move all the files

44 files changed, 1858 insertions, 0 deletions

diff --git a/mut/neovim/README.md b/mut/neovim/README.md
new file mode 100644
index 0000000..3a441bd
--- /dev/null
+++ b/mut/neovim/README.md
@@ -0,0 +1,2 @@
+# mike_neovim
+installs my neovim config on mac or linux
diff --git a/mut/neovim/compiler/ansible-lint.vim b/mut/neovim/compiler/ansible-lint.vim
new file mode 100644
index 0000000..9427092
--- /dev/null
+++ b/mut/neovim/compiler/ansible-lint.vim
@@ -0,0 +1,11 @@
+if exists('current_compiler')
+  finish
+endif
+let current_compiler = 'go-test'
+
+if exists(':CompilerSet') != 2
+  command -nargs=* CompilerSet setlocal <args>
+endif
+
+CompilerSet makeprg=compile\ ansible-lint
+CompilerSet errorformat=%Z%f:%l\ %m,%Z%f:%l,%E%\\%%(%\\S%\\)%\\@=%m,%C%\\%%(%\\S%\\)%\\@=%m,%-G
diff --git a/mut/neovim/compiler/go-test.vim b/mut/neovim/compiler/go-test.vim
new file mode 100644
index 0000000..61442e5
--- /dev/null
+++ b/mut/neovim/compiler/go-test.vim
@@ -0,0 +1,14 @@
+if exists('current_compiler')
+  finish
+endif
+let current_compiler = 'go-test'
+
+if exists(':CompilerSet') != 2
+  command -nargs=* CompilerSet setlocal <args>
+endif
+
+" %f>%l:%c:%t:%n:%m
+CompilerSet makeprg=go\ test
+CompilerSet errorformat=%.%#:\ %m\ %f:%l,%.%#:\ %m\ at\ %f:%l%.%#,
+
+" vim: sw=2 sts=2 et
diff --git a/mut/neovim/compiler/helm.vim b/mut/neovim/compiler/helm.vim
new file mode 100644
index 0000000..7e4b21d
--- /dev/null
+++ b/mut/neovim/compiler/helm.vim
@@ -0,0 +1,14 @@
+if exists('current_compiler')
+  finish
+endif
+let current_compiler = 'go-test'
+
+if exists(':CompilerSet') != 2
+  command -nargs=* CompilerSet setlocal <args>
+endif
+
+CompilerSet makeprg=compile\ helm\ lint
+CompilerSet errorformat=\[%t%.%#\]%.%#\ template:\ %f:%l:%c:\ %m,
+                        \\[%t%.%#\]\ %f:\ %m,
+
+" vim: sw=2 sts=2 et
diff --git a/mut/neovim/compiler/racket.vim b/mut/neovim/compiler/racket.vim
new file mode 100644
index 0000000..1f98a41
--- /dev/null
+++ b/mut/neovim/compiler/racket.vim
@@ -0,0 +1,26 @@
+if exists('current_compiler')
+  finish
+endif
+let current_compiler = 'go-test'
+
+if exists(':CompilerSet') != 2
+  command -nargs=* CompilerSet setlocal <args>
+endif
+
+" The errorformat can also use vim's regular expression syntax (albeit in a rather awkward way) which gives us a solution to the problem. We can use a non-capturing group and a zero-width assertion to require the presence of these signaling phrases without consuming them. This then allows the %m to pick them up. As plain regular expression syntax this zero-width assertion looks like:
+"
+" \%(undefined reference\|multiple definition\)\@=
+"
+" But in order to use it in efm we need to replace \ by %\ and % by %%
+
+
+CompilerSet makeprg=compile\ racket
+CompilerSet errorformat=\%Z%*\\S%.%#,
+                        \%C\ \ \ %f:%l:%c,
+                        \%C\ \ \ %f:%l:%c:\ %m,
+                        \%C\ \ %.%#%\\%%(module%\\spath:%\\\|at\:%\\\|in\:%\\\|expected\:%\\\|given\:%\\)%\\@=%m,
+                        \%C\ %.%#,
+                        \%E%\\%%(%\\w%\\)%\\@=%f:%*\\d:%*\\d:\ %m,
+                        \%E%*\\f:%*\\d:%*\\d:\ %m,
+                        \%E%\\%%(%\\S%\\+:%\\\|%\.%\\+--%\\)%\\@=%m,
+" vim: sw=2 sts=2 et
diff --git a/mut/neovim/compiler/terragrunt.vim b/mut/neovim/compiler/terragrunt.vim
new file mode 100644
index 0000000..54f94ef
--- /dev/null
+++ b/mut/neovim/compiler/terragrunt.vim
@@ -0,0 +1,21 @@
+if exists('current_compiler')
+  finish
+endif
+let current_compiler = 'go-test'
+
+if exists(':CompilerSet') != 2
+  command -nargs=* CompilerSet setlocal <args>
+endif
+
+" The errorformat can also use vim's regular expression syntax (albeit in a rather awkward way) which gives us a solution to the problem. We can use a non-capturing group and a zero-width assertion to require the presence of these signaling phrases without consuming them. This then allows the %m to pick them up. As plain regular expression syntax this zero-width assertion looks like:
+"
+" \%(undefined reference\|multiple definition\)\@=
+"
+" But in order to use it in efm we need to replace \ by %\ and % by %%
+
+
+CompilerSet makeprg=terragrunt
+CompilerSet errorformat=%.%#level=%t%.%#msg=%f:%l%\\,%c-%*\\d:\ %m,
+                        \%Z%m,
+                        \%E-\ %m\ (at\ %f:%l\\,%c-%*\\d),
+" vim: sw=2 sts=2 et
diff --git a/mut/neovim/debug b/mut/neovim/debug
new file mode 100644
index 0000000..6319340
--- /dev/null
+++ b/mut/neovim/debug
@@ -0,0 +1,8 @@
+~/projects/k8s ~/neovim
+can't find session: kaks@projects-k8s
+direnv: loading ~/projects/k8s/.envrc
+direnv: using flake
+direnv: nix-direnv: using cached dev shell
+make: *** No rule to make target 'envtest'.  Stop.
+direnv: export +AR +AS +CC +CONFIG_SHELL +CXX +ENVTEST +ENVTEST_K8S_VERSION +GOTOOLDIR +HOST_PATH +IN_NIX_SHELL +KUBEBUILDER_ASSETS +LD +LOCALBIN +NIX_BINTOOLS +NIX_BINTOOLS_WRAPPER_TARGET_HOST_x86_64_unknown_linux_gnu +NIX_BUILD_CORES +NIX_CC +NIX_CC_WRAPPER_TARGET_HOST_x86_64_unknown_linux_gnu +NIX_CFLAGS_COMPILE +NIX_ENFORCE_NO_NATIVE +NIX_HARDENING_ENABLE +NIX_INDENT_MAKE +NIX_LDFLAGS +NIX_STORE +NM +OBJCOPY +OBJDUMP +RANLIB +READELF +SIZE +SOURCE_DATE_EPOCH +STRINGS +STRIP +buildInputs +buildPhase +builder +cmakeFlags +configureFlags +depsBuildBuild +depsBuildBuildPropagated +depsBuildTarget +depsBuildTargetPropagated +depsHostHost +depsHostHostPropagated +depsTargetTarget +depsTargetTargetPropagated +doCheck +doInstallCheck +dontAddDisableDepTrack +mesonFlags +nativeBuildInputs +out +outputs +patches +phases +propagatedBuildInputs +propagatedNativeBuildInputs +shell +shellHook +stdenv +strictDeps +system ~PATH ~XDG_DATA_DIRS ~name
+~/neovim
diff --git a/mut/neovim/fnl/conf/diagnostic.fnl b/mut/neovim/fnl/conf/diagnostic.fnl
new file mode 100644
index 0000000..7ef1dd3
--- /dev/null
+++ b/mut/neovim/fnl/conf/diagnostic.fnl
@@ -0,0 +1,16 @@
+(fn m [mode key cb]
+  (vim.keymap.set mode key cb {:silent true :noremap true}))
+
+(m :n :<leader>ge (fn []
+                    (vim.diagnostic.open_float)))
+
+(vim.diagnostic.config {:virtual_text false})
+
+(vim.keymap.set :n :<Leader>l (let [l (require :lsp_lines)]
+                                l.toggle)
+                {:desc "Toggle lsp_lines"})
+
+(vim.api.nvim_set_hl 0 :VirtualTextWarning {:link :Grey})
+(vim.api.nvim_set_hl 0 :VirtualTextError {:link :DiffDelete})
+(vim.api.nvim_set_hl 0 :VirtualTextInfo {:link :DiffChange})
+(vim.api.nvim_set_hl 0 :VirtualTextHint {:link :DiffAdd})
diff --git a/mut/neovim/fnl/conf/events.fnl b/mut/neovim/fnl/conf/events.fnl
new file mode 100644
index 0000000..00d75d4
--- /dev/null
+++ b/mut/neovim/fnl/conf/events.fnl
@@ -0,0 +1,32 @@
+(vim.api.nvim_create_augroup "conf#events" {:clear true})
+(local event vim.api.nvim_create_autocmd)
+
+(event [:BufReadPost] {:pattern ["*"]
+                       :callback (fn []
+                                   (local pattern "'\\s\\+$'")
+                                   (vim.cmd (.. "syn match TrailingWhitespace "
+                                                pattern))
+                                   (vim.cmd "hi link TrailingWhitespace IncSearch"))
+                       :group "conf#events"})
+
+(local vimenter-cwd (vim.fn.getcwd))
+(event [:VimLeave] {:pattern ["*"]
+                    :callback (fn []
+                                (vim.cmd (.. "mksession! " vimenter-cwd
+                                             :/.vimsession.vim)))
+                    :group "conf#events"})
+
+(event [:BufWinEnter :WinEnter]
+       {:pattern ["term://*"]
+        :callback (fn []
+                    (vim.cmd :startinsert))
+        :group "conf#events"})
+
+(event [:BufLeave] {:pattern ["term://*"]
+                    :callback (fn []
+                                (vim.cmd :stopinsert))
+                    :group "conf#events"})
+
+(event [:FileType] {:pattern [:dirvish]
+                    :callback #(vim.cmd "silent! unmap <buffer> <C-p>")
+                    :group "conf#events"})
diff --git a/mut/neovim/fnl/conf/filetype.fnl b/mut/neovim/fnl/conf/filetype.fnl
new file mode 100644
index 0000000..29f64b0
--- /dev/null
+++ b/mut/neovim/fnl/conf/filetype.fnl
@@ -0,0 +1,44 @@
+(fn playbook? [filename]
+  (P filename)
+  (local pattern (vim.regex :^playbook.*))
+  (pattern:match_str filename))
+
+(fn group-vars? [relative-dir]
+  (local pattern (vim.regex :group_vars$))
+  (pattern:match_str relative-dir))
+
+(fn roles? [relative-dir]
+  (local pattern (vim.regex :roles$))
+  (pattern:match_str relative-dir))
+
+(fn task? [relative-file]
+  (local pattern (vim.regex :.*tasks.*))
+  (pattern:match_str relative-file))
+
+(fn ansible-files? [items]
+  (local [item & rest] items)
+  (if (not item) :yaml
+      (task? item) :yaml.ansible
+      (roles? item) :yaml.ansible
+      (group-vars? item) :yaml.ansible
+      (ansible-files? rest)))
+
+(fn yaml-filetype [path buf]
+  (local [repo?]
+         (vim.fs.find :.git
+                      {:upward true
+                       :path (vim.fs.dirname path)
+                       :stop (vim.fs.dirname (vim.loop.cwd))}))
+  (local files (or (not repo?) (icollect [path file-or-dir (vim.fs.dir (vim.fs.dirname repo?)
+                                                                       {:skip #(not= "."
+                                                                                     ($1:sub 1
+                                                                                             1))
+                                                                        :depth 2})]
+                                 (do
+                                   path))))
+  (if (and repo? (playbook? (vim.fn.fnamemodify path ":t"))) :yaml.ansible
+      (and repo? (task? (vim.fn.fnamemodify path ":."))) :yaml.ansible
+      repo? (ansible-files? files)
+      :yaml))
+
+(vim.filetype.add {:extension {:yml yaml-filetype :yaml yaml-filetype}})
diff --git a/mut/neovim/fnl/conf/init.fnl b/mut/neovim/fnl/conf/init.fnl
new file mode 100644
index 0000000..90bc20c
--- /dev/null
+++ b/mut/neovim/fnl/conf/init.fnl
@@ -0,0 +1,172 @@
+(vim.cmd "colorscheme kanagawa-wave")
+(vim.cmd "filetype plugin on")
+(vim.cmd "filetype indent on")
+(vim.cmd "highlight WinSeparator guibg=None")
+(vim.cmd "packadd cfilter")
+
+(require :conf.settings)
+;; (require :conf.pkgs)
+;; (require :conf.lsp)
+;; (require :conf.events)
+;; (require :conf.filetype)
+;; (require :conf.newtab)
+;; (require :conf.nix-develop)
+
+;; (require :conf.diagnostic)
+
+;; TODO: make a function that sets this autocommand: au BufWritePost currentfile :!curl -X POST -d "{\"previewRun\": true, \"yamlOverride\": \"$(cat % | yq -P)\", \"resources\": {\"repositories\": {\"self\": {\"refName\": \"refs/heads/branch\"}}}}" -s -H "Content-Type: application/json" -H "Authorization: Basic $WORK_AZDO_GIT_AUTH" "$WORK_AZDO_GIT_ORG_URL/Stater/_apis/pipelines/pipelineid/preview?api-version=7.1-preview.1" | jq -r '.finalYaml // .' > scratch.yaml
+
+(let [map vim.keymap.set]
+  (map :t :<c-s> "<c-\\><c-n>")
+  ;; pausing and continueing printing output is not necessary inside neovim terminal right?
+  (map :t :<c-q> "<c-\\><c-n>:q<cr>")
+  (map :n :<leader>qo ":copen<cr>")
+  (map :n :<leader>qc ":cclose<cr>")
+  (map :n :<leader>lo ":lopen<cr>")
+  (map :n :<leader>lc ":lclose<cr>")
+  (map :n "[q" ":cprevious<cr>")
+  (map :n "]q" ":cnext<cr>")
+  (map :n "[x" ":lprevious<cr>")
+  (map :n "]x" ":lnext<cr>")
+  (map :n :<c-p> ":Telescope find_files<cr>" {:noremap true})
+  (map :n "`<Backspace>" ":FocusDispatch ")
+  (map :n "`k" ":K9s ")
+  (map :n "`s" ":Ssh ")
+  (map :n :<leader>p ":NewTab<cr>")
+  (map :n :<leader>cf ":tabedit ~/flake|tc ~/flake|G<cr><c-w>o")
+  (map :n :<leader>cn ":tabedit ~/neovim|tc ~/neovim|G<cr><c-w>o"))
+
+(tset _G :P (lambda [...]
+              (let [inspected (icollect [_ v (ipairs [...])]
+                                (vim.inspect v))]
+                (each [_ printer (ipairs inspected)]
+                  (print printer)))))
+
+(local git-worktree (require :git-worktree))
+(git-worktree.setup {:change_directory_command :tcd
+                     :update_on_change true
+                     :autopush true})
+
+(fn append [tbl item]
+  (table.insert tbl item)
+  tbl)
+
+(fn by-newline [lines]
+  (fn iter [items by result]
+    (local [item & rest] items)
+    (if (= item nil) result
+        (= "" item) (iter rest [] (append result by))
+        (iter rest (append by item) result)))
+
+  (ipairs (iter lines [] [])))
+
+(vim.keymap.set [:n] :<leader>w
+                (fn []
+                  (vim.fn.feedkeys ":Worktree switch ")
+                  (local cmp (require :cmp))
+                  (vim.schedule (fn []
+                                  (cmp.close)
+                                  (cmp.complete)))))
+
+(vim.keymap.set [:n] :<leader>W ":Worktree ")
+(fn list-worktrees []
+  (local pworktree (io.popen "git worktree list --porcelain"))
+  (icollect [_ worktree (by-newline (icollect [line (pworktree:lines)]
+                                      line))]
+    (match (icollect [_ line (ipairs worktree)]
+             (vim.split line " "))
+      [[:worktree path] [:HEAD commit] [:branch branch]] (branch:gsub :refs/heads/
+                                                                      ""))))
+
+(fn list-branches []
+  (local pbranch (io.popen "git branch --list -r --format \"%(refname)\""))
+  (icollect [_ ref (ipairs (icollect [line (pbranch:lines)]
+                             (line:gsub :refs/remotes/.+/ "")))]
+    (if (not (= ref :HEAD))
+        ref)))
+
+(vim.api.nvim_create_user_command :Worktree
+                                  (fn [ctx]
+                                    (match ctx.fargs
+                                      [:create tree branch upstream] (git-worktree.create_worktree tree
+                                                                                                   branch
+                                                                                                   upstream)
+                                      [:create tree upstream] (git-worktree.create_worktree tree
+                                                                                            tree
+                                                                                            upstream)
+                                      [:create tree] (git-worktree.create_worktree tree
+                                                                                   tree
+                                                                                   :origin)
+                                      [:switch tree] (git-worktree.switch_worktree tree)
+                                      [:delete tree] (git-worktree.delete_worktree tree)
+                                      _ (vim.notify "not recognized")))
+                                  {:nargs "*"
+                                   :complete (fn [lead cmdline cursor]
+                                               (local cmdline-tokens
+                                                      (vim.split cmdline " "))
+                                               (match cmdline-tokens
+                                                 [:Worktree :create & rest] (list-branches)
+                                                 [:Worktree :switch & rest] (list-worktrees)
+                                                 [:Worktree :delete & rest] (list-worktrees)
+                                                 [:Worktree & rest] [:create
+                                                                     :switch
+                                                                     :delete]))})
+
+(vim.api.nvim_create_user_command :HomeManager
+                                  (fn [ctx]
+                                    (vim.cmd (.. ":Dispatch home-manager switch --impure "
+                                                 (os.getenv :HOME) "/flake#"
+                                                 (. ctx.fargs 1))))
+                                  {:nargs 1})
+
+(vim.api.nvim_create_user_command :Gpush
+                                  (fn [ctx]
+                                    (vim.cmd ":Dispatch git push"))
+                                  {})
+
+(vim.api.nvim_create_user_command :Grunt
+                                  (fn [ctx]
+                                    (match (. ctx.fargs 1)
+                                      :plan (vim.cmd (.. ":Dispatch "
+                                                         (if ctx.bang
+                                                             "TF_LOG=DEBUG "
+                                                             "")
+                                                         "terragrunt "
+                                                         (table.concat ctx.fargs
+                                                                       " ")
+                                                         " " :-out=gruntplan))
+                                      :apply (vim.cmd (.. ":Dispatch "
+                                                          (if ctx.bang
+                                                              "TF_LOG=DEBUG "
+                                                              "")
+                                                          "terragrunt "
+                                                          (table.concat ctx.fargs
+                                                                        " ")
+                                                          " " :gruntplan))
+                                      _ (vim.cmd (.. ":Start "
+                                                     (if ctx.bang
+                                                         "TF_LOG=DEBUG "
+                                                         "")
+                                                     "terragrunt "
+                                                     (table.concat ctx.fargs
+                                                                   " ")))))
+                                  {:nargs "*" :bang true})
+
+(vim.api.nvim_create_user_command :K9s
+                                  (fn [ctx]
+                                    (vim.cmd (.. ":Start k9s --context "
+                                                 (. ctx.fargs 1))))
+                                  {:nargs 1})
+
+(vim.api.nvim_create_user_command :Ssh
+                                  (fn [ctx]
+                                    (vim.cmd (.. ":Start ssh " (. ctx.fargs 1))))
+                                  {:nargs 1
+                                   :complete (fn [lead cmdline cursor]
+                                               (local p
+                                                      (io.popen :get-sshables))
+                                               (local lines
+                                                      (icollect [line (p:lines)]
+                                                        line))
+                                               (p:close)
+                                               lines)})
diff --git a/mut/neovim/fnl/conf/lsp.fnl b/mut/neovim/fnl/conf/lsp.fnl
new file mode 100644
index 0000000..35fa34f
--- /dev/null
+++ b/mut/neovim/fnl/conf/lsp.fnl
@@ -0,0 +1,75 @@
+(fn map-to-capabilities [{: client : buf} format]
+  (fn bo [name value]
+    (vim.api.nvim_buf_set_option buf name value))
+
+  (fn bm [mode key cb]
+    (vim.keymap.set mode key cb {:silent true :noremap true :buffer buf}))
+
+  (fn lspdo [action]
+    (. vim.lsp.buf action))
+
+  (fn use [cpb]
+    (match cpb
+      :completionProvider (bo :omnifunc "v:lua.vim.lsp.omnifunc")
+      :renameProvider (bm :n :<leader>gr (lspdo :rename))
+      :signatureHelpProvider (bm :n :<leader>gs (lspdo :signature_help))
+      :definitionProvider (bm :n :<leader>gd (lspdo :definition))
+      :declaration (bm :n :<leader>gD (lspdo :declaration))
+      :implementationProvider (bm :n :<leader>gi (lspdo :implementation))
+      :referencesProvider (bm :n :<leader>gg (lspdo :references))
+      :documentSymbolProvider (bm :n :<leader>gds (lspdo :workspace_symbol))
+      :codeActionProvider (bm :n :<leader>ga (lspdo :code_action))
+      :codeLensProvider (bm :n :<leader>gl
+                            (lambda []
+                              (vim.lsp.codelens.run)))
+      :hoverProvider (bo :keywordprg ":LspHover")
+      :documentFormattingProvider (if format
+                                      ((fn []
+                                         (bo :formatexpr
+                                             "v:lua.vim.lsp.format()")
+                                         (bm :n :<leader>gq
+                                             #(vim.lsp.buf.format {:async true})))))))
+
+  (each [cpb enabled? (pairs client.server_capabilities)]
+    (if enabled?
+        (use cpb)))
+  {: client : buf})
+
+(fn register-handlers [{: client : buf}]
+  (tset (. client :handlers) :textDocument/publishDiagnostics
+        (vim.lsp.with (fn [_ result ctx config]
+                        (vim.lsp.diagnostic.on_publish_diagnostics _ result ctx
+                                                                   config)
+                        (vim.diagnostic.setloclist {:open false}))
+          {:virtual_text true
+           :underline true
+           :update_in_insert false
+           :severity_sort true}))
+  {: client : buf})
+
+(var format-on-save true)
+(fn toggle-format-on-save []
+  (set format-on-save (not format-on-save)))
+
+(vim.api.nvim_create_user_command :LspToggleOnSave toggle-format-on-save
+                                  {:nargs 1 :complete (fn [] [:format])})
+
+(fn events [{: client : buf}]
+  (match client.server_capabilities
+    {:documentFormattingProvider true}
+    (let [format-events-group (vim.api.nvim_create_augroup :format-events
+                                                           {:clear true})]
+      (vim.api.nvim_create_autocmd [:BufWritePre]
+                                   {:group format-events-group
+                                    :callback (lambda []
+                                                (if format-on-save
+                                                    (vim.lsp.buf.format)))
+                                    :buffer buf}))))
+
+(fn attach [client buf format]
+  (-> {: client : buf}
+      (register-handlers)
+      (map-to-capabilities format)
+      (events)))
+
+{: attach}
diff --git a/mut/neovim/fnl/conf/macros.fnl b/mut/neovim/fnl/conf/macros.fnl
new file mode 100644
index 0000000..9ce8b26
--- /dev/null
+++ b/mut/neovim/fnl/conf/macros.fnl
@@ -0,0 +1,45 @@
+(fn by-two [l]
+  (fn iter [t i]
+    (let [k (. l (- i 1))
+          v (. l i)]
+      (when (and (not= k nil) (not= v nil))
+        (values (+ i 2) [k v]))))
+
+  (values iter l 2))
+
+(fn decode-opt-value [v]
+  (fn symbol-luatype [s]
+    (let [t (tostring s)]
+      (match t
+        :on true
+        :off false
+        _ t)))
+
+  (if (sym? v) (symbol-luatype v) v))
+
+(fn opt-template [o]
+  (fn remove/append [target value mode]
+    `(let [target# (. vim :opt ,target)
+           value# ,value]
+       ,(match mode
+          :append `(target#:append value#)
+          :remove `(target#:remove value#))))
+
+  (fn [v]
+    (match (string.sub o 1 1)
+      "-" (remove/append (string.sub o 2) v :remove)
+      "+" (remove/append (string.sub o 2) v :append)
+      _ `(tset (. vim :opt) ,o ,v))))
+
+(fn settings [...]
+  `,(icollect [_ [o v] (by-two [...])]
+      ((opt-template (tostring o)) (decode-opt-value v))))
+
+(fn globals [...]
+  (local globa (icollect [_ [k v] (by-two [...])]
+                 [(tostring k) v]))
+  `(let [l# ,globa]
+     (each [a# b# (ipairs l#)]
+       (tset (. vim :g) (. b# 1) (. b# 2)))))
+
+{: settings : globals}
diff --git a/mut/neovim/fnl/conf/newtab/init.fnl b/mut/neovim/fnl/conf/newtab/init.fnl
new file mode 100644
index 0000000..fbf8e18
--- /dev/null
+++ b/mut/neovim/fnl/conf/newtab/init.fnl
@@ -0,0 +1,36 @@
+(local pickers (require :telescope.pickers))
+(local finders (require :telescope.finders))
+(local conf (. (require :telescope.config) :values))
+(local themes (require :telescope.themes))
+(local actions (require :telescope.actions))
+(local action_state (require :telescope.actions.state))
+
+(fn colors [opts]
+  (local opts (if opts opts {}))
+  (local finder
+         (pickers.new opts
+                      {:prompt_title :colors
+                       :finder (finders.new_oneshot_job [:fd
+                                                         :-d1
+                                                         "."
+                                                         (os.getenv :HOME)
+                                                         (.. (os.getenv :HOME)
+                                                             :/projects)]
+                                                        {})
+                       :attach_mappings (fn [prompt_buf map]
+                                          (actions.select_default:replace (fn []
+                                                                            (actions.close prompt_buf)
+                                                                            (local selection
+                                                                                   (action_state.get_selected_entry))
+                                                                            (vim.cmd (.. :tabnew
+                                                                                         (. selection
+                                                                                            1)))
+                                                                            (vim.cmd (.. :tc
+                                                                                         (. selection
+                                                                                            1))))))
+                       :sorter (conf.generic_sorter opts)}))
+  (finder:find))
+
+(vim.api.nvim_create_user_command :NewTab (fn [] (colors (themes.get_ivy))) {})
+
+(vim.api.nvim_create_user_command :Colors colors {})
diff --git a/mut/neovim/fnl/conf/nix-develop/init.fnl b/mut/neovim/fnl/conf/nix-develop/init.fnl
new file mode 100644
index 0000000..0983e06
--- /dev/null
+++ b/mut/neovim/fnl/conf/nix-develop/init.fnl
@@ -0,0 +1,122 @@
+(local loop vim.loop)
+
+(var original-env {})
+(local ignored-variables {:SHELL true
+                          :BASHOPTS true
+                          :HOME true
+                          :NIX_BUILD_TOP true
+                          :NIX_ENFORCE_PURITY true
+                          :NIX_LOG_FD true
+                          :NIX_REMOTE true
+                          :PPID true
+                          :SHELL true
+                          :SHELLOPTS true
+                          :SSL_CERT_FILE true
+                          :TEMP true
+                          :TEMPDIR true
+                          :TERM true
+                          :TMP true
+                          :TMPDIR true
+                          :TZ true
+                          :UID true})
+
+(local separated-dirs {:PATH ":" :XDG_DATA_DIRS ":"})
+
+(fn set-env [key value]
+  (if (not (. original-env key))
+      (tset original-env key (or (. vim.env key) :nix-develop-nil)))
+  (local sep (. separated-dirs key))
+  (if sep
+      (do
+        (local suffix (or (. vim.env key) ""))
+        (tset vim.env key (.. value sep suffix)))
+      (tset vim.env key value)))
+
+(fn unload-env []
+  (each [k v (pairs original-env)]
+    (if (= v :nix-develop-nil)
+        (tset vim.env k nil)
+        (tset vim.env k v))))
+
+(fn ignored? [key]
+  (. ignored-variables (string.upper key)))
+
+(fn exported? [Type]
+  (= Type :exported))
+
+(fn handle-shellhook [shellhook] ; (P :handle-shellhook shellhook)
+  (var shellhook-env "")
+  (local stdin (loop.new_pipe))
+  (local stdout (loop.new_pipe))
+  (local p
+         (loop.spawn :bash {:stdio [stdin stdout nil]}
+                     (fn [code signal]
+                       (vim.schedule #(vim.notify (.. "shellhook: exit code "
+                                                      code " " signal))))))
+  (loop.read_start stdout
+                   (fn [err data]
+                     (assert (not err) err)
+                     (if data
+                         (set shellhook-env (.. shellhook-env data))
+                         (do
+                           (if (not= shellhook-env "")
+                               (vim.schedule (fn []
+                                               (local json
+                                                      (vim.fn.json_decode shellhook-env))
+                                               ; (P json)
+                                               (each [key value (pairs json)]
+                                                 (set-env key value)))))))))
+  (stdin:write (.. shellhook "jq -n 'env'\n\n"))
+  (stdin:close))
+
+(fn handle-nix-print-dev-env [str]
+  (vim.schedule (fn []
+                  (local json (. (vim.fn.json_decode str) :variables))
+                  (-> (icollect [key {: type : value} (pairs json)]
+                        (do
+                          (if (and (exported? type) (not (ignored? key)))
+                              (set-env key value))
+                          (if (= key :shellHook)
+                              value)))
+                      (#(each [_ shellhook (ipairs $1)]
+                          (handle-shellhook shellhook)))))))
+
+(fn nix-develop [fargs unload]
+  (if unload
+      (unload-env))
+  (local cmd :nix)
+  (local fargs (or fargs []))
+  (local args [:print-dev-env :--json (unpack fargs)])
+  (local stdout (loop.new_pipe))
+  (local stdio [nil stdout nil])
+  (var nix-print-dev-env "")
+  (local p
+         (loop.spawn cmd {: args : stdio}
+                     (fn [code signal]
+                       (if (not= code 0)
+                           (vim.schedule #(vim.notify (.. "nix-develop: exit code "
+                                                          code " " signal)))))))
+  (loop.read_start stdout
+                   (fn [err data]
+                     (assert (not err) err)
+                     (if data
+                         (set nix-print-dev-env (.. nix-print-dev-env data))
+                         (do
+                           (vim.schedule #(vim.notify "nix-develop: stdout end"))
+                           (if (not= nix-print-dev-env "")
+                               (handle-nix-print-dev-env nix-print-dev-env)))))))
+
+(vim.api.nvim_create_user_command :NixDevelop
+                                  (fn [ctx]
+                                    (nix-develop ctx.fargs true))
+                                  {:nargs "*"})
+
+(vim.api.nvim_create_augroup :nix-develop {:clear true})
+(vim.api.nvim_create_autocmd [:DirChanged :VimEnter]
+                             {:pattern ["*"]
+                              :callback (fn [ctx]
+                                          (unload-env)
+                                          (if (= 1
+                                                 (vim.fn.filereadable (.. ctx.file
+                                                                          :/flake.nix)))
+                                              (nix-develop false)))})
diff --git a/mut/neovim/fnl/conf/pkgs.fnl b/mut/neovim/fnl/conf/pkgs.fnl
new file mode 100644
index 0000000..1445454
--- /dev/null
+++ b/mut/neovim/fnl/conf/pkgs.fnl
@@ -0,0 +1,15 @@
+;; (require :conf.pkgs.cmp)
+
+;; (require :conf.pkgs.null-ls)
+;; (require :conf.pkgs.lspconfig)
+;; (require :conf.pkgs.treesitter)
+;; (require :conf.pkgs.tree-sitter-context)
+;; (require :conf.pkgs.conjure)
+;; (require :conf.pkgs.test)
+;; (require :conf.pkgs.lsp_lines)
+;; (require :conf.pkgs.noice)
+;; (require :conf.pkgs.dap)
+;; (require :conf.pkgs.heirline)
+;; (require :conf.pkgs.gitsigns)
+;; (require :conf.pkgs.harpoon)
+;; (require :conf.pkgs.venn)
diff --git a/mut/neovim/fnl/conf/pkgs/cmp.fnl b/mut/neovim/fnl/conf/pkgs/cmp.fnl
new file mode 100644
index 0000000..76319f4
--- /dev/null
+++ b/mut/neovim/fnl/conf/pkgs/cmp.fnl
@@ -0,0 +1,114 @@
+(local cmp (require :cmp))
+(local compare (require :cmp.config.compare))
+(local always-first [:write :edit :split :quit :cfirst])
+
+(fn string-startswith? [str start]
+  (= start (string.sub str 1 (string.len start))))
+
+(fn string-startswith-anyof? [str start-list]
+  (fn iter [[item & rest]]
+    (if (not item) false
+        (string-startswith? str item) true
+        (iter rest)))
+
+  (iter start-list))
+
+(fn string-startswith-upper? [str]
+  (local first-char (string.sub str 1 1))
+  (= first-char (string.upper first-char)))
+
+(fn has-words-before? []
+  (local [line col] (vim.api.nvim_win_get_cursor 0))
+  (local [word & rest] (vim.api.nvim_buf_get_lines 0 (- line 1) line true))
+  (local before (word:sub col col))
+  (local is_string (before:match "%s"))
+  (and (not= col 0) (= is_string nil)))
+
+(fn enum [types key]
+  (. (. cmp types) key))
+
+(fn cmp-setup [cmp autocomplete]
+  (let [luasnip (require :luasnip)
+        snip (fn [args]
+               (luasnip.lsp_expand (. args :body)))]
+    (local cfg
+           {:experimental {:ghost_text true}
+            :snippet {:expand snip}
+            :preselect cmp.PreselectMode.None
+            :mapping {:<Tab> (cmp.mapping (fn [fallback]
+                                            (if (cmp.visible)
+                                                (cmp.select_next_item)
+                                                (luasnip.expand_or_jumpable)
+                                                (luasnip.expand_or_jump)
+                                                (has-words-before?)
+                                                (cmp.complete)
+                                                (fallback))
+                                            [:i :s]))
+                      :<S-Tab> (cmp.mapping (fn [fallback]
+                                              (if (cmp.visible)
+                                                  (cmp.select_prev_item)
+                                                  (luasnip.jumpable -1)
+                                                  (luasnip.jump -1)
+                                                  (fallback))
+                                              [:i :s]))
+                      :<C-b> (cmp.mapping.scroll_docs -4)
+                      :<C-f> (cmp.mapping.scroll_docs 4)
+                      :<C-j> (cmp.mapping.complete)
+                      :<CR> (cmp.mapping.confirm {:behavior (enum :ConfirmBehavior
+                                                                  :Replace)
+                                                  :select true})}
+            :sources (cmp.config.sources [{:name :nvim_lsp}
+                                          {:name :path}
+                                          {:name :luasnip}])})
+    (if (not autocomplete) (tset cfg :completion {:autocomplete false}))
+    ;; (print (vim.inspect cfg))
+    (cmp.setup cfg)
+    (cmp.setup.cmdline ["/" "?"]
+                       {:sources (cmp.config.sources [{:name :buffer}])
+                        :experimental {:ghost_text true}
+                        :mapping (cmp.mapping.preset.cmdline)})
+    (cmp.setup.cmdline ":"
+                       {:matching {:disallow_partial_fuzzy_matching true
+                                   :disallow_prefix_unmatching true}
+                        :sources (cmp.config.sources [{:name :path}]
+                                                     [{:name :cmdline
+                                                       :keyword_length 1}])
+                        :preselect cmp.PreselectMode.Item
+                        :sorting {:priority_weight 2
+                                  :comparators [(fn [e1 e2]
+                                                  (fn iter [[item & rest]]
+                                                    (if (or (not rest)
+                                                            (not item))
+                                                        false
+                                                        (= e1.completion_item.label
+                                                           item)
+                                                        true
+                                                        (iter rest)))
+
+                                                  (iter always-first))
+                                                compare.offset
+                                                compare.exact
+                                                compare.score
+                                                compare.locality
+                                                compare.kind
+                                                compare.length
+                                                compare.order]}
+                        :mapping (cmp.mapping.preset.cmdline {:<CR> {:c (fn [fallback]
+                                                                          (if (not (cmp.confirm {:behavior (enum :ConfirmBehavior
+                                                                                                                 :Replace)
+                                                                                                 :select true}))
+                                                                              (fallback)
+                                                                              (vim.schedule fallback)))}})})))
+
+; {:name :cmdline_history
+;                                                        :keyword_pattern "^[ABCDEFHIJKLMNOPQRSTUVWXYZ].*"
+;                                                        :entry_filter (fn [entry
+;                                                                           ctx]
+;                                                                        (if (string-startswith-upper entry.completion_item.label)
+;                                                                            true
+;                                                                            false))
+;                                                        :max_item_count 1)})))
+;     disallow_fuzzy_matching = false,
+;     disallow_partial_matching = false,
+;     disallow_prefix_unmatching = false,)))
+(cmp-setup cmp true)
diff --git a/mut/neovim/fnl/conf/pkgs/conjure.fnl b/mut/neovim/fnl/conf/pkgs/conjure.fnl
new file mode 100644
index 0000000..c07a6f4
--- /dev/null
+++ b/mut/neovim/fnl/conf/pkgs/conjure.fnl
@@ -0,0 +1,17 @@
+(tset vim.g "conjure#log#wrap" true)
+
+(tset vim.g "conjure#client#python#stdio#command" "python -iq")
+
+(vim.api.nvim_create_user_command :ConjurePythonCommand
+                                  (fn [opts]
+                                    (tset vim.g
+                                          "conjure#client#python#stdio#command"
+                                          opts.args))
+                                  {:nargs 1})
+
+(let [group (vim.api.nvim_create_augroup "conf#pkgs#conjure" {:clear true})]
+  (vim.api.nvim_create_autocmd [:BufEnter]
+                               {: group
+                                :callback (fn [opts]
+                                            (vim.diagnostic.disable opts.buf))
+                                :pattern [:conjure-log*]}))
diff --git a/mut/neovim/fnl/conf/pkgs/dap.fnl b/mut/neovim/fnl/conf/pkgs/dap.fnl
new file mode 100644
index 0000000..6476d3e
--- /dev/null
+++ b/mut/neovim/fnl/conf/pkgs/dap.fnl
@@ -0,0 +1,78 @@
+(local dap (require :dap))
+(local adapters (. dap :adapters))
+(local configurations (. dap :configurations))
+
+(local dapui (require :dapui))
+
+(tset adapters :delve
+      {:type :server
+       :port "${port}"
+       :executable {:command :dlv :args [:dap :-l "127.0.0.1:${port}"]}})
+
+(tset configurations :go
+      [{:type :delve
+        :name :Debug
+        :request :launch
+        :env {:CGO_CFLAGS :-Wno-error=cpp}
+        :program "${file}"}
+       {:type :delve
+        :name :DebugTest
+        :request :launch
+        :mode :test
+        :env {:CGO_CFLAGS :-Wno-error=cpp}
+        :program "${file}"}
+       {:type :delve
+        :name :DebugTerraform
+        :request :launch
+        :program "${file}"
+        :env {:CGO_CFLAGS :-Wno-error=cpp}
+        :args [:-debug]}
+       {:type :delve
+        :name :DebugTerraformAcc
+        :request :launch
+        :program "${file}"
+        :mode :test
+        :env {:CGO_CFLAGS :-Wno-error=cpp :TF_ACC :1}}
+       {:type :delve
+        :name :DebugTestSuite
+        :request :launch
+        :mode :test
+        :env {:CGO_CFLAGS :-Wno-error=cpp}
+        :program "${fileDirname}"}])
+
+(dapui.setup {:expand_lines false})
+
+(vim.keymap.set :n :si (lambda []
+                         (dapui.toggle {:reset true})) {:silent true})
+;;     "breakpoints",
+;;     "repl",
+;;     "scopes",
+;;     "stacks",
+;;     "watches",
+;;     "hover",
+;;     "console",)
+(vim.keymap.set :n :sfw
+                (lambda []
+                  (dapui.float_element :watches
+                                       {:width (vim.api.nvim_win_get_width 0) :height 30 :enter true})))
+(vim.keymap.set :n :sfs
+                (lambda []
+                  (dapui.float_element :scopes
+                                       {:width (vim.api.nvim_win_get_width 0) :height 30 :enter true})))
+
+(vim.keymap.set :n :sq dap.terminate {:silent true})
+(vim.keymap.set :n :sc dap.continue {:silent true})
+(vim.keymap.set :n :sr dap.run_to_cursor {:silent true})
+(vim.keymap.set :n :sn dap.step_over {:silent true})
+(vim.keymap.set :n :ss dap.step_into {:silent true})
+(vim.keymap.set :n :so dap.step_out {:silent true})
+(vim.keymap.set :n :sb dap.toggle_breakpoint {:silent true})
+(vim.keymap.set :n :sB dap.set_breakpoint {:silent true})
+(vim.keymap.set :n :slp
+                (fn []
+                  (dap.set_breakpoint nil nil
+                                      (vim.fn.input "Log point message: ")))
+                {:silent true})
+
+(vim.keymap.set :n :st dap.repl.toggle {:silent true})
+(vim.keymap.set :n :sl dap.run_last {:silent true})
diff --git a/mut/neovim/fnl/conf/pkgs/gitsigns.fnl b/mut/neovim/fnl/conf/pkgs/gitsigns.fnl
new file mode 100644
index 0000000..813d410
--- /dev/null
+++ b/mut/neovim/fnl/conf/pkgs/gitsigns.fnl
@@ -0,0 +1,2 @@
+(local gitsigns (require :gitsigns))
+(gitsigns.setup)
diff --git a/mut/neovim/fnl/conf/pkgs/harpoon.fnl b/mut/neovim/fnl/conf/pkgs/harpoon.fnl
new file mode 100644
index 0000000..3f5fc48
--- /dev/null
+++ b/mut/neovim/fnl/conf/pkgs/harpoon.fnl
@@ -0,0 +1,39 @@
+(local harpoon-mark (require :harpoon.mark))
+(local harpoon-ui (require :harpoon.ui))
+(fn make-harpoon [func]
+  (fn []
+    (func)
+    (vim.cmd :redrawtabline)))
+
+(vim.keymap.set :n "[]" (make-harpoon (fn [] (harpoon-mark.add_file))))
+(vim.keymap.set :n "][" (make-harpoon (fn [] (harpoon-ui.toggle_quick_menu))))
+(vim.keymap.set :n "]]" (make-harpoon (fn [] (harpoon-ui.nav_next))))
+(vim.keymap.set :n "[[" (make-harpoon (fn [] (harpoon-ui.nav_prev))))
+
+(var use-numbers false)
+(local num [1 2 3 4 5])
+(local shortcuts ["+" "-" "<" ">" "\""])
+(fn print-use-numbers []
+  (print (vim.inspect use-numbers)))
+
+(fn toggle-harpoon-mappings []
+  (if (not use-numbers)
+      (do
+        ; (each [_ i (ipairs shortcuts)] ;   (vim.keymap.del :n i))
+        (vim.keymap.set :n "[+" (make-harpoon (fn [] (harpoon-ui.nav_file 1))))
+        (vim.keymap.set :n "[-" (make-harpoon (fn [] (harpoon-ui.nav_file 2))))
+        (vim.keymap.set :n "[<" (make-harpoon (fn [] (harpoon-ui.nav_file 3))))
+        (vim.keymap.set :n "[>" (make-harpoon (fn [] (harpoon-ui.nav_file 4))))
+        (vim.keymap.set :n "[\"" (make-harpoon (fn [] (harpoon-ui.nav_file 5))))
+        (set use-numbers true))
+      (do
+        ; (each [_ s (ipairs shortcuts)] ;   (vim.keymap.del :n s)
+        (vim.keymap.set :n "[1" (make-harpoon (fn [] (harpoon-ui.nav_file 1))))
+        (vim.keymap.set :n "[2" (make-harpoon (fn [] (harpoon-ui.nav_file 2))))
+        (vim.keymap.set :n "[3" (make-harpoon (fn [] (harpoon-ui.nav_file 3))))
+        (vim.keymap.set :n "[4" (make-harpoon (fn [] (harpoon-ui.nav_file 4))))
+        (vim.keymap.set :n "[5" (make-harpoon (fn [] (harpoon-ui.nav_file 5))))
+        (set use-numbers false))))
+
+(vim.api.nvim_create_user_command :H toggle-harpoon-mappings {})
+(toggle-harpoon-mappings)
diff --git a/mut/neovim/fnl/conf/pkgs/heirline.fnl b/mut/neovim/fnl/conf/pkgs/heirline.fnl
new file mode 100644
index 0000000..c8d9c52
--- /dev/null
+++ b/mut/neovim/fnl/conf/pkgs/heirline.fnl
@@ -0,0 +1,241 @@
+(local heirline (require :heirline))
+(local conditions (require :heirline.conditions))
+(local utils (require :heirline.utils))
+(local colors (let [kanagawa-colors (require :kanagawa.colors)]
+                (kanagawa-colors.setup)))
+
+(local Align {:provider "%="})
+(local Space {:provider " "})
+(fn with [tbl with-kv]
+  (local w {})
+  (each [k v (pairs tbl)]
+    (tset w k v))
+  (each [k v (pairs with-kv)]
+    (tset w k v))
+  w)
+
+(heirline.load_colors colors)
+(fn palette [name]
+  (. colors :palette name))
+
+(fn theme [theme name]
+  (. colors :theme theme name))
+
+(var FileNameBlock
+     {;; let's first set up some attributes needed by this component and it's children
+      :init (lambda [self]
+              (tset self :filename (vim.api.nvim_buf_get_name 0)))})
+
+(local FileName
+       {:provider (lambda [self]
+                    ;; first, trim the pattern relative to the current directory. For other
+                    ;;- options, see :h filename-modifers
+                    (var filename (vim.fn.fnamemodify (. self :filename) ":."))
+                    (if (= filename "")
+                        (set filename "[No Name]")
+                        ;;- now, if the filename would occupy more than 1/4th of the available
+                        ;;-- space, we trim the file path to its initials
+                        ;;-- See Flexible Components section below for dynamic truncation
+                        (if (not (conditions.width_percent_below (length filename)
+                                                                 0.25))
+                            (set filename (vim.fn.pathshorten filename))))
+                    filename)
+        :hl {:fg (. (utils.get_highlight :Directory) :fg)}})
+
+(local FileNameModifier {:hl (lambda []
+                               (when vim.bo.modified
+                                 {:fg (theme :diag :warning)
+                                  :bold true
+                                  :force true}))})
+
+(local FileFlags [{:condition (lambda [] vim.bo.modified)
+                   :provider "[+]"
+                   :hl {:fg (theme :diag :warning)}}])
+
+(set FileNameBlock (utils.insert FileNameBlock
+                                 (utils.insert FileNameModifier FileName)
+                                 FileFlags {:provider "%<"}))
+
+(local DAPMessages {:condition (lambda []
+                                 (local dap (require :dap))
+                                 (local session (dap.session))
+                                 (not (= session nil)))
+                    :provider (lambda []
+                                (local dap (require :dap))
+                                (.. " " (dap.status)))
+                    :hl :Debug})
+
+(local Ruler {;; %l = current line number
+              ;; %L = number of lines in the buffer
+              ;; %c = column number
+              ;; %P = percentage through file of displayed window
+              :provider "%7(%l/%3L%):%2c %P"})
+
+(local ScrollBar
+       {:static {:sbar ["▁" "▂" "▃" "▄" "▅" "▆" "▇" "█"]}
+        ;; Another variant, because the more choice the better.
+        ;; sbar { '🭶', '🭷', '🭸', '🭹', '🭺', '🭻'}}
+        :provider (lambda [self]
+                    (local curr_line (. (vim.api.nvim_win_get_cursor 0) 1))
+                    (local lines (vim.api.nvim_buf_line_count 0))
+                    (local i
+                           (- (length self.sbar)
+                              (math.floor (* (/ (- curr_line 1) lines)
+                                             (length (. self :sbar))))))
+                    (string.rep (. self :sbar i) 2))
+        :hl {:fg (theme :syn :fun) :bg (theme :ui :bg)}})
+
+(local Nix
+       {:condition (fn [] vim.env.IN_NIX_SHELL)
+        :provider (fn [self]
+                    (local purity vim.env.IN_NIX_SHELL)
+                    (local name vim.env.name)
+                    (.. "" purity "(" name ")"))
+        :hl {:fg (theme :syn :fun) :bold true :bg (theme :ui :bg_m3)}})
+
+(local RecordingMacro {:condition #(not= "" (vim.fn.reg_recording))
+                       :provider (fn [self]
+                                   (.. "Recording... " (vim.fn.reg_recording)))
+                       :hl {:fg (theme :syn :fun)
+                            :bold true
+                            :bg (theme :ui :bg_m3)}})
+
+(local harpoon (require :harpoon))
+(local harpoon-mark (require :harpoon.mark))
+(local harpoon-colors [(theme :syn :identifier)
+                       (theme :syn :identifier)
+                       (theme :syn :identifier)])
+
+(fn mark-component [i mark]
+  (utils.insert {} {:hl {:bg (if (= mark.filename
+                                    (vim.fn.fnamemodify (vim.api.nvim_buf_get_name 0)
+                                                        ":."))
+                                 (theme :ui :bg_p1)
+                                 (theme :ui :bg_m1))
+                         :bold true
+                         :fg (. harpoon-colors i)}
+                    :provider (fn [self]
+                                (.. " M" i " "))}))
+
+;{:hl {:fg (theme :syn :fun)} :provider (vim.fn.pathshorten mark.filename)}))
+; {:hl {:bold true :fg (. harpoon-colors i)} :provider ")"} Space))
+
+(local HarpoonMarks
+       (utils.insert {:hl :TabLineSel
+                      :condition #(< 0
+                                     (length (. (harpoon.get_mark_config)
+                                                :marks)))}
+                     {:init (lambda [self]
+                              (local mark-list
+                                     (. (harpoon.get_mark_config) :marks))
+                              (each [i mark (ipairs mark-list)]
+                                (tset self i
+                                      (self:new (mark-component i mark) i)))
+                              (while (> (length self) (length mark-list))
+                                (table.remove self (length self))))}))
+
+(local Tabpage
+       {:provider (lambda [self]
+                    (fn fnamemod [name mod]
+                      (vim.fn.fnamemodify name mod))
+
+                    (fn format-name [name]
+                      (if (= name "") "[No Name]"
+                          (fnamemod name ":t")))
+
+                    (.. "%" self.tabnr "T " self.tabnr " "))
+        :hl (lambda [self]
+              (if (not self.is_active) :TabLine :TabLineSel))})
+
+(fn active-tab-hrpn [self]
+  (local hl {})
+  (if (. self :is_active)
+      (do
+        (tset hl :fg (theme :syn :identifier))
+        (tset hl :bold true)))
+  hl)
+
+(fn active-hl [hl]
+  (lambda [self]
+    (if self.is_active
+        hl
+        {})))
+
+(fn tab-visible-buffers [tab]
+  (local visible (vim.fn.tabpagebuflist tab))
+  (if (= visible 0)
+      []
+      visible))
+
+(fn tab-harpoon-marks [tab]
+  (local visible (tab-visible-buffers tab))
+  (local tab-buffers (accumulate [buffers [] _ buf (ipairs visible)]
+                       (do
+                         (if (not (vim.tbl_contains buffers buf))
+                             (table.insert buffers buf))
+                         buffers)))
+  (icollect [_ buf (ipairs tab-buffers)]
+    (do
+      (local status (harpoon-mark.status buf))
+      (if (not= status "")
+          status))))
+
+(local Tabpage
+       (utils.insert Tabpage {:hl active-tab-hrpn :provider "🌊 [ "}
+                     {:hl (active-hl {:fg (theme :syn :fun)})
+                      :provider (lambda [self]
+                                  (local harpoon_marks
+                                         (tab-harpoon-marks self.tabnr))
+                                  (table.concat harpoon_marks " "))}
+                     {:hl active-tab-hrpn :provider " ] %T"}))
+
+(local TabpageClose {:provider "%999X  %X" :hl :TabLine})
+
+(local TabPages
+       {;; only show this component if there's 2 or more tabpages
+        :condition (lambda []
+                     (>= (length (vim.api.nvim_list_tabpages)) 1))})
+
+(local TabPages (utils.insert TabPages (utils.make_tablist Tabpage)
+                              TabpageClose))
+
+(local dispatch-get-request (. vim.fn "dispatch#request"))
+(local Dispatch (utils.insert {:init (fn [self]
+                                       (set self.req (dispatch-get-request)))
+                               :condition (fn []
+                                            (not (vim.tbl_isempty (dispatch-get-request))))}
+                              {:provider "dispatch("
+                               :hl (fn [self]
+                                     {:fg (if (= 1 self.req.completed)
+                                              (theme :syn :fun)
+                                              (theme :diag :warning))
+                                      :bold true})}
+                              {:provider (fn [self]
+                                           self.req.command)
+                               :hl {:fg (theme :syn :string) :bold false}}
+                              {:provider ")"
+                               :hl (fn [self]
+                                     {:fg (if (= 1 self.req.completed)
+                                              (theme :syn :fun)
+                                              (theme :diag :warning))
+                                      :bold true})}))
+
+(local StatusLine [FileNameBlock
+                   Space
+                   HarpoonMarks
+                   Space
+                   TabPages
+                   DAPMessages
+                   Space
+                   RecordingMacro
+                   Dispatch
+                   Align
+                   Space
+                   Nix
+                   Space
+                   Ruler
+                   Space
+                   ScrollBar
+                   Space])
+
+(heirline.setup {:statusline StatusLine})
diff --git a/mut/neovim/fnl/conf/pkgs/lsp_lines.fnl b/mut/neovim/fnl/conf/pkgs/lsp_lines.fnl
new file mode 100644
index 0000000..7194bd9
--- /dev/null
+++ b/mut/neovim/fnl/conf/pkgs/lsp_lines.fnl
@@ -0,0 +1,2 @@
+(let [l (require :lsp_lines)]
+  (l.setup))
diff --git a/mut/neovim/fnl/conf/pkgs/lsp_signature.fnl b/mut/neovim/fnl/conf/pkgs/lsp_signature.fnl
new file mode 100644
index 0000000..7fecc9e
--- /dev/null
+++ b/mut/neovim/fnl/conf/pkgs/lsp_signature.fnl
@@ -0,0 +1,3 @@
+(local lsp_signature (require :lsp_signature))
+
+(lsp_signature.setup)
diff --git a/mut/neovim/fnl/conf/pkgs/lspconfig.fnl b/mut/neovim/fnl/conf/pkgs/lspconfig.fnl
new file mode 100644
index 0000000..accd001
--- /dev/null
+++ b/mut/neovim/fnl/conf/pkgs/lspconfig.fnl
@@ -0,0 +1,51 @@
+(local lspconfig (require :lspconfig))
+(local configs (require :lspconfig.configs))
+(local {: attach} (require :conf.lsp))
+
+(lspconfig.pyright.setup {:root_dir (lspconfig.util.root_pattern :.git
+                                                                 (vim.fn.getcwd))
+                          :on_attach attach})
+
+(lspconfig.tsserver.setup {:root_dir (lspconfig.util.root_pattern :.git
+                                                                  (vim.fn.getcwd))
+                           :on_attach attach})
+
+(local pid (vim.fn.getpid))
+(lspconfig.omnisharp.setup {:cmd [:OmniSharp
+                                  :--languageserver
+                                  :--hostPID
+                                  (tostring pid)]
+                            :handlers {[:textDocument/definition] (. (require :omnisharp_extended)
+                                                                     :handler)}
+                            :root_dir (lspconfig.util.root_pattern :.git
+                                                                   (vim.fn.getcwd))
+                            :on_attach attach})
+
+(lspconfig.gopls.setup {:root_dir (lspconfig.util.root_pattern :.git
+                                                               (vim.fn.getcwd))
+                        :on_attach attach
+                        :settings {:gopls {:codelenses {:test true :bench true}
+                                           ;;  Show a code lens toggling the display of gc's choices.}
+                                           :buildFlags [:-tags=all]}}})
+
+(lspconfig.ansiblels.setup {:ansible {:ansible {:path :ansible}
+                                      :executionEnvironment {:enabled false}
+                                      :python {:interpreterPath :python}
+                                      :validation {:enabled true
+                                                   :lint {:enabled false
+                                                          :arguments " --profile=production --write=all "
+                                                          :path :ansible-lint}}}})
+
+;; (tset configs :fennel_language_server
+;;       {:default_config {;; replace it with true path
+;;                         :cmd [:fennel-language-server]
+;;                         :filetypes [:fennel]
+;;                         :single_file_support true
+;;                         ;; source code resides in directory `fnl/`
+;;                         :root_dir (lspconfig.util.root_pattern :fnl)
+;;                         :settings {:fennel {:workspace {;; If you are using hotpot.nvim or aniseed,
+;;                                                         ;; make the server aware of neovim runtime files.
+;;                                                         :library (vim.api.nvim_list_runtime_paths)}
+;;                                             :diagnostics {:globals [:vim]}}}}})
+;;
+;; (lspconfig.fennel_language_server.setup {:on_attach attach})
diff --git a/mut/neovim/fnl/conf/pkgs/neotest.fnl b/mut/neovim/fnl/conf/pkgs/neotest.fnl
new file mode 100644
index 0000000..251cdcb
--- /dev/null
+++ b/mut/neovim/fnl/conf/pkgs/neotest.fnl
@@ -0,0 +1,4 @@
+(let [nt (require :neotest)
+      python (require :neotest-python)]
+  (nt.setup {:adapters [(python {:dap {:justMyCode false}})]}))
+
diff --git a/mut/neovim/fnl/conf/pkgs/noice.fnl b/mut/neovim/fnl/conf/pkgs/noice.fnl
new file mode 100644
index 0000000..58ac761
--- /dev/null
+++ b/mut/neovim/fnl/conf/pkgs/noice.fnl
@@ -0,0 +1,34 @@
+(local noice (require :noice))
+(noice.setup {:views {:cmdline_popup {:border {:style :none :padding [1 3]}
+                                      :win_options {:winhighlight "NormalFloat:NormalFloat,FloatBorder:FloatBorder"}}}
+              :lsp {;; override markdown rendering so that **cmp** and other plugins use **Treesitter**
+                    :override {[:vim.lsp.util.convert_input_to_markdown_lines] true
+                               [:vim.lsp.util.stylize_markdown] true
+                               [:cmp.entry.get_documentation] true}}
+              :popupmenu {:enabled false}
+              :messages {; NOTE: If you enable messages then the cmdline is enabled automatically.
+                         ; This is a current Neovim limitation.
+                         :enabled true
+                         ; enables the Noice messages UI
+                         :view :mini
+                         ; default view for messages
+                         :view_error :mini
+                         ; view for errors
+                         :view_warn :mini
+                         ; view for warnings
+                         :view_history :mini
+                         ; view for :messages
+                         :view_search :virtualtext}
+              ; view for search count messages. Set to `false` to disable}
+              ;; you can enable a preset for easier configuration
+              :presets {:bottom_search true
+                        ; use a classic bottom cmdline for search
+                        :command_palette true
+                        ; position the cmdline and popupmenu together
+                        :long_message_to_split true
+                        ; long messages will be sent to a split
+                        :inc_rename false
+                        ; enables an input dialog for inc-rename.nvim
+                        :lsp_doc_border false}})
+
+; add a border to hover docs and signature help}})
diff --git a/mut/neovim/fnl/conf/pkgs/null-ls.fnl b/mut/neovim/fnl/conf/pkgs/null-ls.fnl
new file mode 100644
index 0000000..9908823
--- /dev/null
+++ b/mut/neovim/fnl/conf/pkgs/null-ls.fnl
@@ -0,0 +1,21 @@
+(local lsp-conf (require :conf.lsp))
+(local null-ls (require :null-ls))
+
+(local fmt null-ls.builtins.formatting)
+(local diag null-ls.builtins.diagnostics)
+
+(fn executable? [program]
+  (fn []
+    (= 1 (vim.fn.executable program))))
+
+(null-ls.setup {:update_in_insert false
+                :debug true
+                :on_attach (fn [client buf]
+                             (lsp-conf.attach client buf true))
+                :sources [fmt.alejandra
+                          fmt.fnlfmt
+                          (fmt.black.with {:condition (executable? :black)})
+                          (fmt.goimports.with {:condition (executable? :goimports)})
+                          (fmt.gofumpt.with {:condition (executable? :gofumpt)})
+                          (fmt.raco_fmt.with {:condition (executable? :raco)})
+                          (fmt.terraform_fmt.with {:condition (executable? :terraform)})]})
diff --git a/mut/neovim/fnl/conf/pkgs/test.fnl b/mut/neovim/fnl/conf/pkgs/test.fnl
new file mode 100644
index 0000000..4f0bcc4
--- /dev/null
+++ b/mut/neovim/fnl/conf/pkgs/test.fnl
@@ -0,0 +1,9 @@
+(tset vim.g "test#strategy" :neovim)
+(tset vim.g "test#neovim#term_position" :botright)
+
+(vim.keymap.set :n :<leader>t ":TestNearest<CR>" {:silent true})
+(vim.keymap.set :n :<leader>C ":TestClass<CR>" {:silent true})
+(vim.keymap.set :n :<leader>T ":TestFile<CR>" {:silent true})
+(vim.keymap.set :n :<leader>a ":TestSuite<CR>" {:silent true})
+(vim.keymap.set :n :<leader>l ":TestLast<CR>" {:silent true})
+(vim.keymap.set :n :<leader>g ":TestVisit<CR>" {:silent true})
diff --git a/mut/neovim/fnl/conf/pkgs/tree-sitter-context.fnl b/mut/neovim/fnl/conf/pkgs/tree-sitter-context.fnl
new file mode 100644
index 0000000..12fedc6
--- /dev/null
+++ b/mut/neovim/fnl/conf/pkgs/tree-sitter-context.fnl
@@ -0,0 +1,2 @@
+(local context (require :treesitter-context))
+(context.setup {:enable true})
diff --git a/mut/neovim/fnl/conf/pkgs/treesitter.fnl b/mut/neovim/fnl/conf/pkgs/treesitter.fnl
new file mode 100644
index 0000000..c613be0
--- /dev/null
+++ b/mut/neovim/fnl/conf/pkgs/treesitter.fnl
@@ -0,0 +1,2 @@
+(let [ts (require :nvim-treesitter.configs)]
+  (ts.setup {:highlight {:enable true}}))
diff --git a/mut/neovim/fnl/conf/pkgs/venn.fnl b/mut/neovim/fnl/conf/pkgs/venn.fnl
new file mode 100644
index 0000000..064e84e
--- /dev/null
+++ b/mut/neovim/fnl/conf/pkgs/venn.fnl
@@ -0,0 +1,18 @@
+;; venn.nvim: enable or disable keymappings
+(fn toggle-venn []
+  (if (not vim.b.venn_enabled)
+      (do
+        (set vim.b.venn_enabled true)
+        (vim.cmd "setlocal ve=all") ; draw a line on HJKL keystokes
+        (vim.keymap.set [:n] :J "<C-v>j:VBox<CR>" {:noremap true :buffer 0})
+        (vim.keymap.set [:n] :K "<C-v>k:VBox<CR>" {:noremap true :buffer 0})
+        (vim.keymap.set [:n] :L "<C-v>l:VBox<CR>" {:noremap true :buffer 0})
+        (vim.keymap.set [:n] :H "<C-v>h:VBox<CR>" {:noremap true :buffer 0}) ; draw a box by pres]sing "f" with visual selection)
+        (vim.keymap.set [:v] :f ":VBox<CR>" {:noremap true :buffer 0}))
+      (do
+        (vim.cmd "setlocal ve=")
+        (vim.cmd "mapclear <buffer>")
+        (set vim.b.venn_enabled nil))))
+
+; toggle keymappings for venn using <leader>v)
+(vim.keymap.set [:n] :<leader>v toggle-venn {:noremap true})
diff --git a/mut/neovim/fnl/conf/settings.fnl b/mut/neovim/fnl/conf/settings.fnl
new file mode 100644
index 0000000..ec68e6c
--- /dev/null
+++ b/mut/neovim/fnl/conf/settings.fnl
@@ -0,0 +1,69 @@
+(import-macros {: settings : globals} :conf.macros)
+
+(globals
+  codeium_enabled false
+  loaded_2html_plugin true
+  loaded_fzf false
+  loaded_man false
+  loaded_gzip false
+  loaded_health false
+  loaded_matchit false
+  loaded_matchparen false
+  loaded_netrwPlugin false
+  loaded_rplugin false
+  loaded_shada false
+  loaded_spellfile false
+  loaded_tarPlugin false
+  loaded_tohtml false
+  loaded_tutor false
+  loaded_zipPlugin false
+
+  mapleader " "
+  maplocalleader " "
+  dirvish_mode ":sort | sort ,^.*[^/]$, r")
+
+(settings
+  +shortmess "c"
+  +diffopt vertical
+  +isfname "@-@"
+  wmw 10
+  inccommand split
+  signcolumn yes
+  smd off
+  scrolloff 8
+  termguicolors on
+  incsearch on
+  undofile on
+  undodir (.. (os.getenv :HOME)  :/.local/share/nvim/undo)
+  backup off
+  backupcopy yes
+  swapfile off
+  wrap off
+  splitbelow on
+  magic on
+  showbreak "+++"
+  listchars {:eol "󰁂"}
+  list on
+  autoread on
+  autoindent on
+  smartindent on
+  expandtab on
+  tabstop 4
+  softtabstop 4
+  shiftwidth 4
+  hidden on
+  number on
+  relativenumber on
+  exrc on
+  secure on
+  completeopt "menuone,noselect"
+  wildmode "lastused"
+  complete ".,w,k,kspell,b"
+  foldopen "block,hor,jump,mark,percent,quickfix,search,tag"
+  laststatus 3
+  ; winbar "%=%m %f"
+  winbar ""
+  hlsearch off
+  clipboard ""
+  showtabline 0
+  cmdheight 0)
diff --git a/mut/neovim/fnl/conf/wict-nvim/builder.fnl b/mut/neovim/fnl/conf/wict-nvim/builder.fnl
new file mode 100644
index 0000000..177b773
--- /dev/null
+++ b/mut/neovim/fnl/conf/wict-nvim/builder.fnl
@@ -0,0 +1,99 @@
+(tset package.loaded :conf.wict-nvim.frames.frame nil)
+(local vec (require :conf.wict-nvim.frames.vec))
+(local frame (require :conf.wict-nvim.frames.frame))
+(local m {})
+
+;; Creates a new painter that wraps the paint and close methods of a painter
+(local transform-painter (fn [painter ori width height]
+                           (fn [frm]
+                             (local coord (frame.frame->coord frm))
+                             (local new-ori (coord ori))
+                             (local new-frame
+                                    (frame new-ori
+                                           (vec.sub (coord width) new-ori)
+                                           (vec.sub (coord height) new-ori)))
+                             (painter new-frame))))
+
+(local pad (fn [painter pad-size]
+             (fn [frm]
+               (local pad-width (/ pad-size (frame.width frm)))
+               (local pad-height (/ pad-size (frame.height frm)))
+               (local transformed
+                      (transform-painter painter (vec.vec pad-width pad-height)
+                                         (vec.vec (- 1 pad-width) pad-height)
+                                         (vec.vec pad-width (- 1 pad-height))))
+               (transformed frm))))
+
+(local beside (fn [p1 p2 size]
+                (local size (or size 0.5))
+                (local left
+                       (transform-painter p1 (vec.vec 0 0) (vec.vec size 0)
+                                          (vec.vec 0 1)))
+                (local right
+                       (transform-painter p2 (vec.vec size 0) (vec.vec 1 0)
+                                          (vec.vec size 1)))
+                (fn [frm]
+                  (left frm)
+                  (right frm))))
+
+(local builder {})
+
+(fn builder.Padding [self size]
+  (table.insert self.partial-painters {:op :pad : size})
+  self)
+
+(fn builder.Beside [self partial-builder size]
+  (table.insert self.partial-painters {:op :beside : partial-builder : size})
+  self)
+
+(fn builder.LeftOf [self partial-builder size]
+  (table.insert self.partial-painters {:op :left : partial-builder : size})
+  self)
+
+(fn builder.RightOf [self partial-builder size]
+  (table.insert self.partial-painters {:op :right : partial-builder : size})
+  self)
+
+(fn builder.build-painter [self effects]
+  (accumulate [painter (fn [frame] (print :leaf-painter)) _ partial-painter (ipairs self.partial-painters)]
+    (do
+      (match partial-painter
+        {:op :pad : size} (do
+                            (pad painter size))
+        {:op :left : partial-builder} (do
+                                        (beside painter
+                                                (partial-builder:build-painter effects)
+                                                partial-painter.size))
+        {:op :right : partial-builder} (do
+                                         (beside (partial-builder:build-painter effects)
+                                                 painter partial-painter.size))
+        {:op :beside : partial-builder} (do
+                                          (beside painter
+                                                  (partial-builder:build-painter effects)
+                                                  partial-painter.size))
+        {: maps : buffer} (do
+                            (local window (effects:new-window maps))
+                            (local painter-ptr painter)
+                            (fn [frm]
+                              (local frame-opts
+                                     (frame.frame->open-win-options frm))
+                              (local buf (buffer))
+                              (if (not (window:open?))
+                                  (window:open buf frame-opts)
+                                  (window:repaint buf frame-opts))
+                              (painter-ptr frm)))
+        _ painter))))
+
+(fn builder.Build [self effects]
+  (local painter (self:build-painter effects))
+  (fn [frm]
+    (effects:attach)
+    (painter frm)))
+
+(fn builder.For [partial-painter]
+  (local bldr {:partial-painters [partial-painter]})
+  (setmetatable bldr builder)
+  (set builder.__index builder)
+  bldr)
+
+builder
diff --git a/mut/neovim/fnl/conf/wict-nvim/effects.fnl b/mut/neovim/fnl/conf/wict-nvim/effects.fnl
new file mode 100644
index 0000000..e4321da
--- /dev/null
+++ b/mut/neovim/fnl/conf/wict-nvim/effects.fnl
@@ -0,0 +1,81 @@
+(local m {})
+(local window {})
+
+(local aug vim.api.nvim_create_augroup)
+(local del-aug (fn [] (vim.api.nvim_create_augroup :EffectsMgr {:clear true})))
+(local au vim.api.nvim_create_autocmd)
+(local winvar (fn [...] (pcall vim.api.nvim_win_get_var ...)))
+(local unmap (fn [{: mode : lhs : opts}] (pcall vim.keymap.del mode lhs opts)))
+(local map (fn [mode lhs rhs opts] (vim.keymap.set mode lhs rhs opts)))
+
+(fn window.close [self]
+  (if (self:open?)
+      (set self.handle (vim.api.nvim_win_close self.handle true))))
+
+(fn window.open [self buf frame]
+  (set frame.style :minimal)
+  (set self.handle (vim.api.nvim_open_win buf false frame))
+  (P self.handle :before-setvar)
+  (vim.api.nvim_buf_set_var buf :effect-window self)
+  (vim.api.nvim_win_set_var self.handle :effect-window self)
+  (if self.enter
+      (vim.api.nvim_set_current_win self.handle)))
+
+(fn window.id [self]
+  self.handle)
+
+(fn window.open? [self]
+  (if self.handle
+      (vim.api.nvim_win_is_valid self.handle) false))
+
+(fn window.new [self i enter maps]
+  (local w (setmetatable {: i : enter : maps} window))
+  (set self.__index self)
+  w)
+
+(fn m.new-window [self maps]
+  (local w (window:new (+ (length self.windows) 1) (= (length self.windows) 0)
+                       maps))
+  (table.insert self.windows w)
+  w)
+
+(fn m.close [self]
+  (each [_ w (ipairs self.windows)]
+    (w:close))
+  (if self.augroup
+      (set self.augroup (del-aug self.augroup)))
+  (if self.unmap
+      (set self.unmap (self.unmap))))
+
+(fn m.attach [self]
+  (set self.augroup (aug :EffectsMgr {:clear true}))
+  (au [:WinEnter]
+      {:group self.augroup
+       :pattern "*"
+       :callback (fn [cb-info]
+                   (P :effectEnter)
+                   (local (ok? win) (winvar 0 :effect-window))
+                   (P ok? win)
+                   (if (not ok?)
+                       (self:close)
+                       (do
+                         (if win.maps
+                             (self:win-maps win)))))}))
+
+(fn m.win-maps [self win]
+  (P win)
+  (if self.unmap
+      (self.unmap))
+  (set self.unmap (fn []
+                    (each [_ m (ipairs win.maps)]
+                      (unmap m))))
+  (each [_ {: mode : lhs : rhs : opts} (ipairs win.maps)]
+    (map mode lhs (rhs self win) opts)))
+
+(fn m.new [self opts]
+  (local effects {:windows []})
+  (setmetatable effects self)
+  (set self.__index self)
+  effects)
+
+m
diff --git a/mut/neovim/fnl/conf/wict-nvim/frames/frame.fnl b/mut/neovim/fnl/conf/wict-nvim/frames/frame.fnl
new file mode 100644
index 0000000..d32c9b5
--- /dev/null
+++ b/mut/neovim/fnl/conf/wict-nvim/frames/frame.fnl
@@ -0,0 +1,61 @@
+(local vec (require :conf.wict-nvim.frames.vec))
+(local m {})
+(local frame {})
+
+;; frame is interpreted as matrix coords
+;; origin ------------------> ne-edge
+;; |
+;; |
+;; |
+;; |
+;; |
+;; |
+;;\ /
+;; .
+;; sw-edge
+(fn frame.make [self ori width height]
+  (local f {: ori : width : height})
+  (setmetatable f self)
+  (set self.__index self)
+  f)
+
+(fn frame.origin [f]
+  f.ori)
+
+(fn frame.width-edge [f]
+  f.width)
+
+(fn frame.height-edge [f]
+  f.height)
+
+(fn m.frame->coord [f]
+  (fn [v]
+    (vec.add (f:origin)
+             (vec.add (vec.scale (v:x-coord) (f:width-edge))
+                      (vec.scale (v:y-coord) (f:height-edge))))))
+
+(fn m.width [f]
+  (let [width-edge (f:width-edge)]
+    (width-edge:x-coord)))
+
+(fn m.height [f]
+  (let [height-edge (f:height-edge)]
+    (height-edge:y-coord)))
+
+(fn m.frame->open-win-options [f anchor]
+  (local coord (m.frame->coord f))
+  (local ori (f:origin))
+  (local width-edge (f:width-edge))
+  (local height-edge (f:height-edge))
+  (local anchor (or anchor :NW))
+  {:width (width-edge:x-coord)
+   :height (height-edge:y-coord)
+   :col (ori:x-coord)
+   :row (ori:y-coord)
+   : anchor
+   :relative :editor})
+
+(setmetatable m {:__call (fn [self ...]
+                           (frame:make ...))})
+
+m
diff --git a/mut/neovim/fnl/conf/wict-nvim/frames/vec.fnl b/mut/neovim/fnl/conf/wict-nvim/frames/vec.fnl
new file mode 100644
index 0000000..4a9515d
--- /dev/null
+++ b/mut/neovim/fnl/conf/wict-nvim/frames/vec.fnl
@@ -0,0 +1,28 @@
+(local m {})
+(local vec {})
+
+(fn vec.make [self x y]
+  (local v {: x : y})
+  (setmetatable v self)
+  (set self.__index self)
+  v)
+
+(fn vec.x-coord [v]
+  v.x)
+
+(fn vec.y-coord [v]
+  v.y)
+
+(fn m.add [v1 v2]
+  (vec:make (+ (v1:x-coord) (v2:x-coord)) (+ (v1:y-coord) (v2:y-coord))))
+
+(fn m.sub [v1 v2]
+  (vec:make (- (v1:x-coord) (v2:x-coord)) (- (v1:y-coord) (v2:y-coord))))
+
+(fn m.scale [a v]
+  (vec:make (math.floor (* a (v:x-coord))) (math.floor (* a (v:y-coord)))))
+
+(fn m.vec [...]
+  (vec:make ...))
+
+m
diff --git a/mut/neovim/fnl/conf/wict-nvim/init.fnl b/mut/neovim/fnl/conf/wict-nvim/init.fnl
new file mode 100644
index 0000000..9e40fad
--- /dev/null
+++ b/mut/neovim/fnl/conf/wict-nvim/init.fnl
@@ -0,0 +1,31 @@
+(tset package.loaded :conf.wict-nvim.frames.vec nil)
+(local vec (require :conf.wict-nvim.frames.vec))
+
+(tset package.loaded :conf.wict-nvim.frames.frame nil)
+(local frame (require :conf.wict-nvim.frames.frame))
+
+(tset package.loaded :conf.wict-nvim.builder nil)
+(local builder (require :conf.wict-nvim.builder))
+
+(tset package.loaded :conf.wict-nvim.effects nil)
+(local effects (require :conf.wict-nvim.effects))
+
+(local m {})
+
+(local root-frame (frame (vec.vec 0 0) (vec.vec vim.o.columns 0)
+                         (vec.vec 0 vim.o.lines)))
+
+(local painter (-> (builder.For {:buffer (fn [] 0)
+                                 :maps [{:mode [:n :v :o]
+                                         :lhs :q
+                                         :rhs (fn [effects window]
+                                                (fn []
+                                                  (effects:close)))}]})
+                   (builder.Beside (-> (builder.For {:buffer (fn [] 0)
+                                                     :maps []}))
+                                   0.5)
+                   (builder.Padding 5)
+                   (builder.Build (effects:new))))
+
+; (painter root-frame)
+{: root-frame : builder : effects}
diff --git a/mut/neovim/fnl/conf/wictl-nvim/init.fnl b/mut/neovim/fnl/conf/wictl-nvim/init.fnl
new file mode 100644
index 0000000..bd04182
--- /dev/null
+++ b/mut/neovim/fnl/conf/wictl-nvim/init.fnl
@@ -0,0 +1,58 @@
+(local Path (require :plenary.path))
+(tset package.loaded :conf.wict-nvim nil)
+(local wict (require :conf.wict-nvim))
+(tset package.loaded :conf.wictl-nvim.resolvers nil)
+(local Resolver (require :conf.wictl-nvim.resolvers))
+
+(local bld wict.builder)
+(local eff wict.effects)
+
+(local config_path (vim.fn.stdpath :config))
+(local data_path (vim.fn.stdpath :data))
+(local user_config (string.format "%s/wictl.json" config_path))
+(local cache_config (string.format "%s/wictl.json" data_path))
+
+(local m {})
+
+(local WictlConfig {})
+;; {
+;;   ["/path/to/project"] = {
+;;      terms = [{cmd = "k9s"}]
+;; }
+
+(fn m.Edit [project])
+
+(fn m.Read [path]
+  (local p (Path:new path))
+  (vim.fn.json_decode (p:read)))
+
+(fn m.Save []
+  (local cache-path (Path:new cache_config))
+  (cache-path:write (vim.fn.json_encode WictlConfig) :w))
+
+(local ensure-complete-project (fn [config]
+                                 (var config (or config {:terms []}))
+                                 (if (not config.terms)
+                                     (set config.terms
+                                          [{:name :k9s :cmd :bash}]))
+                                 config))
+
+(local get-project (fn []
+                     (local proj (. WictlConfig (Resolver.project_key)))
+                     (ensure-complete-project (or proj
+                                                  (do
+                                                    (local cfg {})
+                                                    (tset WictlConfig
+                                                          (Resolver.project_key)
+                                                          cfg)
+                                                    cfg)))))
+
+(fn m.Get-Terms-Config []
+  (local proj (get-project))
+  proj.terms)
+
+(m.Save)
+(m.Read cache_config)
+(m.Get-Terms-Config)
+
+m
diff --git a/mut/neovim/fnl/conf/wictl-nvim/resolvers.fnl b/mut/neovim/fnl/conf/wictl-nvim/resolvers.fnl
new file mode 100644
index 0000000..df5f2ac
--- /dev/null
+++ b/mut/neovim/fnl/conf/wictl-nvim/resolvers.fnl
@@ -0,0 +1,5 @@
+(local m {})
+(fn m.project_key []
+  (vim.loop.cwd))
+
+m
diff --git a/mut/neovim/fnl/conf/wictl-nvim/term.fnl b/mut/neovim/fnl/conf/wictl-nvim/term.fnl
new file mode 100644
index 0000000..51e263a
--- /dev/null
+++ b/mut/neovim/fnl/conf/wictl-nvim/term.fnl
@@ -0,0 +1,54 @@
+(tset package.loaded :conf.wict-nvim nil)
+(local ui (require :conf.wict-nvim))
+(tset package.loaded :conf.wict-nvim.effects nil)
+(local ui-eff (require :conf.wict-nvim.effects))
+
+(tset package.loaded :conf.wictl-nvim nil)
+(local wictl (require :conf.wictl-nvim))
+
+(local Resolver (require :conf.wictl-nvim.resolvers))
+(local ui-bld ui.builder)
+(local M {})
+
+(local ProjectBufs {})
+(var selected nil)
+(local term-ui (-> (ui-bld.For {:buffer (fn [] selected)
+                                :maps [{:mode [:n :v :o]
+                                        :lhs :q
+                                        :rhs (fn [effects window]
+                                               (fn []
+                                                 (P :quitting!)
+                                                 (effects:close)))}]})
+                   (ui-bld.Padding 2)
+                   (ui-bld.Build (ui-eff:new))))
+
+(fn M.open [idx]
+  (local new-term-buf (fn []
+                        (local (buf_handle term_handle) (M.start idx))
+                        (tset ProjectBufs (Resolver.project_key) idx
+                              {: buf_handle : term_handle})
+                        {: buf_handle : term_handle}))
+  (local proj (or (. ProjectBufs (Resolver.project_key))
+                  (do
+                    (local p [])
+                    (tset ProjectBufs (Resolver.project_key) p)
+                    p)))
+  (var term (or (. proj idx) (new-term-buf)))
+  (if (or (not (vim.api.nvim_buf_is_valid term.buf_handle))
+          (not (vim.api.nvim_buf_get_var term.buf_handle :terminal_job_id)))
+      (set term (new-term-buf)))
+  (set selected term.buf_handle)
+  (term-ui ui.root-frame))
+
+(fn M.start [idx]
+  (P :starting)
+  (local term (. (wictl.Get-Terms-Config) idx))
+  (local prestart-buf (vim.api.nvim_get_current_buf))
+  (vim.cmd (.. "edit term://" term.cmd))
+  (local buf_handle (vim.api.nvim_get_current_buf))
+  (local term_handle vim.b.terminal_job_id)
+  (vim.api.nvim_buf_set_option buf_handle :bufhidden :hide)
+  (vim.api.nvim_set_current_buf prestart-buf)
+  (values buf_handle term_handle))
+
+M
diff --git a/mut/neovim/init.fnl b/mut/neovim/init.fnl
new file mode 100644
index 0000000..7e82675
--- /dev/null
+++ b/mut/neovim/init.fnl
@@ -0,0 +1,36 @@
+;; fixes nixpkgs hotpot not adding package path correctly
+
+(tset _G.package :path
+      (.. (vim.fn.stdpath :cache) "/hotpot/hotpot.nvim/lua/?/init.lua;"
+          package.path))
+
+(fn build-init []
+  (let [{: build} (require :hotpot.api.make)
+        allowed-globals (icollect [n _ (pairs _G)]
+                          n)
+        opts {:verbosity 0
+              :compiler {:modules {:allowedGlobals allowed-globals}}}
+        here #(values $1)
+        config-path (vim.fn.stdpath :config)]
+    (build config-path opts (.. config-path :/init.fnl) here
+           (.. config-path :/after/ftdetect/.+) here
+           (.. config-path :/ftplugin/.+) here
+           (.. config-path :/after/ftplugin/.+) here)))
+
+;; Call hotpot.setup and compile again after fs event
+
+(let [hotpot (require :hotpot)
+      setup hotpot.setup
+      build hotpot.api.make.build
+      uv vim.loop
+      config-path (vim.fn.stdpath :config)]
+  (setup {:provide_require_fennel true
+          :compiler {:modules {:correlate true}
+                     :macros {:env :_COMPILER
+                              :compilerEnv _G
+                              :allowedGlobals false}}})
+  (let [handle (uv.new_fs_event)
+        path (vim.fn.expand (.. config-path :/init.fnl))]
+    (uv.fs_event_start handle path {} #(vim.schedule build-init))
+    (vim.api.nvim_create_autocmd :VimLeavePre {:callback #(uv.close handle)})))
+(require :conf)
diff --git a/mut/neovim/init.lua b/mut/neovim/init.lua
new file mode 100644
index 0000000..3de4446
--- /dev/null
+++ b/mut/neovim/init.lua
@@ -0,0 +1,46 @@
+_G.package["path"] = (vim.fn.stdpath("cache") .. "/hotpot/hotpot.nvim/lua/?/init.lua;" .. package.path)
+local function build_init()
+  local _let_1_ = require("hotpot.api.make")
+  local build = _let_1_["build"]
+  local allowed_globals
+  do
+    local tbl_17_auto = {}
+    local i_18_auto = #tbl_17_auto
+    for n, _ in pairs(_G) do
+      local val_19_auto = n
+      if (nil ~= val_19_auto) then
+        i_18_auto = (i_18_auto + 1)
+        do end (tbl_17_auto)[i_18_auto] = val_19_auto
+      else
+      end
+    end
+    allowed_globals = tbl_17_auto
+  end
+  local opts = {verbosity = 0, compiler = {modules = {allowedGlobals = allowed_globals}}}
+  local here
+  local function _3_(_241)
+    return _241
+  end
+  here = _3_
+  local config_path = vim.fn.stdpath("config")
+  return build(config_path, opts, (config_path .. "/init.fnl"), here, (config_path .. "/after/ftdetect/.+"), here, (config_path .. "/ftplugin/.+"), here, (config_path .. "/after/ftplugin/.+"), here)
+end
+do
+  local hotpot = require("hotpot")
+  local setup = hotpot.setup
+  local build = hotpot.api.make.build
+  local uv = vim.loop
+  local config_path = vim.fn.stdpath("config")
+  setup({provide_require_fennel = true, compiler = {modules = {correlate = true}, macros = {env = "_COMPILER", compilerEnv = _G, allowedGlobals = false}}})
+  local handle = uv.new_fs_event()
+  local path = vim.fn.expand((config_path .. "/init.fnl"))
+  local function _4_()
+    return vim.schedule(build_init)
+  end
+  uv.fs_event_start(handle, path, {}, _4_)
+  local function _5_()
+    return uv.close(handle)
+  end
+  vim.api.nvim_create_autocmd("VimLeavePre", {callback = _5_})
+end
+return require("conf")
\ No newline at end of file
diff --git a/mut/neovim/test.py b/mut/neovim/test.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/mut/neovim/test.py