some dotfiles while I explore a more robust solution

init.el

;;; init.el --- Personal Emacs config -*- lexical-binding: t; -*-

;;; Commentary:
;; a personal take on a Doom style setup

;;; Code:

(setq gc-cons-threshold most-positive-fixnum)
(add-hook 'emacs-startup-hook
          (lambda () (setq gc-cons-threshold (* 16 1024 1024))))

(when (featurep 'native-compile)
  (setq native-comp-async-report-warnings-errors 'silent))

(setq warning-minimum-level :error)

(require 'package)
(setq package-archives
      '(("gnu"    . "https://elpa.gnu.org/packages/")
        ("nongnu" . "https://elpa.nongnu.org/nongnu/")
        ("melpa"  . "https://melpa.org/packages/")))
(package-initialize)

; bootstrap use-package on fresh installs
(unless (package-installed-p 'use-package)
  (package-refresh-contents)
  (package-install 'use-package))

(require 'use-package)
(setq use-package-always-ensure t)

(use-package emacs
  :ensure nil
  :init
  (menu-bar-mode -1)
  (tool-bar-mode -1)
  (scroll-bar-mode -1)
  (tooltip-mode -1)
  (blink-cursor-mode -1)

  (setq inhibit-startup-screen t)
  (setq initial-scratch-message ";; Happy Hacking!\n\n")
  (setq initial-major-mode 'emacs-lisp-mode)

  (setq-default indent-tabs-mode nil)
  (setq-default tab-width 2)
  (setq ring-bell-function 'ignore)
  (setq use-short-answers t)
  (setq confirm-kill-emacs 'y-or-n-p)
  (setq require-final-newline t)
  (setq sentence-end-double-space nil)

  (setq scroll-margin 3)
  (setq scroll-conservatively 101)
  (setq scroll-preserve-screen-position t)

  (setq auto-save-default nil)
  (setq make-backup-files nil)
  (setq create-lockfiles nil)
  (setq custom-file (expand-file-name "custom.el" user-emacs-directory))
  (when (file-exists-p custom-file) (load custom-file 'noerror))

  (global-display-line-numbers-mode 1)
  (dolist (mode '(term-mode-hook eshell-mode-hook eat-mode-hook dired-mode-hook))
    (add-hook mode (lambda () (display-line-numbers-mode 0))))

  (setq-default truncate-lines t)
  (setq-default fill-column 80)
  (global-hl-line-mode 1)
  (show-paren-mode 1)
  (recentf-mode 1)
  (savehist-mode 1)
  (save-place-mode 1)
  (global-auto-revert-mode 1)
  (setq global-auto-revert-non-file-buffers t)

  (global-set-key (kbd "C-S-c") 'kill-ring-save)
  (global-set-key (kbd "C-S-v") 'yank)
  (global-set-key (kbd "C-S-p") 'yank)

  ; electric-pair for auto-closing brackets in non-lisp modes
  (electric-pair-mode 1)

  (set-default-coding-systems 'utf-8)
  (prefer-coding-system 'utf-8)

  (set-face-attribute 'default nil :font "DejaVu Sans Mono" :height 110))

(use-package ef-themes
  :config
  (setq ef-themes-to-toggle '(ef-day ef-night))
  (mapc #'disable-theme custom-enabled-themes)
  (load-theme 'ef-day t))

(defun my/set-theme-toggle-pair ()
  (interactive)
  (let* ((themes (mapcar #'symbol-name (custom-available-themes)))
         (ef-only (seq-filter (lambda (s) (string-prefix-p "ef-" s)) themes))
         (light (intern (completing-read "Light theme: " ef-only nil t)))
         (dark (intern (completing-read "Dark theme: " ef-only nil t))))
    (setq ef-themes-to-toggle (list light dark))
    (message "Toggle pair set: %s / %s" light dark)))

(use-package doom-modeline
  :hook (after-init . doom-modeline-mode)
  :config
  (setq doom-modeline-height 28)
  (setq doom-modeline-buffer-file-name-style 'relative-from-project)
  (setq doom-modeline-icon t))

(use-package nerd-icons)

(use-package evil
  :init
  (setq evil-want-integration t)
  (setq evil-want-keybinding nil)
  (setq evil-want-C-u-scroll t)
  (setq evil-want-C-i-jump t)
  (setq evil-want-Y-yank-to-eol t)
  (setq evil-undo-system 'undo-redo)
  (setq evil-search-module 'evil-search)
  (setq evil-split-window-below t)
  (setq evil-vsplit-window-right t)
  (setq evil-respect-visual-line-mode t)
  :config
  (evil-mode 1)
  (global-set-key (kbd "<escape>") 'keyboard-escape-quit)
  (define-key evil-insert-state-map (kbd "j")
    (lambda () (interactive)
      (let ((next-key (read-event nil nil 0.2)))
        (if (eq next-key ?k)
            (evil-normal-state)
          (insert "j")
          (when next-key (push next-key unread-command-events)))))))

(use-package evil-collection
  :after evil
  :config
  (evil-collection-init))

(use-package evil-surround
  :after evil
  :config
  (global-evil-surround-mode 1))

(use-package evil-commentary
  :after evil
  :config
  (evil-commentary-mode))

(use-package evil-lion
  :after evil
  :config
  (evil-lion-mode))

(use-package evil-goggles
  :after evil
  :config
  (setq evil-goggles-duration 0.1)
  (evil-goggles-mode))

(use-package evil-matchit
  :after evil
  :config
  (global-evil-matchit-mode 1))

(use-package vertico
  :init (vertico-mode)
  :config
  (setq vertico-cycle t)
  (setq vertico-count 15)
  (define-key vertico-map (kbd "TAB") #'vertico-insert)
  (define-key vertico-map (kbd "<tab>") #'vertico-insert)
  (define-key vertico-map (kbd "C-j") #'vertico-next)
  (define-key vertico-map (kbd "C-k") #'vertico-previous))

(with-eval-after-load 'vertico
  (require 'vertico-directory)
  (define-key vertico-map (kbd "RET") #'vertico-directory-enter)
  (define-key vertico-map (kbd "DEL") #'vertico-directory-delete-char)
  (define-key vertico-map (kbd "M-DEL") #'vertico-directory-delete-word)
  (add-hook 'rfn-eshadow-update-overlay-hook #'vertico-directory-tidy))

(use-package orderless
  :config
  (setq completion-styles '(orderless basic))
  (setq completion-category-defaults nil)
  (setq completion-category-overrides '((file (styles partial-completion)))))

(use-package marginalia
  :init (marginalia-mode))

(use-package consult
  :config
  (setq consult-narrow-key "<")
  (setq consult-preview-key '(:debounce 0.2 any)))

(use-package embark
  :bind (("C-." . embark-act) ("C-;" . embark-dwim))
  :config
  (setq prefix-help-command #'embark-prefix-help-command))

(use-package embark-consult
  :after (embark consult)
  :demand t
  :hook (embark-collect-mode . consult-preview-at-point-mode))

(use-package corfu
  :custom
  (corfu-auto t)
  (corfu-auto-delay 0.1)
  (corfu-auto-prefix 2)
  (corfu-cycle t)
  (corfu-quit-no-match 'separator)
  :init (global-corfu-mode)
  :config
  (define-key corfu-map (kbd "TAB") #'corfu-next)
  (define-key corfu-map (kbd "<tab>") #'corfu-next)
  (define-key corfu-map (kbd "S-TAB") #'corfu-previous)
  (define-key corfu-map (kbd "<backtab>") #'corfu-previous)
  (define-key corfu-map (kbd "RET") #'corfu-insert))

(use-package cape
  :init
  (add-to-list 'completion-at-point-functions #'cape-file)
  (add-to-list 'completion-at-point-functions #'cape-dabbrev))

(use-package which-key
  :config
  (setq which-key-idle-delay 0.5)
  (setq which-key-separator " → ")
  (setq which-key-prefix-prefix "+")
  (which-key-mode))

(use-package dired-sidebar
  :commands (dired-sidebar-toggle-sidebar)
  :config
  (setq dired-sidebar-theme 'nerd)
  (setq dired-sidebar-width 35)
  (setq dired-sidebar-use-custom-font t)
  (evil-define-key 'normal dired-sidebar-mode-map
    (kbd "RET") 'dired-sidebar-find-file
    (kbd "o") 'dired-sidebar-find-file-alt
    (kbd "ma") 'dired-create-empty-file
    (kbd "md") 'dired-create-directory
    (kbd "mc") 'dired-do-copy
    (kbd "mm") 'dired-do-rename
    (kbd "mD") 'dired-do-delete
    (kbd "q") 'dired-sidebar-toggle-sidebar))

(defun my/show-line-diagnostics ()
  (interactive)
  (if (bound-and-true-p flymake-mode)
      (let ((diags (flymake-diagnostics (line-beginning-position) (line-end-position))))
        (if diags
            (message "%s" (mapconcat
                           (lambda (d) (flymake-diagnostic-text d))
                           diags "\n"))
          (message "No diagnostics on this line")))
    (message "Flymake not active")))

(use-package general
  :after evil
  :config
  (general-evil-setup)

  (general-create-definer leader-keys
    :states '(normal insert visual emacs)
    :keymaps 'override
    :prefix "SPC"
    :global-prefix "C-SPC")

  (leader-keys
    "SPC" '(execute-extended-command :wk "M-x")
    "TAB" '(evil-switch-to-windows-last-buffer :wk "last buffer")
    "RET" '(evil-ex-nohighlight :wk "clear search")
    "u"   '(universal-argument :wk "universal arg")
    "n"   '((lambda () (interactive) (evil-open-below 1) (evil-normal-state)) :wk "blank line below")
    "e"   '(my/show-line-diagnostics :wk "show diagnostic")
    "v"   '((lambda () (interactive) (find-file "~/.emacs.d/init.el")) :wk "init.el")

    "f"   '(:ignore t :wk "file")
    "ff"  '(project-find-file :wk "find in project")
    "fF"  '(find-file :wk "find file")
    "fr"  '(consult-recent-file :wk "recent files")
    "fw"  '(save-buffer :wk "save")
    "fa"  '((lambda () (interactive) (save-some-buffers t)) :wk "save all")
    "fW"  '(write-file :wk "save as")
    "fR"  '(rename-visited-file :wk "rename")
    "fD"  '((lambda () (interactive)
              (when (y-or-n-p (format "Delete %s?" (buffer-file-name)))
                (delete-file (buffer-file-name))
                (kill-buffer))) :wk "delete")
    "fy"  '((lambda () (interactive)
              (when buffer-file-name
                (kill-new buffer-file-name)
                (message "Copied: %s" buffer-file-name))) :wk "yank path")
    "fe"  '(eval-buffer :wk "eval buffer")

    "b"   '(:ignore t :wk "buffer")
    "bb"  '(consult-buffer :wk "switch buffer")
    "bd"  '(kill-current-buffer :wk "kill buffer")
    "bD"  '(kill-buffer-and-window :wk "kill buffer & window")
    "br"  '(revert-buffer :wk "revert buffer")
    "bs"  '(scratch-buffer :wk "scratch buffer")
    "by"  '((lambda () (interactive)
              (mark-whole-buffer)
              (call-interactively 'evil-yank)
              (message "Yanked entire buffer")) :wk "yank buffer")

    "w"   '(:ignore t :wk "window")
    "wv"  '(evil-window-vsplit :wk "vsplit")
    "ws"  '(evil-window-split :wk "hsplit")
    "wd"  '(evil-window-delete :wk "close")
    "wo"  '(delete-other-windows :wk "only")
    "wh"  '(evil-window-left :wk "left")
    "wj"  '(evil-window-down :wk "down")
    "wk"  '(evil-window-up :wk "up")
    "wl"  '(evil-window-right :wk "right")
    "w="  '(balance-windows :wk "balance")

    "s"   '(:ignore t :wk "search")
    "ss"  '(consult-line :wk "search buffer")
    "sS"  '(consult-line-multi :wk "search all buffers")
    "sp"  '(consult-ripgrep :wk "ripgrep")
    "sf"  '(consult-find :wk "find file")
    "si"  '(consult-imenu :wk "imenu")
    "sr"  '(consult-register :wk "registers")
    "sm"  '(consult-mark :wk "marks")
    "so"  '(consult-outline :wk "outline")

    "p"   '(:ignore t :wk "project")
    "pp"  '(project-switch-project :wk "switch project")
    "pf"  '(project-find-file :wk "find file")
    "pb"  '(project-switch-to-buffer :wk "buffers")
    "ps"  '(consult-ripgrep :wk "search")
    "pk"  '(project-kill-buffers :wk "kill buffers")
    "pd"  '(project-find-dir :wk "find dir")

    "g"   '(:ignore t :wk "git")
    "gg"  '(magit-status :wk "status")
    "gb"  '(magit-blame :wk "blame")
    "gl"  '(magit-log-current :wk "log")
    "gd"  '(magit-diff-dwim :wk "diff")
    "gf"  '(magit-file-dispatch :wk "file")

    "c"   '(:ignore t :wk "code")
    "ca"  '(eglot-code-actions :wk "actions")
    "cr"  '(eglot-rename :wk "rename")
    "cf"  '(eglot-format :wk "format")
    "cF"  '(eglot-format-buffer :wk "format buffer")
    "cd"  '(xref-find-definitions :wk "definition")
    "cD"  '(xref-find-references :wk "references")
    "ci"  '(eglot-find-implementation :wk "implementation")
    "ce"  '(consult-flymake :wk "errors list")

    "t"   '(:ignore t :wk "toggle")
    "ta"  '(dired-sidebar-toggle-sidebar :wk "file tree")
    "tt"  '(my/toggle-terminal :wk "terminal")
    "tT"  '(ef-themes-toggle :wk "light/dark toggle")
    "ts"  '(ef-themes-select :wk "select theme")
    "tp"  '(my/set-theme-toggle-pair :wk "set toggle pair")
    "tl"  '(display-line-numbers-mode :wk "line numbers")
    "tw"  '(whitespace-mode :wk "whitespace")
    "tz"  '(writeroom-mode :wk "zen mode")
    "ti"  '(eglot-inlay-hints-mode :wk "inlay hints")

    "o"   '(:ignore t :wk "open")
    "oa"  '(org-agenda :wk "agenda")
    "oc"  '(org-capture :wk "capture")
    "od"  '(dired-jump :wk "dired here")
    "oD"  '(dired :wk "dired")

    "q"   '(:ignore t :wk "quit")
    "qq"  '(save-buffers-kill-terminal :wk "quit")
    "qQ"  '(kill-emacs :wk "quit no save")
    "qr"  '(restart-emacs :wk "restart")

    "h"   '(:ignore t :wk "help")
    "hf"  '(helpful-callable :wk "function")
    "hv"  '(helpful-variable :wk "variable")
    "hk"  '(helpful-key :wk "key")
    "ho"  '(helpful-symbol :wk "symbol")
    "hm"  '(describe-mode :wk "mode")
    "hi"  '(info :wk "info"))

  (general-nmap
    "K"   'eldoc-box-help-at-point
    "gd"  'xref-find-definitions
    "gD"  'xref-find-definitions-other-window
    "gr"  'xref-find-references
    "gi"  'eglot-find-implementation
    "gy"  'eglot-find-typeDefinition
    "gn"  'eglot-rename
    "ga"  'eglot-code-actions
    "[d"  'flymake-goto-prev-error
    "]d"  'flymake-goto-next-error
    "gl"  'flymake-show-buffer-diagnostics))

(use-package avy
  :config
  (setq avy-all-windows t)
  (setq avy-background t)
  :general
  (:states '(normal visual)
   "s" 'avy-goto-char-2
   "S" 'avy-goto-line))

(use-package eat
  :commands (eat eat-project)
  :config
  (setq eat-kill-buffer-on-exit t)
  (add-hook 'eat-mode-hook (lambda () (display-line-numbers-mode 0))))

(defun my/toggle-terminal ()
  (interactive)
  (if-let ((buf (get-buffer "*eat*")))
      (if-let ((win (get-buffer-window buf)))
          (delete-window win)
        (display-buffer buf '(display-buffer-at-bottom (window-height . 0.3))))
    (let ((default-directory (or (when-let ((proj (project-current))) (project-root proj)) default-directory)))
      (eat)
      (display-buffer (current-buffer) '(display-buffer-at-bottom (window-height . 0.3))))))

(with-eval-after-load 'eat
  (evil-define-key 'insert eat-mode-map (kbd "jk") 'evil-normal-state)
  (evil-define-key 'emacs eat-mode-map (kbd "jk") 'evil-normal-state)
  (evil-set-initial-state 'eat-mode 'insert))

(use-package magit
  :commands magit-status
  :config
  (setq magit-display-buffer-function #'magit-display-buffer-same-window-except-diff-v1))

(use-package diff-hl
  :hook ((prog-mode . diff-hl-mode)
         (magit-post-refresh . diff-hl-magit-post-refresh))
  :config
  (diff-hl-flydiff-mode))

(use-package eglot
  :ensure nil
  :hook ((clojure-mode . eglot-ensure)
         (clojurescript-mode . eglot-ensure)
         (clojurec-mode . eglot-ensure)
         (rust-mode . eglot-ensure)
         (rust-ts-mode . eglot-ensure)
         (js-mode . eglot-ensure)
         (typescript-mode . eglot-ensure)
         (typescript-ts-mode . eglot-ensure)
         (zig-mode . eglot-ensure))
  :config
  (setq eglot-autoshutdown t)
  (setq eglot-events-buffer-size 0)
  (setq eglot-sync-connect nil)
  (add-to-list 'eglot-server-programs
               '((clojure-mode clojurescript-mode clojurec-mode) . ("clojure-lsp"))))

(use-package eldoc-box
  :config
  (setq eldoc-box-max-pixel-width 600)
  (setq eldoc-box-max-pixel-height 400))

(use-package flymake
  :ensure nil
  :hook (prog-mode . flymake-mode)
  :config
  (setq flymake-no-changes-timeout 0.5)
  (setq flymake-show-diagnostics-at-end-of-line nil))

(use-package treesit
  :ensure nil
  :config
  (setq treesit-language-source-alist
        '((bash "https://github.com/tree-sitter/tree-sitter-bash")
          (css "https://github.com/tree-sitter/tree-sitter-css")
          (html "https://github.com/tree-sitter/tree-sitter-html")
          (javascript "https://github.com/tree-sitter/tree-sitter-javascript")
          (json "https://github.com/tree-sitter/tree-sitter-json")
          (rust "https://github.com/tree-sitter/tree-sitter-rust")
          (typescript "https://github.com/tree-sitter/tree-sitter-typescript" "master" "typescript/src")
          (tsx "https://github.com/tree-sitter/tree-sitter-typescript" "master" "tsx/src")))
  (setq major-mode-remap-alist
        '((bash-mode . bash-ts-mode)
          (css-mode . css-ts-mode)
          (js-mode . js-ts-mode)
          (javascript-mode . js-ts-mode)
          (json-mode . json-ts-mode)
          (typescript-mode . typescript-ts-mode))))

(use-package clojure-mode
  :mode (("\\.clj\\'" . clojure-mode)
         ("\\.edn\\'" . clojure-mode)
         ("\\.cljs\\'" . clojurescript-mode)
         ("\\.cljc\\'" . clojurec-mode))
  :config
  (setq clojure-indent-style 'align-arguments)
  (setq clojure-align-forms-automatically t))

(use-package cider
  :after clojure-mode
  :hook ((clojure-mode . cider-mode)
         (clojurescript-mode . cider-mode)
         (clojurec-mode . cider-mode))
  :config
  (setq cider-repl-display-help-banner nil)
  (setq cider-repl-pop-to-buffer-on-connect 'display-only)
  (setq cider-show-error-buffer 'only-in-repl)
  (setq cider-auto-select-error-buffer nil)
  (setq cider-repl-history-file (expand-file-name "cider-history" user-emacs-directory))
  (setq cider-repl-wrap-history t)
  (setq cider-save-file-on-load t)
  (setq cider-auto-select-test-report-buffer nil)
  (setq cider-test-show-report-on-success nil)
  (setq cider-font-lock-dynamically '(macro core function var))
  (setq cider-print-fn 'puget)
  (setq cider-print-options '(("length" 100) ("right-margin" 80)))
  (setq cider-debug-prompt 'overlay)
  (setq cider-clojure-cli-aliases ":test:dev:repl"))

(defun my/cider-jack-in-with-aliases ()
  (interactive)
  (let ((cider-clojure-cli-aliases
         (read-string "Aliases (e.g. :test:dev:repl): " cider-clojure-cli-aliases)))
    (cider-jack-in-clj nil)))

(with-eval-after-load 'clojure-mode
  (add-hook 'clojure-mode-hook (lambda () (electric-pair-local-mode -1)))
  (add-hook 'clojurescript-mode-hook (lambda () (electric-pair-local-mode -1)))
  (add-hook 'clojurec-mode-hook (lambda () (electric-pair-local-mode -1)))

  (general-define-key
   :states '(normal visual)
   :keymaps '(clojure-mode-map clojurescript-mode-map clojurec-mode-map)
   :prefix ","

   "" '(nil :wk "clojure")
   "'" '(cider-jack-in-clj :wk "jack-in")

   "c" '(:ignore t :wk "connect")
   "cc" '(cider-connect-clj :wk "connect")
   "cs" '(cider-connect-cljs :wk "connect cljs")
   "cj" '(cider-jack-in-clj :wk "jack-in")
   "cJ" '(my/cider-jack-in-with-aliases :wk "jack-in (prompt)")
   "cq" '(cider-quit :wk "quit")
   "cr" '(cider-restart :wk "restart")

   "e" '(:ignore t :wk "eval")
   "eb" '(cider-eval-buffer :wk "buffer")
   "ed" '(cider-eval-defun-at-point :wk "defun")
   "eD" '(cider-eval-defun-to-comment :wk "defun to comment")
   "ee" '(cider-eval-sexp-at-point :wk "sexp at point")
   "eE" '(cider-eval-last-sexp-to-repl :wk "last sexp to repl")
   "ef" '(cider-eval-defun-at-point :wk "defun")
   "ei" '(cider-interrupt :wk "interrupt")
   "el" '(cider-eval-last-sexp :wk "last sexp")
   "em" '(cider-macroexpand-1 :wk "macroexpand-1")
   "eM" '(cider-macroexpand-all :wk "macroexpand-all")
   "en" '(cider-eval-ns-form :wk "ns form")
   "ep" '(cider-pprint-eval-last-sexp :wk "pprint last sexp")
   "eP" '(cider-pprint-eval-defun-at-point :wk "pprint defun")
   "er" '(cider-eval-region :wk "region")
   "es" '(cider-eval-sexp-at-point :wk "sexp at point")
   "eu" '(cider-eval-sexp-up-to-point :wk "sexp up to point")
   "ew" '(cider-eval-sexp-at-point :wk "word/sexp at point")
   "e;" '(cider-eval-print-last-sexp :wk "eval print last sexp")

   "f" '(cider-format-buffer :wk "format buffer")
   "F" '(cider-format-defun :wk "format defun")

   "d" '(:ignore t :wk "debug")
   "db" '(cider-debug-defun-at-point :wk "debug defun")
   "de" '(cider-enlighten-mode :wk "enlighten mode")
   "di" '(cider-inspect-last-result :wk "inspect last")
   "dI" '(cider-inspect :wk "inspect")
   "dr" '(cider-inspect-last-result :wk "inspect result")
   "dt" '(cider-toggle-trace-var :wk "trace var")
   "dT" '(cider-toggle-trace-ns :wk "trace ns")
   "dv" '(cider-inspect-defun-at-point :wk "inspect defun")

   "t" '(:ignore t :wk "test")
   "ta" '(cider-test-run-loaded-tests :wk "all loaded")
   "tc" '(cider-test-run-test :wk "at cursor")
   "tf" '(cider-test-rerun-failed-tests :wk "rerun failed")
   "tl" '(cider-test-run-loaded-tests :wk "loaded tests")
   "tn" '(cider-test-run-ns-tests :wk "ns tests")
   "tN" '(cider-test-run-ns-tests-with-filters :wk "ns *-test")
   "tp" '(cider-test-run-project-tests :wk "project")
   "tr" '(cider-test-rerun-tests :wk "rerun")
   "ts" '(cider-test-show-report :wk "show report")

   "r" '(:ignore t :wk "repl")
   "rb" '(cider-load-buffer :wk "load buffer")
   "rc" '(cider-repl-clear-buffer :wk "clear")
   "rn" '(cider-repl-set-ns :wk "set ns")
   "rq" '(cider-quit :wk "quit")
   "rr" '(cider-switch-to-repl-buffer :wk "switch to repl")
   "rR" '(cider-ns-refresh :wk "refresh")
   "rx" '(cider-refresh :wk "refresh all")

   "h" '(:ignore t :wk "help")
   "ha" '(cider-apropos :wk "apropos")
   "hA" '(cider-apropos-documentation :wk "apropos doc")
   "hc" '(cider-clojuredocs :wk "clojuredocs")
   "hd" '(cider-doc :wk "doc")
   "hj" '(cider-javadoc :wk "javadoc")
   "hn" '(cider-find-ns :wk "find ns")
   "hs" '(cider-browse-spec :wk "browse spec")

   "n" '(:ignore t :wk "navigate")
   "nb" '(cider-pop-back :wk "pop back")
   "nn" '(cider-browse-ns :wk "browse ns")
   "nN" '(cider-browse-ns-all :wk "all ns")
   "ns" '(cider-browse-spec :wk "browse spec")
   "nS" '(cider-browse-spec-all :wk "all specs")))

(use-package parinfer-rust-mode
  :hook ((clojure-mode clojurescript-mode clojurec-mode emacs-lisp-mode lisp-mode scheme-mode) . parinfer-rust-mode)
  :init
  (setq parinfer-rust-auto-download t)
  (setq parinfer-rust-troublesome-modes nil))

; (use-package paredit
;   :hook ((clojure-mode . paredit-mode)
;          (clojurescript-mode . paredit-mode)
;          (clojurec-mode . paredit-mode)
;          (emacs-lisp-mode . paredit-mode)
;          (lisp-mode . paredit-mode)
;          (scheme-mode . paredit-mode)
;          (cider-repl-mode . paredit-mode)))

(add-hook 'emacs-lisp-mode-hook (lambda () (electric-pair-local-mode -1)))
(add-hook 'lisp-mode-hook (lambda () (electric-pair-local-mode -1)))
(add-hook 'scheme-mode-hook (lambda () (electric-pair-local-mode -1)))

(defun my/setup-elisp-keys ()
  (general-define-key
   :states '(normal visual)
   :keymaps 'local
   :prefix ","
   "" '(nil :wk "elisp")
   "e" '(:ignore t :wk "eval")
   "eb" '(eval-buffer :wk "buffer")
   "ed" '(eval-defun :wk "defun")
   "ee" '(eval-last-sexp :wk "last sexp")
   "er" '(eval-region :wk "region")
   "h" '(:ignore t :wk "help")
   "hf" '(helpful-callable :wk "function")
   "hv" '(helpful-variable :wk "variable")))

(add-hook 'emacs-lisp-mode-hook #'my/setup-elisp-keys)

(use-package org
  :ensure nil
  :mode ("\\.org\\'" . org-mode)
  :config
  (setq org-directory "~/org")
  (setq org-default-notes-file (concat org-directory "/notes.org"))
  (setq org-agenda-files (list org-directory))

  (setq org-startup-indented t)
  (setq org-startup-folded 'content)
  (setq org-hide-leading-stars t)
  (setq org-hide-emphasis-markers t)
  (setq org-pretty-entities t)
  (setq org-ellipsis " ▾")

  (setq org-return-follows-link t)
  (setq org-mouse-1-follows-link t)

  (setq org-todo-keywords
        '((sequence "TODO(t)" "IN-PROGRESS(i)" "WAITING(w)" "|" "DONE(d)" "CANCELLED(c)")))

  (setq org-capture-templates
        '(("t" "Todo" entry (file+headline "~/org/todos.org" "Inbox")
           "* TODO %?\n%U\n")
          ("n" "Note" entry (file+headline "~/org/notes.org" "Notes")
           "* %?\n%U\n")
          ("j" "Journal" entry (file+datetree "~/org/journal.org")
           "* %?\nEntered on %U\n")))

  (setq org-log-done 'time)
  (setq org-log-into-drawer t)

  (setq org-src-fontify-natively t)
  (setq org-src-tab-acts-natively t)
  (setq org-edit-src-content-indentation 0)
  (setq org-confirm-babel-evaluate nil)

  (org-babel-do-load-languages
   'org-babel-load-languages
   '((emacs-lisp . t)
     (shell . t)
     (clojure . t))))

(use-package org-modern
  :hook (org-mode . org-modern-mode)
  :config
  (setq org-modern-star '("◉" "○" "●" "○" "●" "○" "●"))
  (setq org-modern-table nil))

(defun my/setup-org-keys ()
  (general-define-key
   :states '(normal visual)
   :keymaps 'local
   :prefix ","
   "" '(nil :wk "org")

   "'" '(org-edit-special :wk "edit src block")
   "RET" '(org-open-at-point :wk "open link")

   "a" '(org-archive-subtree :wk "archive")

   "b" '(:ignore t :wk "babel")
   "be" '(org-babel-execute-src-block :wk "execute block")
   "bE" '(org-babel-execute-buffer :wk "execute buffer")
   "bt" '(org-babel-tangle :wk "tangle")

   "c" '(:ignore t :wk "clock")
   "ci" '(org-clock-in :wk "clock in")
   "co" '(org-clock-out :wk "clock out")
   "cc" '(org-clock-cancel :wk "cancel")
   "cg" '(org-clock-goto :wk "goto")

   "d" '(:ignore t :wk "date")
   "dd" '(org-deadline :wk "deadline")
   "ds" '(org-schedule :wk "schedule")
   "dt" '(org-time-stamp :wk "timestamp")

   "e" '(org-export-dispatch :wk "export")

   "h" '(:ignore t :wk "heading")
   "hi" '(org-insert-heading-after-current :wk "insert after")
   "hI" '(org-insert-heading :wk "insert")
   "hs" '(org-insert-subheading :wk "subheading")

   "i" '(:ignore t :wk "insert")
   "il" '(org-insert-link :wk "link")
   "it" '(org-insert-todo-heading :wk "todo")
   "ip" '(org-set-property :wk "property")

   "l" '(:ignore t :wk "link")
   "ll" '(org-insert-link :wk "insert")
   "ls" '(org-store-link :wk "store")
   "lp" '(org-cliplink :wk "paste from clipboard")

   "n" '(org-narrow-to-subtree :wk "narrow")
   "N" '(widen :wk "widen")

   "p" '(org-priority :wk "priority")

   "s" '(:ignore t :wk "subtree")
   "sr" '(org-refile :wk "refile")
   "sn" '(org-narrow-to-subtree :wk "narrow")
   "ss" '(org-sort :wk "sort")

   "t" '(org-todo :wk "cycle todo")
   "T" '(org-set-tags-command :wk "set tags")

   "x" '(org-toggle-checkbox :wk "toggle checkbox")))

(add-hook 'org-mode-hook #'my/setup-org-keys)

(use-package org-cliplink
  :commands org-cliplink)

(use-package rainbow-delimiters
  :hook (prog-mode . rainbow-delimiters-mode))

(use-package rust-mode
  :mode "\\.rs\\'")

(defun my/setup-rust-keys ()
  (general-define-key
   :states '(normal visual)
   :keymaps 'local
   :prefix ","
   "" '(nil :wk "rust")
   "b" '((lambda () (interactive) (compile "cargo build")) :wk "build")
   "c" '((lambda () (interactive) (compile "cargo check")) :wk "check")
   "r" '((lambda () (interactive) (compile "cargo run")) :wk "run")
   "R" '((lambda () (interactive) (compile "cargo run --release")) :wk "run release")
   "t" '((lambda () (interactive) (compile "cargo test")) :wk "test")
   "C" '((lambda () (interactive) (compile "cargo clippy")) :wk "clippy")
   "f" '(rust-format-buffer :wk "format")
   "h" '(eglot-inlay-hints-mode :wk "toggle inlay hints")))

(add-hook 'rust-mode-hook #'my/setup-rust-keys)
(add-hook 'rust-ts-mode-hook #'my/setup-rust-keys)

(setq rust-format-on-save t)

(use-package zig-mode
  :mode "\\.zig\\'"
  :config
  (setq zig-format-on-save t))

(defun my/setup-zig-keys ()
  (general-define-key
   :states '(normal visual)
   :keymaps 'local
   :prefix ","
   "" '(nil :wk "zig")
   "b" '((lambda () (interactive) (compile "zig build")) :wk "build")
   "r" '((lambda () (interactive) (compile "zig build run")) :wk "run")
   "t" '((lambda () (interactive) (compile "zig build test")) :wk "test")
   "h" '(eglot-inlay-hints-mode :wk "toggle inlay hints")))

(add-hook 'zig-mode-hook #'my/setup-zig-keys)

(use-package web-mode
  :mode (("\\.html\\'" . web-mode)
         ("\\.css\\'" . web-mode)
         ("\\.tsx\\'" . web-mode)
         ("\\.jsx\\'" . web-mode))
  :config
  (setq web-mode-markup-indent-offset 2)
  (setq web-mode-css-indent-offset 2)
  (setq web-mode-code-indent-offset 2))

(use-package emmet-mode
  :hook ((web-mode . emmet-mode)
         (css-mode . emmet-mode)))

(use-package helpful
  :commands (helpful-callable helpful-variable helpful-key helpful-symbol))

(use-package writeroom-mode
  :commands writeroom-mode
  :config
  (setq writeroom-width 100)
  (setq writeroom-mode-line t))

(use-package restart-emacs
  :commands restart-emacs)

(use-package dired
  :ensure nil
  :commands dired
  :config
  (setq dired-listing-switches "-alh --group-directories-first")
  (setq dired-dwim-target t)
  (setq dired-kill-when-opening-new-dired-buffer t))

(setq-default bidi-display-reordering nil)
(setq-default bidi-paragraph-direction 'left-to-right)
(setq bidi-inhibit-bpa t)
(setq inhibit-compacting-font-caches t)
(setq read-process-output-max (* 1024 1024))

(require 'server)
(unless (server-running-p) (server-start))

(provide 'init)
;;; init.el ends here

init.lua

---@diagnostic disable: undefined-global

local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not vim.uv.fs_stat(lazypath) then
  vim.fn.system({
    "git",
    "clone",
    "--filter=blob:none",
    "https://github.com/folke/lazy.nvim.git",
    "--branch=stable",
    lazypath,
  })
end
vim.opt.rtp:prepend(lazypath)

vim.g.mapleader = " "
vim.g.maplocalleader = ","

local plugins = {
  { "neovim/nvim-lspconfig", tag = "v2.5.0" },
  {
    "nvim-tree/nvim-web-devicons",
    lazy = false,
    priority = 1000,
    opts = {},
  },
  {
    "folke/which-key.nvim",
    event = "VeryLazy",
    opts = {},
  },
  {
   "nvim-telescope/telescope.nvim",
   dependencies = { "nvim-lua/plenary.nvim" },
    opts = {
      defaults = {
       sorting_strategy = "ascending",
       layout_config = {
          horizontal = {
            prompt_position = "top"
         },
        },
      },
    },
  },
  {
    "folke/flash.nvim",
    event = "VeryLazy",
    opts = {},
    keys = {
      { "s", mode = { "n", "x", "o" }, function() require("flash").jump() end, desc = "Flash" },
      { "S", mode = { "n", "x", "o" }, function() require("flash").treesitter() end, desc = "Flash Treesitter" },
      { "r", mode = "o", function() require("flash").remote() end, desc = "Remote Flash" },
      { "R", mode = { "o", "x" }, function() require("flash").treesitter_search() end, desc = "Treesitter Search" },
      { "<c-s>", mode = { "c" }, function() require("flash").toggle() end, desc = "Toggle Flash Search" },
    },
  },
  {
    "akinsho/toggleterm.nvim",
    version = "*",
    config = function()
      require("toggleterm").setup {
        open_mapping = [[<leader>t]],
        direction = "float",
        -- on_open = function() vim.cmd('startinsert!') end,
        insert_mappings = false,
        start_in_insert = false,
        terminal_mappings = false,
      }
    end
  },
  -- {
  --   "kdheepak/lazygit.nvim",
  --   lazy = true,
  --   cmd = {
  --       "LazyGit",
  --       "LazyGitConfig",
  --       "LazyGitCurrentFile",
  --       "LazyGitFilter",
  --       "LazyGitFilterCurrentFile",
  --   },
  --   dependencies = {
  --       "nvim-lua/plenary.nvim",
  --   },
  --   keys = {
  --       { "<leader>lg", "<cmd>LazyGit<cr>", desc = "LazyGit" }
  --   }
  -- },
  {
  "NeogitOrg/neogit",
    dependencies = {
      "nvim-lua/plenary.nvim",         -- required
      "sindrets/diffview.nvim",        -- optional - Diff integration

      -- Only one of these is needed.
      "nvim-telescope/telescope.nvim", -- optional
      "ibhagwan/fzf-lua",              -- optional
      "echasnovski/mini.pick",         -- optional
    },
  config = true
  },
  {
    "NMAC427/guess-indent.nvim",
    config = function()
      require("guess-indent").setup {}
    end,
  },
  { "junegunn/fzf", build = "./install --all" },
  "junegunn/fzf.vim",
  "junegunn/goyo.vim",
  {
    "HiPhish/rainbow-delimiters.nvim",
    enabled = true,
    submodules = false,
  },
  {
    "j-hui/fidget.nvim",
    opts = {},
  },
  "mbbill/undotree",
  "preservim/nerdtree",
  "tpope/vim-commentary",
  "tpope/vim-fugitive",
  "tpope/vim-repeat",
  "tpope/vim-surround",

  {
    "hrsh7th/nvim-cmp",
    dependencies = {
      "hrsh7th/cmp-nvim-lsp",
      "hrsh7th/cmp-buffer",
      "hrsh7th/cmp-path",
      "L3MON4D3/LuaSnip",
      "saadparwaiz1/cmp_luasnip",
      "onsails/lspkind-nvim",
    },
  },
  {
    "nvim-treesitter/nvim-treesitter",
    build = ":TSUpdate",
    config = function()
      require("nvim-treesitter.configs").setup({
        ensure_installed = {
          "lua", "vim", "vimdoc", "javascript", "typescript",
          "rust", "java", "clojure", "css", "html", "csv", "regex"
        },
        auto_install = true,
        highlight = { enable = true },
        indent = { enable = true },
      })
    end,
  },
  {
    "windwp/nvim-autopairs",
    event = "InsertEnter",
    config = function()
      local npairs = require("nvim-autopairs")
      npairs.setup({})
      npairs.get_rules("'")[1].not_filetypes = { "clojure" }
    end,
  },

  { "clojure-vim/clojure.vim", ft = "clojure" },
  { "Olical/conjure",
    branch = "develop",
    ft = { "clojure", "scheme" },
    config = function()
    vim.g["conjure#client#clojure#nrepl#eval#print_function"] = "cider.nrepl.pprint/pprint"
    vim.g["conjure#client#clojure#nrepl#eval#print_options"] = {
      length = 500,
      level = 50,
      ["right-margin"] = 80
    }
    vim.g["conjure#log#wrap"] = true
    vim.g["conjure#log#fold#enabled"] = true
    end
  },
  {
    "eraserhd/parinfer-rust",
    build = "cargo build --release",
    config = function()
      vim.g.parinfer_rust_path = vim.fn.stdpath("data")
          .. "/lazy/parinfer-rust/target/release/libparinfer_rust.so"
    end
  },
  "guns/vim-sexp",
  "tpope/vim-sexp-mappings-for-regular-people",

  { "chrisbra/csv.vim" },

  { "mattn/webapi-vim",   ft = "rust" },
  { "rust-lang/rust.vim", ft = "rust" },
  {
    'mrcjkb/rustaceanvim',
    version = '^6', -- Recommended
    lazy = false, -- This plugin is already lazy
  },

  "mattn/emmet-vim",
  "maxmellon/vim-jsx-pretty",
  "prisma/vim-prisma",
  -- {
  --   "luckasRanarison/tailwind-tools.nvim",
  --   name = "tailwind-tools",
  --   build = ":UpdateRemotePlugins",
  --   dependencies = {
  --     "nvim-treesitter/nvim-treesitter",
  --     "nvim-telescope/telescope.nvim",
  --     "neovim/nvim-lspconfig",
  --   },
  --   opts = {
  --     server = {
  --       override = true,
  --       settings = {
  --         emmetCompletions = true,
  --         includeLanguages = { clojurescript = "html", rust = "html" },
  --         experimental = {
  --           classRegex = {
  --             { "\\[:[^.\\s]*((?:\\.[^.\\s\\]]*)+)[\\s\\]]", "\\.([^.]*)" },
  --             { "\\:(\\.[^\\s#]+(?:\\.[^\\s#]+)*)", "\\.([^\\.\\s#]+)" },
  --             { "\\:class\\s+(\\:[^\\s\\}]*)[\\s\\}]", "[\\:.]([^.]*)" },
  --             { "\\:class\\s+(\"[^\\}\"]*)\"", "[\"\\s]([^\\s\"]*)" },
  --             { "\\:class\\s+\\[([\\s\\S]*)\\]", "[\"\\:]([^\\s\"]*)[\"]?" },
  --             { "\\:class\\s+'\\[([\\s\\S]*)\\]", "([^\\s]*)?" },
  --             { "class\\s*:\\s*\"([^\"]*)" },
  --           },
  --         },
  --       },
  --     },
  --   },
  -- },

  "arcticicestudio/nord-vim",
  "ayu-theme/ayu-vim",
  "chriskempson/vim-tomorrow-theme",
  "folke/tokyonight.nvim",
  "gruvbox-community/gruvbox",
  { "https://gitlab.com/yorickpeterse/vim-paper.git" },
  "iagorrr/noctishc.nvim",
  "iCyMind/NeoSolarized",
  "ishan9299/modus-theme-vim",
  "marko-cerovac/material.nvim",
  "Mofiqul/dracula.nvim",
  "nanotech/jellybeans.vim",
  "NLKNguyen/papercolor-theme",
  "plan9-for-vimspace/acme-colors",
  "projekt0n/github-nvim-theme",
  "rakr/vim-one",
  "yassinebridi/vim-purpura",
}

require("lazy").setup(plugins)

local opt = vim.opt
opt.backupcopy = "yes"
opt.clipboard = { "unnamedplus" }
opt.cmdheight = 2
opt.completeopt = "menuone"
opt.cursorline = true
opt.expandtab = true
opt.hidden = true
opt.ignorecase = true
opt.inccommand = "nosplit"
opt.laststatus = 3
opt.mat = 2
opt.mouse = ""
opt.number = true
opt.shiftwidth = 2
opt.shortmess:append("c")
opt.showmatch = true
opt.signcolumn = "yes"
opt.smartcase = true
opt.smartindent = true
opt.softtabstop = 2
opt.splitbelow = true
opt.splitright = true
opt.swapfile = false
opt.tabstop = 2
opt.undodir = vim.fn.expand("~/.vim/undo-dir")
opt.undofile = true
opt.wildoptions = "pum"
vim.cmd('filetype plugin on')
vim.g.open_in_insert_mode = 0
vim.g.python3_host_prog = "/usr/bin/python3"

local function map(mode, lhs, rhs, opts)
  local options = { noremap = true, silent = true }
  if opts then options = vim.tbl_extend('force', options, opts) end
  vim.keymap.set(mode, lhs, rhs, options)
end

map('i', 'jk', '<ESC>')
map('t', 'jk', [[<C-\><C-n>]])
map('t', '<C-[>', [[<C-\><C-n>]])

map('n', '<leader>g', 'gg"+yG')
map('n', '<leader><CR>', ':noh<CR>')
map('n', '<C-g>', ':Goyo<CR>')
map('n', '<leader><tab>', '<C-^>')
map('n', '<leader><leader>', 'o<Esc>k')
map('n', '<leader>b', ':Buffers<CR>')
map('n', '<leader>cd', ':set background=dark<CR>')
map('n', '<leader>cl', ':set background=light<CR>')
map('n', '<leader>cs', ':colorscheme<Space>')
map('n', '<leader>a', ':NERDTreeToggle<CR>')
map('n', '<leader>f', ':Files<CR>')
map('n', '<leader>o', ':only<CR>')
map('n', '<leader>q', ':x<CR>')
map('n', '<leader>s', ':split<CR>:res -8<CR><leader>t')
map('n', '<leader>v', ':e $MYVIMRC<CR>')
map('n', '<leader>w', ':w<CR>')
map('n', '<leader>y', ':set nonumber<CR>:set signcolumn=no<CR>')

vim.keymap.set('n', 'zT', function()
  local wh = vim.api.nvim_win_get_height(0)
  local offset = math.floor(wh / 4)
  return offset .. 'kzt' .. offset .. 'j'
end, { expr = true, silent = true })

map({ 'n', 'v' }, 'c', '"_c')
map({ 'n', 'v' }, 'C', '"_C')

local capabilities = require("cmp_nvim_lsp").default_capabilities()
local lspconfig = require("lspconfig")
local util = require("lspconfig.util")
local servers = {
  "clojure_lsp", "cssls", "html", "ts_ls",
  "jdtls", "lua_ls", "zls", "clangd", "ols"
}
for _, lsp in ipairs(servers) do
  local opts = { capabilities = capabilities }
  if lsp == "clojure_lsp" then
    opts.root_dir = util.root_pattern(".git")
    opts.settings = {
      ["clojure-lsp"] = {
        format = { enabled = true },
        ["cljfmt-config-path"] = ".cljfmt.edn"
      }
    }
  elseif lsp == "ols" then
    opts.settings = {
      ols = {
        format = {
          enable = true,
          indentationStyle = "tab",
          indentWidth = 4
        }
      }
    }
  elseif lsp == "zls" then
    opts.settings = {
      zls = {
        semantic_tokens = "partial",
        enable_build_on_save = true,
      }
    }
  end
  lspconfig[lsp].setup(opts)
end

vim.api.nvim_create_autocmd("LspAttach", {
  callback = function(args)
    local bufnr = args.buf
    vim.lsp.inlay_hint.enable(false, { bufnr = bufnr })
  end,
})

vim.api.nvim_create_autocmd('BufWritePre', {
  pattern = { "*.ts", "*.tsx", "*.js", "*.jsx" },
  callback = function()
    vim.lsp.buf.format({ async = false })
  end,
})

vim.api.nvim_create_autocmd('BufWritePre', {
  pattern = {"*.zig", "*.zon"},
  callback = function()
    vim.lsp.buf.format({ async = false})
  end
})

vim.keymap.set("n", "<localleader>h", function()
  local bufnr = vim.api.nvim_get_current_buf()
  vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled({ bufnr = bufnr }), { bufnr = bufnr })
end, { desc = "Toggle LSP inlay hints" })

vim.diagnostic.config({
  virtual_text = false,
  signs = true,
  underline = true,
  severity_sort = true,
})

vim.keymap.set("n", "<leader>e", function()
  vim.diagnostic.open_float(nil, { scope = "line" })
end, { silent = true })

local cmp = require("cmp")
local luasnip = require("luasnip")
local check_backspace = function()
  local col = vim.fn.col('.') - 1
  return col == 0 or vim.fn.getline('.'):sub(col, col):match('%s')
end

vim.g.goyo_active = false

cmp.setup({
  enabled = function() return not vim.g.goyo_active end,
  formatting = {
    format = require("lspkind").cmp_format({
      -- before = require("tailwind-tools.cmp").lspkind_format
    }),
  },
  snippet = {
    expand = function(args) luasnip.lsp_expand(args.body) end,
  },
  mapping = {
    ["<Tab>"] = cmp.mapping(function(fallback)
      if cmp.visible() then
        cmp.select_next_item()
      elseif check_backspace() then
        fallback()
      else
        cmp.complete()
      end
    end, { "i", "s" }),
    ["<S-Tab>"] = cmp.mapping(function(fallback)
      if cmp.visible() then cmp.select_prev_item() else fallback() end
    end, { "i", "s" }),
    ["<CR>"] = cmp.mapping(function(fallback)
      if cmp.visible() then
        cmp.confirm({ select = true, behavior = cmp.ConfirmBehavior.Replace })
      else
        fallback()
      end
    end, { "i", "s" }),
    ["<C-u>"] = cmp.mapping.scroll_docs(4),
    ["<C-d>"] = cmp.mapping.scroll_docs(-4),

    ["<C-n>"] = cmp.mapping(function(fallback)
      if cmp.visible() then
        cmp.select_next_item()
      else
        fallback()
      end
    end, { "i", "s" }),
    ["<C-p>"] = cmp.mapping(function(fallback)
      if cmp.visible() then
        cmp.select_prev_item()
      else
        fallback()
      end
    end, { "i", "s" }),
  },
  sources = {
    { name = "buffer" },
    { name = "conjure" },
    { name = "luasnip" },
    { name = "nvim_lsp" },
    { name = "path" },
  },
})

vim.api.nvim_create_autocmd("User", {
  pattern = "GoyoEnter",
  callback = function()
    vim.g.goyo_active = true
    pcall(function() require("cmp").abort() end)
    vim.opt_local.wrap = true
    vim.opt_local.linebreak = true
  end,
})

vim.api.nvim_create_autocmd("User", {
  pattern = "GoyoLeave",
  callback = function()
    vim.g.goyo_active = false
    vim.opt_local.linebreak = false
    vim.opt_local.wrap = false
  end,
})

vim.keymap.set('n', 'K', vim.lsp.buf.hover, { noremap = true, silent = true })
vim.keymap.set('n', '<leader>k', vim.lsp.buf.hover, { noremap = true, silent = true })
vim.keymap.set('n', 'gd', vim.lsp.buf.definition, { noremap = true, silent = true })
vim.keymap.set('n', 'gy', vim.lsp.buf.type_definition, { noremap = true, silent = true })
vim.keymap.set('n', 'gi', vim.lsp.buf.implementation, { noremap = true, silent = true })
vim.keymap.set('n', 'gr', vim.lsp.buf.references, { noremap = true, silent = true })
vim.keymap.set('n', 'gn', vim.lsp.buf.rename, { noremap = true, silent = true })
vim.keymap.set('n', 'ga', vim.lsp.buf.code_action, { noremap = true, silent = true })
vim.keymap.set('n', '[g', vim.diagnostic.goto_prev, { noremap = true, silent = true })
vim.keymap.set('n', ']g', vim.diagnostic.goto_next, { noremap = true, silent = true })
vim.keymap.set('n', 'gl', vim.diagnostic.open_float, { noremap = true, silent = true })
vim.keymap.set('n', 'gD', vim.diagnostic.setloclist, { noremap = true, silent = true })
vim.keymap.set('n', '<leader>p', '<cmd>Telescope commands<CR>', { noremap = true, silent = true })

vim.g['conjure#log#hud#width'] = 1
vim.g['conjure#client#clojure#nrepl#connection#auto_repl#enabled'] = false
vim.g['conjure#eval#comment_prefix'] = ';; '

vim.g.NERDTreeWinSize = 40
vim.g.rustfmt_autosave = 1
vim.g.zig_fmt_autosave = 1

vim.api.nvim_create_autocmd('FileType', {
  pattern = '*',
  callback = function()
    vim.opt_local.formatoptions:remove { 'r', 'o' }
  end
})
vim.api.nvim_create_autocmd('FileType', {
  pattern = '*',
  callback = function()
    vim.opt_local.modifiable = true
  end
})

local scratch_dir = vim.fn.expand('~/.nvim/scratch')
vim.fn.mkdir(scratch_dir, 'p')
vim.api.nvim_create_user_command('Scratch', function()
  local filename = scratch_dir .. '/scratch-' .. os.time()
  vim.cmd('new ' .. filename)
  vim.bo.buftype = 'nofile'
  vim.bo.bufhidden = 'hide'
  vim.bo.swapfile = false
  vim.wo.number = true
end, {})

local function term_exec(cmd)
  require('toggleterm').exec(cmd)
end

local ft_settings = {
  c = {
    settings = function()
      vim.opt_local.shiftwidth = 4
      vim.opt_local.tabstop = 4
      vim.opt_local.softtabstop= 4
    end,
    mappings = {
      { 'n', '<localleader>c', ':!cc ' },
      { 'n', '<localleader>l', ':!cc -Wall -Wextra ' },
      { 'n', '<localleader>r', function()
          local file = vim.fn.expand('%')
          local output = 'a.out'
          local cmd = string.format('zig cc %s -Wall -Wextra -o %s && ./%s', file, output, output)
          term_exec(cmd)
        end
      }
    }
  },
  clojure = {
    settings = function()
      vim.cmd('stopinsert')
      vim.opt_local.shiftwidth = 2
      vim.opt_local.tabstop = 2
      vim.opt_local.commentstring = ';; %s'
    end,
    mappings = {
      { 'n', '<localleader>cc',  ':ConjureConnect<Space>' },
      { 'n', '<localleader>cs',  ':ConjureShadowSelect<Space>' },
      { 'n', '<localleader>f',   function() vim.lsp.buf.format({ async = false }) end },  -- Format buffer with cljfmt
      { 'v', '<localleader>f',   function() vim.lsp.buf.format({ async = false }) end },  -- Format selection
      { 'n', '<localleader>hd',  ':let g:conjure#log#hud#enabled = v:false<CR>' },
      { 'n', '<localleader>he',  ':let g:conjure#log#hud#enabled = v:true<CR>' },
      { 'n', '<localleader>jT',  '<Cmd>TapForm<CR>' },
      { 'n', '<localleader>jt',  '<Cmd>TapWord<CR>' },
      { 'v', '<localleader>jt',  ':TapV<CR>' },
      { 'n', '<localleader>jte', '<Cmd>TapExc<CR>' }
    }
  },
  go = {
    mappings = {
      { 'n', '<localleader>b', ':!go build<CR>' },
      { 'n', '<localleader>r', ':!go run .<CR>' }
    }
  },
  java = {
    mappings = {
      { 'n', '<localleader>r', ':!java src/Main.java<CR>' },
      { 'n', '<localleader>,', ':!java ' }
    }
  },
  odin = {
    settings = function()
      vim.opt_local.shiftwidth = 4
      vim.opt_local.tabstop = 4
    end,
    mappings = {
      { 'n', '<localleader>b', function() term_exec('odin build .') end },
      { 'n', '<localleader>r', function() term_exec('odin run .') end },
      { 'n', '<localleader>t', function() term_exec('odin test .') end },
    }
  },
  rust = {
    mappings = {
      { 'n', '<localleader>a', function() vim.ui.input({prompt='Package: '}, function(input)
          if input then term_exec('cargo add ' .. input) end
        end)
      end },
      { 'n', '<localleader>b', function() term_exec('cargo build') end },
      { 'n', '<localleader>c', function() term_exec('cargo check') end },
      { 'n', '<localleader>C', function() term_exec('cargo clippy --all-targets --all-features -- -D warnings -W clippy::pedantic -W clippy::nursery') end },
      { 'n', '<localleader>p', 'o<CR>println!("{:?}", );<Esc>hi' },
      { 'n', '<localleader>r', function() term_exec('cargo run') end },
      { 'n', '<localleader>R', function() term_exec('cargo run --release') end },
      { 'n', '<localleader>t', function() term_exec('cargo test') end },
      { 'n', '<localleader>,', ':Rust' },
    }
  },
  zig = {
    settings = function()
      vim.opt_local.shiftwidth = 4
      vim.opt_local.tabstop = 4
    end,
    mappings = {
      { 'n', '<localleader>b', function() term_exec('zig build') end },
      { 'n', '<localleader>r', function() term_exec('zig build run ') end },
      { 'n', '<localleader>R', function()
          vim.ui.input({prompt='Args: '}, function(input)
            if input then term_exec('zig run ' .. vim.fn.expand('%') .. ' -- ' .. input) end
          end)
        end },
      { 'n', '<localleader>t', function() term_exec('zig build test') end },
      { 'n', '<localleader>z', function()
          vim.ui.input({prompt='Zig command: '}, function(input)
            if input then term_exec('zig ' .. input) end
          end)
        end }
    }
  }
}

for ft, config in pairs(ft_settings) do
  vim.api.nvim_create_autocmd('FileType', {
    pattern = ft,
    callback = function()
      if config.settings then config.settings() end
      if config.mappings then
        for _, mapping in ipairs(config.mappings) do
          map(mapping[1], mapping[2], mapping[3], { buffer = true })
        end
      end
    end
  })
end

vim.opt.termguicolors = true
vim.cmd([[colorscheme NeoSolarized]])
vim.opt.background = 'light'