Thornjad's Emacs Configuration

  (defun aero/kill-line-autoreindent ()
    "Kill excess whitespace when joining lines.
If the next line is joined to the current line, kill the extra indent
whitespace in front of the next line."
    (when (and (eolp) (not (bolp)))
      (save-excursion
        (forward-char 1)
        (just-one-space 1))))
  (advice-add 'kill-line :before #'aero/kill-line-autoreindent)

(defun aero/advice-elisp-get-fnsym-args-string (fn sym &rest args)
  "If SYM is a function, append its docstring."
  (concat
   (apply fn sym args)
   (let ((doc (and (fboundp sym) (documentation sym 'raw))))
     (and doc
          (stringp doc)
          (not (string= "" doc))
          (concat "\n\n" (propertize doc 'face 'italic))))))
(advice-add 'elisp-get-fnsym-args-string :around #'aero/advice-elisp-get-fnsym-args-string)

(define-advice comment-indent-new-line (:after (&optional _soft) at-least-one-space)
  "Ensure that at least one space is added after the comment-start."
  (let ((start (regexp-quote comment-start)))
    (when (and (nth 4 (syntax-ppss))
               (looking-back start (+ (point) (length start)))
               (not (looking-back " "  (+ (point) 1))))
      (insert " "))))

(defun aero/kill-buffer-around-advice (orig-fun &rest args)
  "Don't kill my scratch!"
  (let ((buffer-to-kill (car args)))
    (if (equal buffer-to-kill "*scratch*")
        (bury-buffer)
      (apply orig-fun args))))
(advice-add 'kill-buffer :around #'aero/kill-buffer-around-advice)

  (defun aero/keyboard-quit-context ()
    "Quit current context.

  This function is a combination of `keyboard-quit' and `keyboard-escape-quit'
  with some parts omitted and some custom behavior added."
    ;; Adapted from https://with-emacs.com/posts/tips/quit-current-context/
    (interactive)
    (cond
     ((region-active-p)
      ;; Avoid adding the region to the window selection.
      (setq saved-region-selection nil)
      (let (select-active-regions)
        (deactivate-mark)))

     ((eq last-command 'mode-exited)
      nil)

     (current-prefix-arg
      nil)

     (defining-kbd-macro
       (message
        (substitute-command-keys
         "Quit is ignored during macro definition, use \\[kmacro-end-macro] if you want to stop macro definition"))
       (cancel-kbd-macro-events))

     ((active-minibuffer-window)
      (when (get-buffer-window "*Completions*")
        ;; hide completions first so point stays in active window when
        ;; outside the minibuffer
        (minibuffer-hide-completions))
      (abort-recursive-edit))

     (t
      (keyboard-quit))))

  (defun aero/comment-dwim ()
    "Comment region if active, else comment line.

This avoids the excess region commenting of `comment-line' while also
avoiding the weird single-line behavior of `comment-dwim'."
    (interactive)
    (save-excursion
      (if (use-region-p)
          (call-interactively #'comment-or-uncomment-region)
        (call-interactively #'comment-line))))

  (defmacro aero/voidvar! (&rest body)
    "Appease the compiler by pretending to use variables in BODY.

  Similar to C++'s void var construct."
    `(and ,@body))

(defun system-is-mac () (string= system-type 'darwin))
(defun system-is-linux () (string= system-type 'gnu/linux))
(defun system-is-mswindows () (string= system-type 'windows-nt))
(defun window-system-is-mac () (memq (window-system) '(mac ns)))
(defun in-nix-shell-p () (string-equal (getenv "IN_NIX_SHELL") "1"))

(defun aero/has-modules-p ()
  "Return true when Emacs has been compiled with modules support."
  (and (functionp 'module-load) (bound-and-true-p module-file-suffix)))

(defun treesitterp ()
  "Evaluate whether Emacs has treesitter support."
  (and (functionp 'treesit-available-p) (treesit-available-p)))

(defun aero/switch-to-minibuffer-window ()
  "switch to minibuffer window (if active)"
  (interactive)
  (when (active-minibuffer-window)
    (select-window (active-minibuffer-window))))

(defun switch-to-messages-buffer ()
  (interactive)
  (switch-to-buffer "*Messages*"))

(defun switch-to-scratch-buffer ()
  (interactive)
  (switch-to-buffer "*scratch*"))

(defun switch-to-new-scratch-buffer ()
  (interactive)
  (switch-to-buffer (generate-new-buffer "*scratch*")))

(defun aero/bury-buffer-kill-window (&optional window)
  "Bury the current buffer and kill its window, or use WINDOW."
  (interactive)
  (let* ((buf (window-buffer window))
         (win (get-buffer-window buf)))
    (bury-buffer buf)
    (delete-window win)))

(defun aero/alternate-buffer (&optional window)
  "Switch back and forth between current and last buffer in the current window."
  (interactive)
  (cl-destructuring-bind
      (buf start pos)
      (or (cl-find (window-buffer window) (window-prev-buffers) :key #'car :test-not #'eq)
          (list (other-buffer) nil nil))
    (if (not buf)
        (message "Last buffer not found")
      (set-window-buffer-start-and-point window buf start pos))))

(defun aero/alternate-window ()
  "Switch back and forth between current and last window in the current frame."
  (interactive)
  (let ( ;; switch to first window previously shown in this frame
        (prev-window (get-mru-window nil t t)))
    ;; Check window was not found successfully
    (unless prev-window
      (user-error "Last window not found."))
    (select-window prev-window)))

(defun aero/tail-compilation-buffer ()
  "Reset tailing the compilation buffer."
  (interactive)
  (let* ((buf-name (aero/get-compilation-buffer-name))
         (window (get-buffer-window buf-name))
         (pos (with-current-buffer buf-name (point-max))))
    (set-window-point window pos)))

(defun aero/project-compile-popup ()
  "Run `project-compile' and pop up the compilation buffer."
  (interactive)
  (aero/toggle-compilation-buffer)
  (call-interactively #'project-compile)
  (aero/tail-compilation-buffer))

(defun aero/get-compilation-buffer-name ()
  "Return the compilation buffer name for the current project."
  (if (project-current nil)
      (project-prefixed-buffer-name "compilation")
    "*compilation*"))

(defun aero/toggle-compilation-buffer ()
  "Pop-up the compilation buffer."
  (interactive)
  (aero/toggle-popup-buffer (aero/get-compilation-buffer-name))
  (aero/tail-compilation-buffer))

(defun aero/toggle-popup-buffer (buf)
  "Pop-up BUF in a buffer below."
  (let ((win (get-buffer-window buf 0)))
    (if win
        ;; found, so close it
        (aero/bury-buffer-kill-window win)

      ;; else we need to pop it up
      (progn
        (display-buffer buf
                        '((display-buffer-below-selected)
                          (reusable-frames . nil) ;; only search this frame
                          (window-height . 20)))
        (set-window-dedicated-p (get-buffer-window buf) t)))))

(defun aero/incr-compilation-buffer ()
  "Renames existing compilation buffer so you can create more."
  (interactive)
  (let ((cbuf (get-buffer "*compilation*"))
        (more-cbufs t)
        (n 1)
        (new-cbuf-name ""))
    (when cbuf
      (while more-cbufs
        (setq new-cbuf-name (format "*compilation%d*" n))
        (setq n (1+ n))
        (setq more-cbufs (get-buffer new-cbuf-name)))
      (with-current-buffer cbuf
        (rename-buffer new-cbuf-name)))))

(defun aero/eshell-new ()
  "Open a new Eshell window."
  (interactive)
  (eshell t))

(defun aero/project-eshell-new ()
  "Open a new project Eshell."
  (interactive)
  (let ((current-prefix-arg t))
    (project-eshell)))

(defmacro aero/async-shell-command-with-path (command &optional buffer error-buffer)
  "Run COMMAND asynchronously like `async-shell-command' but with PATH loaded."
  `(let ((shell-command-switch "-ic"))
     (async-shell-command ,command ,buffer ,error-buffer)))

  ;; written by github user rompy
  (defun aero/smarter-backward-kill-word ()
    "Deletes the previous word, respecting:
  1. If the cursor is at the beginning of line, delete the '\n'.
  2. If there is only whitespace, delete only to beginning of line.
  3. If there is whitespace, delete whitespace and check 4-5.
  4. If there are other characters instead of words, delete one only char.
  5. If it's a word at point, delete it."
    (interactive)
    (if (bolp)
        (delete-char -1)
      (if (string-match-p
           "^[[:space:]]+$" (buffer-substring-no-properties (line-beginning-position) (point)))
          (delete-horizontal-space)
        (when (thing-at-point 'whitespace)
          (delete-horizontal-space))
        (if (thing-at-point 'word)
            (let ((start (car (bounds-of-thing-at-point 'word)))
                  (end (point)))
              (if (> end start)
                  (delete-region start end)
                (delete-char -1)))
          (delete-char -1)))))

  (defun untabify-buffer ()
    (interactive)
    (untabify (point-min) (point-max)))
  (defun tabify-buffer ()
    (interactive)
    (tabify (point-min) (point-max)))
  (defun indent-buffer ()
    (interactive)
    (indent-region (point-min) (point-max)))

  (defun alter-number-at-point (offset)
    (save-excursion
      (skip-chars-backward "0-9")
      (or (looking-at "[0-9]+") (message "No number at point"))
      (replace-match (number-to-string (+ offset (string-to-number (match-string 0)))))))
  (defun increment-number-at-point ()
    (interactive)
    (alter-number-at-point 1))
  (defun decrement-number-at-point ()
    (interactive)
    (alter-number-at-point -1))

  (defun human-date (human-string &optional epoch)
    "Convert HUMAN-STRING to a date string or if EPOCH, seconds.
  Requires the utility date to be installed."
    (with-temp-buffer
      (let ((dateProc
             (if (system-is-mac)
                 "gdate"
               "date")))
        (if epoch
            (call-process dateProc nil t nil "-d" human-string "+%s")
          (call-process dateProc nil t nil "-d" human-string)))
      (replace-regexp-in-string "\n\\'" "" (buffer-string))))

  (defun day-of-week ()
    "Return the current day of the week."
    (format-time-string "%A"))

  (defun day-after (day-name)
    "Return the name of the day following the day given by \\='day-name\\='."
    (format-time-string "%A" (time-add (date-to-time (concat day-name " 00:00")) (* 24 60 60))))

  (defun aero/frame-recenter (&optional frame)
    "Center FRAME on the screen.

  FRAME can specify a frame name, a terminal name, or a frame.
  If FRAME is omitted or nil, use currently selected frame."
    (interactive)
    (unless (eq 'maximised (frame-parameter nil 'fullscreen))
      (let* ((frame (or (and (boundp 'frame) frame) (selected-frame)))
             (frame-w (frame-pixel-width frame))
             (frame-h (frame-pixel-height frame))
             (display (frame-parameter frame 'display))
             (monitor-w (display-pixel-width display))
             (monitor-h (display-pixel-height display))
             ;; NS doesn't report menu bar as outside monitor
             (monitor-h
              (if (eq window-system 'ns)
                  (- monitor-h 22)
                monitor-h))
             (center (list (/ (- monitor-w frame-w) 2) (/ (- monitor-h frame-h) 2))))
        (apply 'set-frame-position (flatten-list (list frame center))))))

  (defun aero/unix-timestamp-to-human (timestamp)
    "Convert a UNIX TIMESTAMP to a human-readable string."
    (interactive (list (read-string "Timestamp: " (thing-at-point 'word))))
    ;; convert from milliseconds if it looks like milliseconds
    (let ((timestamp (if (>= (string-to-number timestamp) 10000000000)
                         (/ (string-to-number timestamp) 1000)
                       (string-to-number timestamp))))
      (message (format-time-string "%Y-%m-%d %H:%M:%S" (seconds-to-time timestamp)))))

  (defun aero/toggle-angular-component-file ()
    "Toggle between an Angular component's Typescript and HTML files."
    (interactive)
    (let ((current-file buffer-file-name))
      (when current-file
        (let* ((file-ext (file-name-extension current-file))
               (base-name (file-name-sans-extension current-file))
               (toggle-ext (cond ((string-equal file-ext "html") "ts")
                                 ((string-equal file-ext "ts") "html")
                                 (t nil)))
               (prefered-filename
                (concat base-name
                        (when (string-equal toggle-ext "ts")
                          ".component")
                        "." toggle-ext)))
          (if (and prefered-filename (file-exists-p prefered-filename))
              (find-file prefered-filename)
            (let ((alternative-filename (concat base-name "." toggle-ext)))
              (if (and toggle-ext (file-exists-p alternative-filename))
                  (find-file alternative-filename)
                (message "No corresponding file found for %s" current-file))))))))

  (defun aero/org-convert-region-from-markdown (beg end)
    (interactive "r")
    (shell-command-on-region beg end "pandoc -t org" nil t))

  (defun aero/open-emacs-config ()
    "Open an org-agenda file from a list of all agenda files."
    (interactive)
    (find-file (expand-file-name "config.org" user-emacs-directory)))

  (defun aero/eslint-fix-file ()
    "Run eslint --fix on the current buffer's file."
    (interactive)

    (when (buffer-modified-p)
      (if (y-or-n-p (format "Save file %s? " buffer-file-name))
          (save-buffer)
        (user-error "ESLint refusing to run on a modified buffer")))

    (message "Running ESLint fix...")

    (let* ((default-directory (project-root (project-current)))
           (error-buffer (get-buffer-create "*ESLint Fix Errors*"))
           (exit-code (call-process "npx" nil error-buffer nil
                                    "eslint" "--fix" buffer-file-name)))
      (if (zerop exit-code)
          (progn
            (message "ESLint fix complete")
            (revert-buffer t t t))
        (message "ESLint fix failed with error code %d" exit-code)
        (pop-to-buffer error-buffer))))

  (defun aero/prettier-fix-file ()
    "Run prettier --write on the current buffer's file."
    (interactive)
    (when (buffer-modified-p)
      (if (y-or-n-p (format "Save file %s? " buffer-file-name))
          (save-buffer)
        (user-error "Prettier refusing to run on a modified buffer")))
    (message "Running Prettier fix...")
    (let* ((default-directory (project-root (project-current)))
           (error-buffer (get-buffer-create "*Prettier Fix Errors*"))
           (exit-code (call-process "npx" nil error-buffer nil
                                    "prettier" "--write" buffer-file-name)))
      (if (zerop exit-code)
          (progn
            (message "Prettier fix complete")
            (revert-buffer t t t))
        (message "Prettier fix failed with error code %d" exit-code)
        (pop-to-buffer error-buffer))))

  (defun aero/make-home ()
    "Run make in home directory.

I use this to run a manual sync on a handful of git repositories,
including this config."
    (interactive)
    (let ((default-directory (expand-file-name "~/")))
      (compile "make")))

  (defun aero/docker-restart ()
    "Run \\='make docker-restart\\=' in the home directory.

Runs the \\='docker-restart\\=' target from the same Makefile as
`aero/make-home'."
    (interactive)
    (let ((default-directory (expand-file-name "~/")))
      (compile "make docker-restart")))

  (defun aero/tickets ()
    "Run \\='make tickets\\=' in the thornlog directory."
    (interactive)
    (let ((default-directory aero/thornlog-path))
      (compile "make tickets")))

(with-eval-after-load 'gnutls
  (eval-when-compile (require 'gnutls))
  (setq gnutls-verify-error t)) ; Do not allow insecure TLS connections.

;; Use the more-cutting-edge develop branch of straight
(eval-when-compile
  (defvar straight-repository-branch)
  (defvar straight-check-for-modifications))
(setq straight-repository-branch "develop")

(setq straight-check-for-modifications nil)

(defvar straight-recipe-repositories)
(defvar straight-recipes-gnu-elpa-use-mirror)
(defvar straight-built-in-pseudo-packages)

(setq straight-recipe-repositories
      '(org-elpa gnu-elpa-mirror
        (nongnu-elpa :type git :host github
                     :repo "emacsmirror/nongnu_elpa"
                     :branch "main")
        emacsmirror-mirror melpa))
(setq straight-recipes-gnu-elpa-use-mirror t)

(with-eval-after-load 'straight
  (add-to-list 'straight-built-in-pseudo-packages 'let-alist))

(defvar bootstrap-version)
(let ((bootstrap-file
       (expand-file-name "straight/repos/straight.el/bootstrap.el" user-emacs-directory))
      (bootstrap-version 5))
  (unless (file-exists-p bootstrap-file)
    (with-current-buffer
        (url-retrieve-synchronously
         "https://raw.githubusercontent.com/radian-software/straight.el/develop/install.el"
         'silent 'inhibit-cookies)
      (goto-char (point-max))
      (eval-print-last-sexp)))
  (load bootstrap-file nil 'nomessage))

(require 'use-package)

(eval-when-compile
  (defvar use-package-expand-minimally)
  (defvar use-package-compute-statistics)
  (defvar use-package-minimum-reported-time)
  (defvar use-package-verbose)
  (defvar package-native-compile))
(setq use-package-expand-minimally byte-compile-current-file
      use-package-compute-statistics nil ; t then `use-package-report' to find packages not used
      package-native-compile t ; compile when installing (not sure if this works)
      use-package-minimum-reported-time 0.1)

(setq use-package-verbose init-file-debug)

  (defmacro package! (package recipe &rest body)
    "Get PACKAGE using RECIPE, then evaluate PACKAGE & BODY with `use-package\\='.

Example:

    (package! foo (:host gitlab :repo \"thornjad/foo\" :branch \"main\")
       :commands (foo-bar foo-spam))

  If the RECIPE is :builtin or :local, do not search [M]ELPA, only pass BODY to `use-package'. While
  there is no functional difference between these two keywords, :builtin should be used for packages
  within Emacs while :local should be used for user packages which exist locally. :local packages may
  require a :load-path for `use-package' to load properly.

  If the BODY contains the keyword :disabled, the package is completely ignored, with an expansion
  indicating the package has been disabled.

  If the recipe does not contain a :host, it default to 'github.

  If the recipe is only a string, it is considered a github repo.

  Usage of this macro allows simplified refactoring when changing packaging systems, as Aero is wont
  to do every few years."
    (declare (indent defun)) ; indent like use-package

    (when (stringp recipe)
      (setq recipe (list :repo recipe)))

    (cond
     ((memq :disabled body)
      (format "%s :disabled by Aero package!" package))

     ((equal recipe :builtin)
      `(use-package ,package :straight (:type built-in) ,@body))

     ((equal recipe :local)
      `(use-package ,package :straight nil ,@body))

     ((equal recipe :localpackage)
      `(use-package ,package :straight nil :load-path "lib/localpackages" ,@body))

     ;; Use straight
     (t
      (progn
        (when (and (not (equal recipe :auto))
                   (and (not (memq :host recipe))
                        (not (memq :source recipe))))
          (setq recipe (plist-put recipe :host 'github)))

        `(use-package ,package :straight ,(or (equal recipe :auto) recipe) ,@body)))))

(and (and (treesitterp)
          (functionp 'module-load)
          (bound-and-true-p module-file-suffix))
     (require 'treesit nil t))

(package! compile-angel "jamescherti/compile-angel.el"
  :demand t
  :hook (emacs-lisp-mode-hook . compile-angel-on-save-local-mode)

  :custom
  (compile-angel-verbose t)
  (compile-angel-enable-byte-compile nil) ; only native compile

  :config
  ;; Exclude these files
  (with-eval-after-load "savehist" (push (concat "/" (file-name-nondirectory savehist-file))
                                         compile-angel-excluded-files))
  (with-eval-after-load "recentf" (push (concat "/" (file-name-nondirectory recentf-save-file))
                                        compile-angel-excluded-files))
  (with-eval-after-load "cus-edit" (push (concat "/" (file-name-nondirectory custom-file))
                                         compile-angel-excluded-files))

  (compile-angel-on-load-mode))

(package! gnu-elpa-keyring-update :auto)

(package! dash :auto)
(package! async :auto :commands (async-save)) ; required by org-download
(package! spinner :auto) ; required by cider

(package! jsonrpc :builtin
  :config
  ;; Don't waste time logging events
  (fset #'jsonrpc--log-event #'ignore))

(package! exec-path-from-shell :auto
  :when (or (memq window-system '(mac ns x)) (daemonp))
  :config
  (dolist (var '("PATH" "SSH_AUTH_SOCK" "SSH_AGENT_PID" "GPG_AGENT_INFO"
                 "LANG" "LC_CTYPE" "NIX_SSL_CERT_FILE" "NIX_PATH"
                 "MANPATH" "INFOPATH" "HOMEBREW_PREFIX"
                 "HOMEBREW_CELLAR" "HOMEBREW_REPOSITORY"))
    (add-to-list 'exec-path-from-shell-variables var))
  (exec-path-from-shell-initialize))

(package! evil :auto
  :init
  (setq evil-want-keybinding nil
        evil-undo-system 'undo-tree
        evil-want-fine-undo t
        evil-want-C-i-jump nil
        evil-want-C-u-scroll t
        evil-search-module 'isearch)

  :config
  ;; Free up some non-useful bindings for other uses.
  (define-key evil-motion-state-map " " nil)
  (define-key evil-motion-state-map (kbd "RET") nil)
  (define-key evil-motion-state-map (kbd "C-o") nil)

  ;; Set up default states. It's Normal for almost everything, but Evil doesn't handle Dired very
  ;; well, so we fall back on Emacs mode for that.
  (setq evil-default-state 'normal)
  (evil-set-initial-state 'dired-mode 'emacs)
  (evil-set-initial-state 'message-mode 'motion)

  ;; Make movement keys work visually, just like other kinds of movement, by remapping.
  (define-key evil-normal-state-map (kbd "<remap> <evil-next-line>")
    'evil-next-visual-line)
  (define-key evil-normal-state-map (kbd "<remap> <evil-previous-line>")
    'evil-previous-visual-line)
  (define-key evil-motion-state-map (kbd "<remap> <evil-next-line>")
    'evil-next-visual-line)
  (define-key evil-motion-state-map (kbd "<remap> <evil-previous-line>")
    'evil-previous-visual-line)

  (setq-default evil-cross-lines nil)
  (define-key evil-visual-state-map (kbd "u") 'undo)

  ;; Use C-f to switch frames, have to override a scrolling function
  (evil-define-key nil global-map (kbd "C-f") #'other-frame)
  (evil-define-key '(normal visual motion) global-map (kbd "C-f") #'other-frame)
  (evil-define-key '(normal visual motion) magit-mode-map (kbd "C-f") #'other-frame)

  ;; Define =vig= and =vag= to look for all paren types
  (defun aero/evil-paren-range (count beg end type inclusive)
    "Get minimum range of paren text object.
    COUNT, BEG, END, TYPE is used.  If INCLUSIVE is t, the text object is inclusive."
    (let* ((parens '("()" "[]" "{}" "<>"))
           range
           found-range)
      (dolist (p parens)
        (condition-case nil
            (setq range (evil-select-paren (aref p 0) (aref p 1) beg end type count inclusive))
          (error nil))
        (when range
          (cond
           (found-range
            (when (< (- (nth 1 range) (nth 0 range))
                     (- (nth 1 found-range) (nth 0 found-range)))
              (setf (nth 0 found-range) (nth 0 range))
              (setf (nth 1 found-range) (nth 1 range))))
           (t
            (setq found-range range)))))
      found-range))
  (evil-define-text-object aero/evil-a-paren (count &optional beg end type)
    "Select a paren."
    :extend-selection t
    (aero/evil-paren-range count beg end type t))
  (evil-define-text-object aero/evil-inner-paren (count &optional beg end type)
    "Select 'inner' paren."
    :extend-selection nil
    (aero/evil-paren-range count beg end type nil))
  (define-key evil-inner-text-objects-map "g" #'aero/evil-inner-paren)
  (define-key evil-outer-text-objects-map "g" #'aero/evil-a-paren)

  (defun aero/evil-shift-right ()
    (interactive)
    (evil-shift-right evil-visual-beginning evil-visual-end)
    (evil-normal-state)
    (evil-visual-restore))
  (defun aero/evil-shift-left ()
    (interactive)
    (evil-shift-left evil-visual-beginning evil-visual-end)
    (evil-normal-state)
    (evil-visual-restore))
  (evil-define-key 'visual global-map (kbd ">") 'aero/evil-shift-right)
  (evil-define-key 'visual global-map (kbd "<") 'aero/evil-shift-left)

  ;; Make =:q= kill the buffer instead of Emacs itself
  (evil-ex-define-cmd "q" 'kill-current-buffer)

  ;; AFAIK there's no "backward" equivalent to "e", so we set it to backward word
  (evil-define-key '(normal visual motion) global-map
    (kbd "C-e") #'evil-backward-word-end)
  (evil-define-key '(normal visual motion) global-map
    (kbd "C-M-e") #'evil-backward-WORD-end)

  ;; Useful for pasting into the minibuffer, since Evil doesn't properly function there
  (evil-define-key '(insert) global-map (kbd "C-y") #'evil-paste-after)
  (evil-define-key '(insert) global-map (kbd "C-S-y") #'evil-paste-before)

  (evil-mode +1))

(when (treesitterp)
  (setq major-mode-remap-alist
        '((python-mode . python-ts-mode)
          (typescript-mode . typescript-ts-mode)
          (js-mode . js-ts-mode))))

    (setq tab-bar-tab-hints t)
    (setq tab-bar-separator "  ")

    (defun aero/tab-bar-tab-name-function ()
      "Tab name function that shows org-roam node titles instead of buffer names.
Truncates long names to keep tab bar manageable."
      (let* ((buf (window-buffer (minibuffer-selected-window)))
             (name (with-current-buffer buf
                     (if (and (derived-mode-p 'org-mode)
                              (buffer-file-name)
                              (org-roam-file-p))
                         (or (ignore-errors
                               (caar (org-roam-db-query
                                      [:select [title]
                                       :from nodes
                                       :where (= file $s1)]
                                      (buffer-file-name))))
                             (buffer-name))
                       (buffer-name))))
             (max-length 60))
        (if (> (length name) max-length)
            (concat (substring name 0 (- max-length 3)) "...")
          name)))

    (setq tab-bar-tab-name-function #'aero/tab-bar-tab-name-function)

    (global-set-key (kbd "s-1") (lambda () (interactive) (tab-bar-select-tab 1)))
    (global-set-key (kbd "s-2") (lambda () (interactive) (tab-bar-select-tab 2)))
    (global-set-key (kbd "s-3") (lambda () (interactive) (tab-bar-select-tab 3)))
    (global-set-key (kbd "s-4") (lambda () (interactive) (tab-bar-select-tab 4)))
    (global-set-key (kbd "s-5") (lambda () (interactive) (tab-bar-select-tab 5)))
    (global-set-key (kbd "s-6") (lambda () (interactive) (tab-bar-select-tab 6)))
    (global-set-key (kbd "s-7") (lambda () (interactive) (tab-bar-select-tab 7)))
    (global-set-key (kbd "s-8") (lambda () (interactive) (tab-bar-select-tab 8)))
    (global-set-key (kbd "s-9") (lambda () (interactive) (tab-bar-select-tab 9)))

(package! winum "deb0ch/emacs-winum"
  :defer 5
  :after (general which-key)
  :init
  (winum-mode)
  :config
  (aero-leader-def
    "1" '(winum-select-window-1 :wk "window-1")
    "2" '(winum-select-window-2 :wk "window-2")
    "3" '(winum-select-window-3 :wk "window-3")
    "4" '(winum-select-window-4 :wk "window-4")
    "5" '(winum-select-window-5 :wk "window-5")
    "6" '(winum-select-window-6 :wk "window-6")
    "7" '(winum-select-window-7 :wk "window-7")
    "8" '(winum-select-window-8 :wk "window-8")
    "9" '(winum-select-window-9 :wk "window-9")))

(package! company
  (:repo "company-mode/company-mode"
   :files (:defaults "icons" ("images/small" "doc/images/small/*.png")))
  :after (evil)
  :hook ((prog-mode . company-mode)
         (company-mode-hook . evil-normalize-keymaps))
  :init
  (setq company-idle-delay 0.2
        company-selection-wrap-around t
        company-minimum-prefix-length 2
        company-dabbrev-downcase nil
        company-tooltip-limit 15
        company-tooltip-margin 2
        company-require-match nil
        company-show-numbers t
        company-tooltip-align-annotations t
        company-dabbrev-other-buffers t ; only look in open buffers with same major mode
        company-global-modes '(not
                               erc-mode message-mode help-mode gud-mode vterm-mode))
  :config
  ;; Wait until it's defined, then disable preview after point
  (setq company-frontends (delq 'company-preview-if-just-one-frontend company-frontends)))

(package! tramp :builtin
  :defer t
  :functions tramp-cleanup-all-connection
  :custom
  (tramp-auto-save-directory
   (expand-file-name "tramp/autosave" aero-cache-dir))
  (tramp-persistency-file-name
   (expand-file-name "tramp/persistency" aero-cache-dir))
  (tramp-use-ssh-controlmaster-options nil)  ; use system settings instead
  (tramp-default-method "rsync")
  (tramp-terminal-type "tramp"))

(package! dired :builtin
  :hook ((dired-mode . hl-line-mode)
         (dired-mode . dired-async-mode))
  :bind (:map dired-mode-map
         ("M-n" . #'dired-next-dirline)
         ("M-p" . #'dired-prev-dirline)
         ("TAB" . #'dired-next-subdir)))

(when (system-is-mac)
  (defvar aero/pbcopier-program (executable-find "pbcopy")
    "Name of Pbcopy program tool.")
  (defvar aero/pbcopier-last-selected-text-clipboard nil
    "The value of the CLIPBOARD X selection from pbcopy.")
  (defvar aero/pbcopier-last-selected-text-primary nil
    "The value of the PRIMARY X selection from pbcopy.")

  (defun aero/pbcopier-set-selection (type data)
    "TYPE is a symbol: primary, secondary and clipboard.
See `x-set-selection'."
    (when aero/pbcopier-program
      (let* ((process-connection-type nil)
             (proc (start-process "pbcopy" nil "pbcopy"
                                  "-selection" (symbol-name type))))
        (process-send-string proc data)
        (process-send-eof proc))))

  (defun aero/pbcopier-select-text (text)
    "See `x-select-text'."
    (aero/pbcopier-set-selection 'primary text)
    (setq aero/pbcopier-last-selected-text-primary text)
    (aero/pbcopier-set-selection 'clipboard text)
    (setq aero/pbcopier-last-selected-text-clipboard text))

  (defun aero/pbcopier-selection-value ()
    "See `x-cut-buffer-or-selection-value'."
    (when aero/pbcopier-program
      (let (clip-text primary-text)
        (let ((tramp-mode nil)
              (default-directory "~"))
          (setq clip-text (shell-command-to-string "pbpaste")))
        (setq clip-text
              (cond ;; check clipboard selection
               ((or (not clip-text) (string= clip-text ""))
                (setq aero/pbcopier-last-selected-text-primary nil))
               ((eq      clip-text aero/pbcopier-last-selected-text-clipboard) nil)
               ((string= clip-text aero/pbcopier-last-selected-text-clipboard)
                ;; Record the newer string,
                ;; so subsequent calls can use the `eq' test.
                (setq aero/pbcopier-last-selected-text-clipboard clip-text)
                nil)
               (t (setq aero/pbcopier-last-selected-text-clipboard clip-text))))
        (let ((tramp-mode nil)
              (default-directory "~"))
          (setq primary-text (shell-command-to-string "pbpaste")))
        (setq primary-text
              (cond ;; check primary selection
               ((or (not primary-text) (string= primary-text ""))
                (setq aero/pbcopier-last-selected-text-primary nil))
               ((eq      primary-text aero/pbcopier-last-selected-text-primary) nil)
               ((string= primary-text aero/pbcopier-last-selected-text-primary)
                ;; Record the newer string,
                ;; so subsequent calls can use the `eq' test.
                (setq aero/pbcopier-last-selected-text-primary primary-text)
                nil)
               (t (setq aero/pbcopier-last-selected-text-primary primary-text))))
        (or clip-text primary-text))))

  (declare-function aero/pbcopier-select-text "aero-pbcopier.el")
  (declare-function aero/pbcopier-selection-value "aero-pbcopier.el")
  (setq interprogram-cut-function #'aero/pbcopier-select-text)
  (setq interprogram-paste-function #'aero/pbcopier-selection-value)

  (setq-default ns-use-native-fullscreen nil)
  (if (executable-find "gls")
      (progn
        (setq insert-directory-program "gls")
        (setq dired-listing-switches "-lFaGh1v --group-directories-first"))
    (setq dired-listing-switches "-ahlF")))

(defvar x-gtk-use-system-tooltips)

(when (system-is-linux)
  (setq select-enable-clipboard t
        interprogram-paste-function #'gui-selection-value
        x-gtk-use-system-tooltips t
        dired-listing-switches "-lFaGh1v --group-directories-first"))

(setq pop-up-frames nil)

(package! ace-window :auto
  :after (general)
  :commands (ace-window)
  :init
  (aero-leader-def
    "wW" 'ace-window))

(defmacro aero/configure-side-window (&rest args)
  (let ((regex (plist-get args :regex))
        (side (plist-get args :side))
        (height (plist-get args :height)))
    `(add-to-list 'display-buffer-alist
                  '(,regex
                    (display-buffer-reuse-window display-buffer-in-side-window)
                    (side . ,side)
                    (window-height . ,height)
                    (window-parameters . ((no-other-window . nil)))))))

(aero/configure-side-window
 :regex "e?shell\\*\\(?:<[[:digit:]]+>\\)?\\'"
 :side bottom
 :height 23)

(aero/configure-side-window
 :regex "\\*vterminal.*"
 :side bottom
 :height 23)

(aero/configure-side-window
 :regex "\\*Flymake diagnostics for.*"
 :side bottom
 :height 20)

  (setq vc-handled-backends nil)

  (defgroup aero/modeline nil
    "A minimal mode-line with useful information."
    :group 'mode-line)

  (defvar aero/modeline--bar-active nil)
  (defvar aero/modeline-bar--inactive nil)

  (defvar aero/modeline-height 30)
  (defvar aero/modeline-bar-width 5)

  (defvar aero/modeline--default-mode-line mode-line-format
    "Store the default mode-line format so it's not lost.")

  (defvar-local aero/modeline-hide--old-format nil
    "Storage for the old `mode-line-format', so it can be restored when
  `aero/modeline-hide-mode' is disabled.")

  ;; Ensure major-mode or theme changes can't overwrite this
  (put 'aero/modeline-hide--old-format 'permanent-local t)

  (defface aero/modeline-status-grayed-out '((t (:inherit (font-lock-doc-face) :slant italic)))
    "Face used for neutral or inactive status indicators in the mode-line."
    :group 'aero/modeline)

  (defface aero/modeline-status-info '((t (:inherit (font-lock-keyword-face) :slant italic)))
    "Face used for generic status indicators in the mode-line."
    :group 'aero/modeline)

  (defface aero/modeline-status-success '((t (:inherit (success) :slant italic)))
    "Face used for success status indicators in the mode-line."
    :group 'aero/modeline)

  (defface aero/modeline-status-warning '((t (:inherit (warning) :slant italic)))
    "Face for warning status indicators in the mode-line."
    :group 'aero/modeline)

  (defface aero/modeline-status-error '((t (:inherit (error) :slant italic)))
    "Face for error stauts indicators in the mode-line."
    :group 'aero/modeline)

  (defface aero/modeline-unimportant '((t (:inherit (font-lock-doc-face))))
    "Face used for less important mode-line elements."
    :group 'aero/modeline)

  (defface aero/modeline-modified '((t (:inherit (error))))
    "Face used for the \\='modified\\=' indicator symbol in the mode-line."
    :group 'aero/modeline)

  (defface aero/modeline-not-modified '((t (:inherit (success))))
    "Face used for the \\='not modified\\=' indicator symbol in the mode-line."
    :group 'aero/modeline)

  (defface aero/modeline-read-only '((t (:inherit (warning))))
    "Face used for the \\='buffer read-only\\=' indicator symbol in the mode-line."
    :group 'aero/modeline)

  (defface aero/modeline-remote '((t (:inherit (font-lock-keyword-face :weight bold))))
    "Face used for the \\='remote\\=' indicator symbol in the mode-line."
    :group 'aero/modeline)

  (defface aero/modeline-evil-normal '((t (:inherit (font-lock-keyword-face))))
    "Face used for Normal Evil state message."
    :group 'aero/modeline)
  (defface aero/modeline-evil-insert '((t (:inherit (font-lock-keyword-face))))
    "Face used for Insert Evil state message."
    :group 'aero/modeline)
  (defface aero/modeline-evil-visual '((t (:inherit (font-lock-keyword-face))))
    "Face used for Visual Evil state message."
    :group 'aero/modeline)
  (defface aero/modeline-evil-operator '((t (:inherit (font-lock-keyword-face))))
    "Face used for Visual Evil state message."
    :group 'aero/modeline)
  (defface aero/modeline-evil-motion '((t (:inherit (font-lock-keyword-face))))
    "Face used for Visual Evil state message."
    :group 'aero/modeline)
  (defface aero/modeline-evil-replace '((t (:inherit (font-lock-keyword-face))))
    "Face used for Replace Evil state message."
    :group 'aero/modeline)
  (defface aero/modeline-evil-emacs '((t (:inherit (font-lock-keyword-face))))
    "Face used for Emacs Evil state message."
    :group 'aero/modeline)

  (defface aero/modeline-major-mode-active '((t (:inherit mode-line-buffer-id)))
    "Face used for major mode."
    :group 'aero/modeline)

  (defface aero/modeline-git-branch '((t (:slant italic :bold t)))
    "Used for Git branch name."
    :group 'aero/modeline)

  (defface aero/modeline-bar '((t (:background unspecified)))
    "Style of the bar on the modeline."
    :group 'aero/modeline)
  (defface aero/modeline-bar-inactive '((t (:background unspecified)))
    "Style of the bar on the inactive modeline."
    :group 'aero/modeline)

  ;; TODO could this be memoized?
  (defun aero-info-line-format (left right)
    "Return a string of `window-width' length containing LEFT and RIGHT, aligned
  respectively."
    (let ((reserve (length right)))
      (concat left " " (propertize
                        " " 'display
                        `((space :align-to
                            (- (+ right right-fringe right-margin)
                               ,(+ reserve (if (display-graphic-p) 1 2))))))
              right)))

  (defvar aero/modeline--active-window nil)
  (defun aero/modeline--get-active-window (&optional frame)
    "Get the current window, but exclude child windows."
    (if (and (fboundp 'frame-parent) (frame-parent frame))
        (frame-selected-window (frame-parent frame))
      (frame-selected-window frame)))
  (defun aero/modeline--set-selected-window (&rest _)
    "Set `aero/modeline--active-window' to the correct window."
    (let ((win (aero/modeline--get-active-window)))
      (setq aero/modeline--active-window
            (if (minibuffer-window-active-p win)
                (minibuffer-selected-window)
              win))))
  (add-hook 'pre-redisplay-functions #'aero/modeline--set-selected-window)
  (defun aero/modeline--active-p ()
    "Return whether mode-line is active."
    (and aero/modeline--active-window
         (eq (aero/modeline--get-active-window) aero/modeline--active-window)))

  ;;; Segments

  (defun aero/modeline--evil-pill (letter face)
    "Render LETTER as an SVG pill image using colors from FACE.
Includes left padding to match the gap on the right side of the modeline."
    (let* ((bg (face-background face nil t))
           (fg (face-foreground face nil t))
           (height aero/modeline-height)
           (pill-width 20)
           (pad 5)
           (total-width (+ pad pill-width))
           (svg (format "<svg xmlns='http://www.w3.org/2000/svg' width='%d' height='%d'>
  <rect x='%d' width='%d' height='%d' rx='3' fill='%s'/>
  <text x='%d' y='%d' fill='%s' font-family='monospace' font-size='%d' font-weight='bold' text-anchor='middle' dominant-baseline='central'>%s</text>
</svg>" total-width height pad pill-width height bg (+ pad (/ pill-width 2)) (/ height 2) fg (- height 16) letter)))
      (propertize " " 'display
                  (create-image svg 'svg t :ascent 'center))))

  (defun aero/modeline-segment-evil-state ()
    "Display current evil state as an SVG pill. Requires function `evil-mode'."
    (when (require 'evil nil 'noerror)
      (declare-function evil-state-property "evil")
      (defvar evil-state)
      (let ((state (evil-state-property evil-state :tag t)))
        (cond
         ((functionp state) (aero/modeline--evil-pill "V" 'aero/modeline-evil-visual))
         ((string= state " <N> ") (aero/modeline--evil-pill "N" 'aero/modeline-evil-normal))
         ((string= state " <I> ") (aero/modeline--evil-pill "I" 'aero/modeline-evil-insert))
         ((string= state " <R> ") (aero/modeline--evil-pill "R" 'aero/modeline-evil-replace))
         ((string= state " <O> ") (aero/modeline--evil-pill "O" 'aero/modeline-evil-operator))
         ((string= state " <M> ") (aero/modeline--evil-pill "M" 'aero/modeline-evil-motion))
         ((string= state " <E> ") (aero/modeline--evil-pill "E" 'aero/modeline-evil-emacs))
         (t state)))))

  (defun aero/modeline-segment-modified ()
    "Displays a color-coded buffer modification indicator in the mode-line."
    (cond
     ((and buffer-read-only (buffer-file-name))  ;; read-only
      (propertize "■" 'face `(:inherit aero/modeline-read-only :height 0.6)))
     ((string-match-p "\\*.*\\*" (buffer-name))  ;; special buffer
      (propertize "▼" 'face `(:inherit aero/modeline-read-only :height 0.6)))
     ((buffer-modified-p)  ;; modified
      (propertize "●" 'face `(:inherit aero/modeline-modified :height 0.65)))
     (t  ;; not modified
      (propertize "✔" 'face `(:inherit aero/modeline-not-modified :height 0.6)))))

  (defvar-local aero/modeline--git-branch nil
    "Cached git branch name for the current buffer.")

  (defun aero/modeline--update-git-branch ()
    "Update the cached git branch for the current buffer."
    (setq aero/modeline--git-branch
          (when buffer-file-name
            (let ((default-directory (file-name-directory buffer-file-name)))
              (ignore-errors
                (string-trim
                 (shell-command-to-string
                  "git rev-parse --abbrev-ref HEAD 2>/dev/null")))))))

  (add-hook 'find-file-hook #'aero/modeline--update-git-branch)
  (add-hook 'after-save-hook #'aero/modeline--update-git-branch)
  (add-hook 'focus-in-hook
            (lambda ()
              (when buffer-file-name
                (aero/modeline--update-git-branch))))

  (defun aero/modeline-segment-git-state ()
    "Displays the current branch from Git using a cached lookup."
    (when (and aero/modeline--git-branch
               (not (string-empty-p aero/modeline--git-branch)))
      (concat
       (propertize
        (let ((max 12))
          (if (> (length aero/modeline--git-branch) max)
              (concat (substring aero/modeline--git-branch 0 (- max 3)) "…")
            aero/modeline--git-branch))
        'mouse-face 'mode-line-highlight
        'face 'aero/modeline-git-branch)
       " ")))

  (defun aero/modeline-segment-remote ()
    "Displays a symbol if buffer is remote"
    (when-let* ((filename (buffer-file-name))
                (host (file-remote-p filename 'host)))
      (concat " @" (propertize host 'face 'aero/modeline-remote) " ")))

  (defvar-local aero/modeline--buffer-display-name nil
    "Cached display name for the current buffer's modeline segment.")

  (defun aero/modeline--update-buffer-display-name ()
    "Update the cached display name, querying org-roam for node titles."
    (setq aero/modeline--buffer-display-name
          (if (and (derived-mode-p 'org-mode)
                   (buffer-file-name)
                   (fboundp 'org-roam-file-p)
                   (org-roam-file-p))
              (or (ignore-errors
                    (caar (org-roam-db-query
                           [:select [title]
                            :from nodes
                            :where (= file $s1)]
                           (buffer-file-name))))
                  (buffer-name))
            (buffer-name))))

  (add-hook 'find-file-hook #'aero/modeline--update-buffer-display-name)
  (add-hook 'after-save-hook #'aero/modeline--update-buffer-display-name)

  (defun aero/modeline-segment-buffer-name ()
    "Displays the name and size of the current buffer in the mode-line.
For org-roam nodes, displays the node title instead of the filename.
Truncates long names to ensure other modeline segments remain visible."
    (let* ((name (or aero/modeline--buffer-display-name (buffer-name)))
           ;; reserve space for other segments
           (reserved-space 70)
           (available-width (- (window-width) reserved-space))
           (max-name-length (max 50 available-width))
           (truncated-name (if (> (length name) max-name-length)
                               (concat (substring name 0 (- max-name-length 3)) "...")
                             name)))
      (concat
       (propertize truncated-name 'face 'mode-line-buffer-id)
       " ")))

  (defun aero/modeline-segment-size-and-position ()
    "Displays the current cursor position in the mode-line."
    (concat "(%I) %l:%C %o%%"
            (when (use-region-p)
              (concat
               "  (" (number-to-string (count-lines (point) (mark)))
               ":" (number-to-string (abs (- (point) (mark))))
               ")"))
            "  "))

  (defun aero/modeline-segment-process ()
    "Displays the current value of `mode-line-process' in the mode-line."
    (when mode-line-process
      (list mode-line-process "  ")))

  (declare-function flymake--mode-line-counter "flymake")
  (defun aero/modeline-segment-flymake ()
    "Displays information about current flymake status."
    (when (bound-and-true-p flymake-mode)
      (list (flymake--mode-line-counter :error) " ")))

  (defun aero/modeline-segment-lsp ()
    "Displays information about LSP status."
    (cond
     ((bound-and-true-p lsp-mode)
      (list (propertize ""
                        'help-echo
                        (string-join
                         (mapcar (lambda (w)
                                   (format "[%s]\n" (lsp--workspace-print w)))
                                 (lsp-workspaces))))
            "  "))

     ((and (fboundp 'eglot-managed-p) (eglot-managed-p))
      (list "" "  "))))

  (defun aero/modeline-segment-major-mode ()
    "Displays the current major mode in the mode-line."
    (format " %s " (format-mode-line mode-name)))

  (defun aero/modeline-create-bar-image (face width height)
    "Create the bar image.
  Use FACE1 for the bar, FACE2 for the background.
  WIDTH and HEIGHT are the image size in pixels."
    (when (and (display-graphic-p)
               (image-type-available-p 'pbm))
      (propertize
       " " 'display
       (let ((color (or (face-background face nil t) "None")))
         (ignore-errors
           (create-image
            (concat (format "P1\n%i %i\n" width height)
                    (make-string (* width height) ?1)
                    "\n")
            'pbm t :foreground color :ascent 'center))))))

  (defun aero/modeline-segment-bar ()
    "The bar, also determines modeline height (in GUI)."
    (let ((width aero/modeline-bar-width)
          (height aero/modeline-height))
      (if (aero/modeline--active-p)
          (aero/modeline-create-bar-image 'aero/modeline-bar width height)
        (aero/modeline-create-bar-image 'aero/modeline-bar-inactive width height))))

  
  ;; Activation function

  ;;;###autoload
  (define-minor-mode aero/modeline-mode
    "Toggle aero/modeline on or off."
    :group 'aero/modeline
    :global t
    :lighter nil
    (progn
      ;; Set the new mode-line-format
      (setq-default mode-line-format
                    '((:eval
                       (aero-info-line-format
                        ;; Left
                        (format-mode-line
                         '((:eval (aero/modeline-segment-evil-state))
                           " " (:eval (aero/modeline-segment-modified)) " "
                           (:eval (aero/modeline-segment-buffer-name))
                           (:eval (aero/modeline-segment-size-and-position))))

                        ;; Right
                        (format-mode-line
                         '((:eval (aero/modeline-segment-process))
                           (:eval (aero/modeline-segment-lsp))
                           (:eval (aero/modeline-segment-flymake))
                           (:eval (aero/modeline-segment-git-state))
                           (:eval (aero/modeline-segment-remote))
                           (:eval (aero/modeline-segment-major-mode))
                           (:eval (aero/modeline-segment-bar))))))))))

  (define-globalized-minor-mode aero/modeline-global-mode aero/modeline-mode
    (lambda () (aero/modeline-mode 1)))

  (define-minor-mode aero/modeline-hide-mode
    "Minor mode to hide the mode-line in the current buffer."
    :init-value nil
    :global nil
    (if aero/modeline-hide-mode
        (progn
          (add-hook 'after-change-major-mode-hook #'aero/modeline-hide-mode nil t)
          (unless aero/modeline-hide--old-format
            (setq aero/modeline-hide--old-format mode-line-format))
          (setq mode-line-format nil))
      (remove-hook 'after-change-major-mode-hook #'aero/modeline-hide-mode t)
      (setq mode-line-format aero/modeline-hide--old-format
            aero/modeline-hide--old-format nil))
    (when (called-interactively-p 'any)
      (redraw-display)))

(aero/modeline-global-mode +1)
(add-hook 'eshell-mode-hook 'aero/modeline-hide-mode)

  (package! aero-theme :local :load-path "lib/aero-theme"
    :init
    (when (system-is-mac)
      (setq aero-theme-font-height 140))
    :config
    (setq aero-theme-font "JetBrains Mono")
    (load-theme 'aero t))

  (defun aero/reload-current-theme ()
    "Force-reload the current custom theme from disk.
Clears the theme from the registry so Emacs re-reads the file
instead of using cached settings."
    (interactive)
    (let* ((theme (car custom-enabled-themes))
           (theme-file (locate-file (concat (symbol-name theme) "-theme.el")
                                    custom-theme-load-path
                                    '("" ".el"))))
      (when theme
        (disable-theme theme)
        (put theme 'theme-settings nil)
        (put theme 'theme-feature nil)
        (setq custom-known-themes (delq theme custom-known-themes))
        (when theme-file
          (load-file theme-file))
        (load-theme theme t))))

(package! tao-theme "11111000000/tao-theme-emacs")
(package! lambda-themes "Lambda-Emacs/lambda-themes")

(setq default-frame-alist
      (append (list
               ;; '(width  . 212) '(height . 62)
               '(tool-bar-lines . 0)
               '(menu-bar-lines . 0)
               '(internal-border-width . 8)
               '(left-fringe . 8) '(right-fringe . 8)
               '(vertical-scroll-bars . nil)
               '(ns-transparent-titlebar . t))))
;; (split-window-horizontally)
(if (fboundp 'fringe-mode) (fringe-mode '8))
(set-frame-parameter (selected-frame) 'internal-border-width 8)
(when (fboundp 'pixel-scroll-precision-mode)
  (pixel-scroll-precision-mode +1))

(setq window-divider-default-right-width 1
      window-divider-default-bottom-width 1
      window-divider-default-places 'right-only
      window-divider-mode t)

(add-hook 'window-state-change-hook
          (lambda ()
            (set-window-margins
             (car (get-buffer-window-list (current-buffer) nil t)) 1 1)))

(add-hook 'before-make-frame-hook 'window-divider-mode)

  (defun aero/--highlight-tab-bar (frame)
    "Apply accent tab bar to FRAME."
    (set-face-attribute 'tab-bar frame
                        :inherit nil
                        :background "#d2cfd2"
                        :foreground "#655370")
    (set-face-attribute 'tab-bar-tab frame
                        :inherit nil
                        :background "#c0b8c5"
                        :foreground "#3a3730"
                        :overline "#8b7f96"
                        :weight 'bold)
    (set-face-attribute 'tab-bar-tab-inactive frame
                        :inherit nil
                        :background "#d2cfd2"
                        :foreground "#655370"
                        :weight 'normal
                        :slant 'italic))

  (defun aero/--unhighlight-tab-bar (frame)
    "Restore muted tab bar on FRAME with consistent sizing."
    (set-face-attribute 'tab-bar frame
                        :inherit nil
                        :background "#ece9e0"
                        :foreground "#a094a2"
                        :overline 'unspecified
                        :weight 'normal)
    (set-face-attribute 'tab-bar-tab frame
                        :inherit nil
                        :background "#ece9e0"
                        :foreground "#655370"
                        :overline "#ece9e0"
                        :weight 'normal)
    (set-face-attribute 'tab-bar-tab-inactive frame
                        :inherit nil
                        :background "#ece9e0"
                        :foreground "#a094a2"
                        :weight 'normal
                        :slant 'italic))

  (defvar aero/--last-focused-frame nil
    "Track the previously focused frame to detect frame switches.")

  (defun aero/--update-tab-bar-highlight ()
    "Highlight tab bar on active frame when multiple frames exist.
Skips update entirely when Emacs has no OS focus."
    (let* ((frames (seq-filter #'frame-visible-p (frame-list)))
           (focused (seq-filter #'frame-focus-state frames)))
      (when (and focused
                 (bound-and-true-p tab-bar-mode)
                 (> (length frames) 1))
        (let* ((active (if (memq (selected-frame) focused)
                           (selected-frame)
                         (car focused)))
               (switched (not (eq active aero/--last-focused-frame))))
          (setq aero/--last-focused-frame active)
          (dolist (f frames)
            (if (eq f active)
                (aero/--highlight-tab-bar f)
              (aero/--unhighlight-tab-bar f)))
          (when switched
            (with-selected-frame active
              (pulse-momentary-highlight-one-line (point))))))))

  (add-function :after after-focus-change-function
                #'aero/--update-tab-bar-highlight)

(when (and (require 'disp-table nil 'noerror) standard-display-table)
  (set-display-table-slot standard-display-table 'truncation ?…)
  (set-display-table-slot standard-display-table 'wrap ?↩)
  (set-display-table-slot standard-display-table 'selective-display
                          (string-to-vector " …")))

(blink-cursor-mode 0)
(show-paren-mode 1)
(pixel-scroll-mode 1)
(global-hl-line-mode +1)
(setq global-hl-line-buffers
      '(not (or (lambda (b) (buffer-local-value 'cursor-face-highlight-mode b))
                (lambda (b) (string-match-p "\\` " (buffer-name b)))
                (lambda (b) (eq (buffer-local-value 'major-mode b) 'vterm-mode))
                minibufferp)))

(defun aero/suggest-other-faces (func &rest args)
  "When hl-line-mode is active, suggest a face calculated without it.
   Credit: Sacha Chua"
  (if global-hl-line-mode
      (progn
        (global-hl-line-mode -1)
        (prog1 (apply func args)
          (global-hl-line-mode 1)))
    (apply func args)))
(advice-add #'face-at-point :around #'aero/suggest-other-faces)

(defun aero/rainbow-mode ()
  "Display colors represented as hex values."
  (interactive)
  (remove-overlays (point-min) (point-max))
  (let ((hex-color-regex "#[0-9a-fA-F]\\{3,6\\}"))
    (save-excursion
      (goto-char (point-min))
      (while (re-search-forward hex-color-regex nil t)
        (let* ((color (match-string 0))
               (overlay (make-overlay (match-beginning 0) (match-end 0))))
          (if (string-greaterp color "#888888")
              (overlay-put overlay 'face `(:background ,color :foreground "black"))
            (overlay-put overlay 'face `(:background ,color :foreground "white"))))))))
(defun aero/rainbow-mode-disable ()
  "Remove all hex color overlays in the current buffer."
  (interactive)
  (remove-overlays (point-min) (point-max)))
(add-hook 'prog-mode-hook #'aero/rainbow-mode)
(add-hook 'org-mode-hook
          (lambda ()
            (when (and buffer-file-name
                       (string-match-p "config\\.org\\'" buffer-file-name))
              (aero/rainbow-mode))))
(add-hook 'conf-space-mode-hook #'aero/rainbow-mode)

;; disable show-paren-mode in org-mode to avoid false "unmatched expression" errors
(add-hook 'org-mode-hook (lambda () (show-paren-mode -1)))

(global-goto-address-mode +1)

(defun pulse-line (&rest _)
  "Briefly pulse a highlight of the line at point.
This function, when bound to certain commands like scrolling, acts as a native
alternative to the beacon package."
  (pulse-momentary-highlight-one-line (point)))
(dolist (fn '(other-window
              windmove-up
              windmove-down
              windmove-left
              windmove-right
              aero/alternate-buffer
              aero/alternate-window))
  (advice-add fn :after #'pulse-line))

(package! formfeeder "thornjad/formfeeder"
  :defer 2
  :defines (formfeeder-line-width)
  :config
  (setq formfeeder-line-width (- fill-column 1))
  (declare-function global-formfeeder-mode "formfeeder.el")
  (global-formfeeder-mode 1))

(package! highlight-thing (:host github :repo "fgeller/highlight-thing.el")
  :hook (prog-mode . highlight-thing-mode)
  :commands (highlight-thing-mode)
  :custom
  (highlight-thing-delay-seconds 0.5)
  (highlight-thing-narrow-region-lines 70)
  (highlight-thing-large-buffer-limit 5000)
  (highlight-thing-limit-to-region-in-large-buffers-p t))

(package! selection-highlight-mode
  (:host github :repo "balloneij/selection-highlight-mode")
  :hook (prog-mode . selection-highlight-mode)
  :custom (selection-highlight-mode-min-length 3))

(package! todo-light "thornjad/todo-light"
  :defer 2
  :config (global-todo-light-mode +1))

(unless (display-graphic-p)
  (package! evil-terminal-cursor-changer
    (:host github :repo "7696122/evil-terminal-cursor-changer")
    :after evil
    :functions (evil-terminal-cursor-changer-activate)
    :config (evil-terminal-cursor-changer-activate)))

  (defun aero/project-git-sync-master ()
    "In the current project root, switch to master, pull, and update.
Show status and update submodules."
    (interactive)
    (let ((default-directory (project-root (project-current))))
      (async-shell-command
       "git switch master && git pull && git submodule update && git status -sb"
       "*project-git-sync-master*")))

(package! git-gutter :auto
  :hook ((prog-mode text-mode conf-mode) . git-gutter-mode)
  :custom
  (git-gutter:visual-line t)
  (git-gutter:disabled-modes '(so-long-mode
                               image-mode asm-mode
                               doc-view-mode
                               fundamental-mode image-mode pdf-view-mode
                               org-agenda-mode))
  (git-gutter:update-interval 2)
  (git-gutter:handled-backends
   (cons 'git (cl-remove-if-not #'executable-find (list 'hg 'svn 'bzr)
                                :key #'symbol-name)))

  :config
  (add-hook 'focus-in-hook #'git-gutter))

(package! ediff :builtin
  :commands (ediff ediff3)
  :custom
  (ediff-split-window-function #'split-window-horizontally )
  (ediff-window-setup-function #'ediff-setup-windows-plain))

(package! git-link :auto
  :after (general)
  :commands (git-link git-link-commit git-link-homepage)
  :init (aero-leader-def "gL" 'git-link))

(defun archive-buffer-closed-tasks ()
  (interactive)
  (org-map-entries
   (lambda ()
     (when (member (org-get-todo-state) org-done-keywords)
       (org-archive-subtree-default)
       ;; the archive alters the tree, so just go back to the top
       (setq org-map-continue-from (point-min))))
   nil 'file))

(defun trim-archive-entries ()
  "Trim entries in the archive file older than 60 days."
  (interactive)
  (let ((archive-file (expand-file-name aero/thornlog-archive-file)))
    (when (file-exists-p archive-file)
      (let ((cutoff-date (time-subtract (current-time) (days-to-time 60))))
        (with-current-buffer (find-file-noselect archive-file)
          (goto-char (point-min))
          (while (not (eobp))
            (when (and (org-at-heading-p)
                       (let ((archive-time-str (org-entry-get (point) "ARCHIVE_TIME")))
                         (and archive-time-str
                              (time-less-p (org-read-date nil t archive-time-str) cutoff-date))))
              (org-cut-subtree)
              (org-back-to-heading t)
              (outline-previous-heading))
            (outline-next-heading)))
        (save-buffer)))))

(defun aero/org-archive-cleanup ()
  "Archive closed tasks and trim archive entries."
  (interactive)
  (archive-buffer-closed-tasks)
  (trim-archive-entries))

(defun aero/org-collapse-entry-if-done ()
  "Collapse the current entry if it is marked as DONE."
  (when (member org-state '("DONE"))
    (outline-hide-subtree)))

(defun aero/org-expand-entry-if-todo ()
  "Expand the current entry if it is marked as TODO."
  (when (member org-state '("TODO"))
    (outline-show-subtree)))

(defun aero/org-insert-modified-timestamp-now ()
  "Insert a modified property with the current time."
  (interactive)
  (org-set-property "modified" (format-time-string "[%Y-%m-%d %a %H:%M]")))

(defun aero/org-capture-created-timestamp ()
  "Return formatted timestamp for org-capture CREATED property."
  (format-time-string "[%Y-%m-%d %a %H:%M]"))

  (defun aero/reorder-buffer-list (new-list)
    (while new-list
      (bury-buffer (car new-list))
      (setq new-list (cdr new-list))))

  (defun aero/keep-buffer-list-unaltered (orig-fun &rest args)
    (let ((buffers (buffer-list))
          (result (apply orig-fun args)))
      (aero/reorder-buffer-list buffers)
      result))

  (defun org-schedule-and-refile ()
    "Schedule the current entry and refile it."
    (interactive)
    (org-schedule t)
    (org-refile))

  (defun org-deadline-and-refile ()
    "Deadline the current entry and refile it."
    (interactive)
    (org-deadline t)
    (org-refile))

  (defun aero/org-agenda-format-date (date)
    "Format a DATE string for display in the daily/weekly agenda.
  This function makes sure that dates are aligned for easy reading."
    (require 'cal-iso)
    (let* ((dayname (calendar-day-name date))
           (day (cadr date))
           (month (car date))
           (monthname (calendar-month-name month))

           ;; divisor must be float so (/) doesn't do integer division
           (quarter (round (/ (1+ month) 3.0)))

           (year (nth 2 date))
           (iso-week (org-days-to-iso-week
                      (calendar-absolute-from-gregorian date)))
           (day-of-week (calendar-day-of-week date))
           (weekstring (if (= day-of-week 1)
                           (format " W%02d" iso-week)
                         "")))
      (format "%-10s %2d %s %4d%s   (Q%s)"
              dayname day monthname year weekstring quarter)))

  (defun aero/org-deindent-on-return (&rest _)
    "De-indent current line if only whitespace before point when pressing ENTER.

This behavior is IDIOTIC and I cannot suffer to live with this
automatic indentation any longer."
    (when (and (derived-mode-p 'org-mode)
               (save-excursion
                 (move-beginning-of-line 1)
                 (looking-at-p "[ \t]*$")))
      (delete-horizontal-space)))

(package! org :builtin
  :preface

  :custom
  ;; don't persist the element cache to disk; prevents stale cache from
  ;; surviving across sessions (the in-session race condition is handled
  ;; by aero/org-suspend-indent-before-revert below)
  (org-element-cache-persistent nil)

  (org-hide-leading-stars t)
  (org-pretty-entities t)
  (org-indent-mode-turns-on-hiding-stars nil) ; why would this even exist??
  (org-fontify-quote-and-verse-blocks t)
  (org-insert-heading-respect-content t) ; insert headings after current subtree
  (org-fold-catch-invisible-edits 'smart) ; don't accidentally remove hidden text
  (org-startup-with-inline-images t) ; default to showing images on startup
  (org-startup-indented t)
  (org-log-done 'time) ; log time when item is marked done
  (org-log-into-drawer t) ; put logs in LOGBOOK
  (org-refile-use-outline-path t) ; show path to outline level during refile
  (org-fontify-done-headline t) ; let theme strike out done items
  (org-return-follows-link t) ; follow links with RET

  ;; always put blank before new headings, but be smart about list items
  (org-blank-before-new-entry '((heading . t) (plain-list-item . auto)))

  ;; re-scale images to 400px if no with attribute is set (see
  ;; https://lists.gnu.org/archive/html/emacs-orgmode/2012-08/msg01402.html)
  (org-image-actual-width '(400))

  (org-capture-templates
   `(("t" "Deadline/Scheduled Task" entry
      (file+headline
       ,(expand-file-name "todo.org" aero/roam-path)
       "Tasks")
      "* TODO [#E] %?\nSCHEDULED: %t\n:PROPERTIES:\n:CREATED: %(aero/org-capture-created-timestamp)\n:END:\n\n"
      :empty-lines 1)
     ("p" "Ticket (PR)" entry
      (file+headline
       ,(expand-file-name "todo.org" aero/roam-path)
       "Tasks")
      "* TICKET [#E] %?\nSCHEDULED: %t\n:PROPERTIES:\n:CREATED: %(aero/org-capture-created-timestamp)\n:END:\n"
      :empty-lines 1)
     ("r" "Review (PR or tech design)" entry
      (file+headline
       ,(expand-file-name "todo.org" aero/roam-path)
       "Tasks")
      "* REVIEW [#B] %? :review:\nSCHEDULED: %t DEADLINE: %t\n:PROPERTIES:\n:CREATED: %(aero/org-capture-created-timestamp)\n:END:\nLink: "
      :empty-lines 1)
     ("s" "School inbox item" entry
      (file+headline
       ,(expand-file-name "school_todo.org" aero/roam-path)
       "Tasks")
      "* TODO [#B] %?\nSCHEDULED: %t\n:PROPERTIES:\n:CREATED: %(aero/org-capture-created-timestamp)\n:END:\n\n"
      :empty-lines 1)))

  (org-todo-keywords
   '((sequence "TODO(t)" "WAITING(w!)" "BLOCKED(b!)" "BACKLOG(l!)" "|" "DONE(d!)" "REMOVED(k)")
     (sequence "TICKET(T)" "PR(p!)" "|" "DONE(d!)" "CLOSED(x)")
     (sequence "REVIEW(r)" "WAITING(w!)" "BLOCKED(b!)" "|" "DONE(d!)" "CLOSED(x)")))

  (org-use-fast-todo-selection 'expert) ; don't fuck up the window layout
  (org-default-notes-file (expand-file-name "notes_inbox.org" aero/roam-path))
  (org-priority-faces '((?A . error) ; emergency
                        (?B . warning) ; urgent, important
                        (?C . warning) ; urgent, not important
                        (?D . success) ; important, not urgent
                        (?E . success) ; neutral default
                        (?F . org-priority) ; not urgent, not important
                        (?G . org-priority) ; backburner
                        ))
  (org-priority-highest ?A)
  (org-priority-lowest ?G) ; default is C, tasks default to E in org-capture
  (org-reverse-note-order nil) ; put notes at the end of the entry, instead of the top
  (org-archive-location (concat aero/thornlog-archive-file "::* From %s"))

  ;; When editing a source block in its own mode, don't mess with windows at all
  (org-src-window-setup 'current-window)

  ;; don't consider empty lines between entries to be part of the entry
  (org-cycle-separator-lines -2)

  (org-link-frame-setup '((vm . vm-visit-folder-other-frame)
                          (vm-imap . vm-visit-imap-folder-other-frame)
                          (gnus . org-gnus-no-new-news)
                          (file . find-file)
                          (wl . wl-other-frame)))

  ;; Add in some custom structure templates. The default has a few good ones.
  ;; You can insert these either through the menu with =SPC , i i= in Org files,
  ;; or you can type <KEY then TAB.
  (org-structure-template-alist
   '(("a" . "export ascii")
     ("c" . "citation")
     ("C" . "comment")
     ("e" . "example")
     ("E" . "export")
     ("h" . "export html")
     ("q" . "quote")
     ("s" . "src")
     ("v" . "verse")
     ("l" . "src emacs-lisp :lexical t")))

  ;; Agenda
  (org-agenda-span 1) ; days to show at a time
  (org-agenda-start-day nil) ; day to start at
  (org-agenda-start-on-weekday nil) ; start week on current day
  (org-agenda-format-date #'aero/org-agenda-format-date)
  (org-agenda-prefix-format '((agenda . " %i %?-12t% s")
                              (todo . " %i %-12:c")
                              (tags . " %i %-12:c")
                              (search . " %i %-12:c")))

  ;; all agenda files
  (org-agenda-files `(,(expand-file-name "todo.org" aero/roam-path)
                      ,(expand-file-name "school_todo.org" aero/roam-path)
                      ,(expand-file-name "log.org" aero/roam-path)
                      ,(expand-file-name "ritual.org" aero/roam-path)
                      ,(expand-file-name "holidays.org" aero/roam-path)
                      ,(expand-file-name "notes_inbox.org" aero/roam-path)))

  ;; holidays I don't want to display
  (holiday-bahai-holidays nil)
  (holiday-hebrew-holidays nil)
  (holiday-islamic-holidays nil)
  (holiday-christian-holidays nil)
  (holiday-oriental-holidays nil)

  ;; local holidays
  (holiday-local-holidays '((holiday-fixed 3 14 "Pi Day")
                            (holiday-fixed 10 23 "Mole Day")
                            (holiday-fixed 11 23 "Fibonacci Day")
                            (holiday-fixed 12 23 "Festivus")
                            (holiday-fixed 9 19 "Talk Like a Pirate Day")
                            (holiday-fixed 10 9 "Leif Erikson Day")
                            (holiday-fixed 5 4 "Star Wars Day")
                            (holiday-fixed 6 28 "Tau Day")

                            (holiday-fixed 2 27 "Hangover (first day)")
                            (holiday-fixed 2 28 "Hangover (second day)")
                            (holiday-fixed 2 29 "Hangover (third day)")
                            (holiday-fixed 3 1 "Hangover (fourth day)")
                            (holiday-fixed 3 2 "Hangover (fifth day)")
                            (holiday-fixed 3 3 "Hangover (sixth day)")
                            (holiday-fixed 3 4 "Hangover (seventh day)")
                            (holiday-fixed 3 5 "Hangover (eighth day)")
                            (holiday-fixed 3 6 "The Day of the Dude")))

  (org-agenda-log-mode-items nil) ; don't show closed nor clocked items
  (org-agenda-tags-column -70) ; shift tags over
  (org-agenda-sticky nil) ; don't bury on close buffer
  (org-agenda-use-tag-inheritance t)
  (org-agenda-show-log t)
  (org-agenda-skip-deadline-if-done t)
  (org-agenda-skip-deadline-prewarning-if-scheduled 'pre-scheduled)
  (org-agenda-skip-scheduled-if-done t)
  (org-agenda-skip-scheduled-if-deadline-is-shown t) ; don't duplicate deadline & scheduled
  (org-agenda-skip-timestamp-if-done t)
  (org-agenda-skip-timestamp-if-deadline-is-shown t)
  (org-agenda-show-outline-path nil) ; waste of cpu time
  (org-agenda-window-setup 'current-window) ; stop agenda opening a new window
  (org-agenda-skip-unavailable-files t)
  (org-agenda-show-future-repeats nil) ; don't show repeating tasks on future agenda dates
  (org-agenda-custom-commands
   `(("n" "Agenda and all TODOs" ((agenda "") (alltodo "")))
     ("s" "School items" agenda ""
      ((org-agenda-files '(,(expand-file-name "school_todo.org" aero/roam-path)))))
     ("e" "Experimentation tag" tags "experimentation")))

  :init
  (aero-leader-def
    "oa" '(aero/org-agenda-list :wk "agenda")
    "oc" '(aero/org-class-agenda-list :wk "class agenda")
    "oA" '(org-agenda :wk "agenda menu")
    "os" 'org-schedule
    "od" 'org-deadline
    "oj" 'org-clock-goto
    "ot" 'aero/org-set-tags
    "ol" 'org-store-link
    "oT" '(org-tags-view :wk "list tags")
    "vo" 'org-capture)

  :config
  (aero-mode-leader-def
    :keymaps 'org-mode-map
    "t" 'org-todo
    "f" 'org-forward-heading-same-level
    "F" 'org-backward-heading-same-level
    "w" 'org-open-at-point
    "p" 'org-priority
    "r" 'org-refile
    "s" 'org-set-property
    "e" 'org-edit-src-code
    "d" 'insert-new-day
    "i" '(:ignore t :wk "insert")
    "il" 'org-insert-link
    "it" 'org-time-stamp
    "ii" 'org-insert-structure-template
    "id" '(org-insert-drawer :wk "drawer")
    "im" 'insert-meeting-task
    "A" 'aero/org-archive-cleanup
    "c" '(:ignore t :wk "clock / cell")
    "cc" '(org-babel-execute-src-block :wk "exec cell")
    "cs" 'org-babel-demarcate-block)

  (aero-mode-leader-def
    :keymaps 'org-src-mode-map
    "q" 'org-edit-src-exit
    "w" 'org-edit-src-save
    "X" 'org-edit-src-abort)

  ;; keep org-save-all from messing up buffer list
  (advice-add 'org-save-all-org-buffers :around #'aero/keep-buffer-list-unaltered)

  ;; org tries to take this binding back, so wrest control back once more
  (define-key org-mode-map (kbd "M-h") #'windmove-left)

  ;; Collapse entries when they are marked as done, and expand when reopened
  (add-hook 'org-after-todo-state-change-hook
            #'aero/org-collapse-entry-if-done)
  (add-hook 'org-after-todo-state-change-hook #'aero/org-expand-entry-if-todo)

  ;; Get rid of the idiotic indentation after pressing enter
  (advice-add 'org-return :after #'aero/org-deindent-on-return)
  (with-eval-after-load 'evil
    (advice-add 'evil-org-open-below :after #'aero/org-deindent-on-return))

  ;; When inside an org src-block (like right here), turn off fancy quotes and use normal pairing so that typing " inserts "" as expected.
  (add-hook 'org-src-mode-hook
            (lambda ()
              (electric-quote-local-mode -1)
              (electric-pair-local-mode +1)
              (define-key org-src-mode-map (kbd "C-c C-c") #'org-edit-src-exit)))

  ;; Also save after state change
  (add-hook 'org-after-todo-state-change-hook #'org-save-all-org-buffers)

  ;; don't auto-pair dollar signs; org treats $ as LaTeX math delimiters but
  ;; we don't use LaTeX and just want to type dollar signs normally
  (add-hook 'org-mode-hook
            (lambda ()
              (setq-local electric-pair-inhibit-predicate
                          (lambda (c)
                            (if (char-equal c ?$) t
                              (electric-pair-default-inhibit c))))))

  ;; start with all levels collapsed
  (add-hook 'org-mode-hook #'org-hide-block-all)

  ;; Save org files when using clock
  (add-hook 'org-clock-in-hook #'org-save-all-org-buffers)
  (add-hook 'org-clock-out-hook #'org-save-all-org-buffers)

  ;; Force org-capture to not open new windows
  (defun aero/org-capture-place-template-dont-delete-windows (oldfun &rest args)
    (cl-letf (((symbol-function 'delete-other-windows) 'ignore))
      (apply oldfun args)))
  (with-eval-after-load "org-capture"
    (advice-add 'org-capture-place-template
                :around #'aero/org-capture-place-template-dont-delete-windows))

  ;; set up stuff for clock persistence
  (org-clock-persistence-insinuate)

  ;; prevent org-indent from firing during auto-revert; when revert-buffer
  ;; erases and re-inserts file contents, org-indent-refresh-maybe runs via
  ;; after-change-functions on the partially-populated buffer, org-element
  ;; tries to parse a half-written timestamp and throws an error, aborting
  ;; the revert mid-stream and leaving the buffer corrupted but marked as
  ;; modified (Syncthing + auto-revert + org-indent = race condition)
  (defvar-local aero/--org-indent-was-active nil)

  (defun aero/org-suspend-indent-before-revert ()
    "Disable org-indent-mode before revert to prevent mid-revert parse errors."
    (when (and (derived-mode-p 'org-mode)
               (bound-and-true-p org-indent-mode))
      (setq aero/--org-indent-was-active t)
      (org-indent-mode -1)))

  (defun aero/org-restore-indent-after-revert ()
    "Re-enable org-indent-mode after revert completes."
    (when (and (derived-mode-p 'org-mode)
               aero/--org-indent-was-active)
      (setq aero/--org-indent-was-active nil)
      (org-indent-mode 1)))

  (add-hook 'before-revert-hook #'aero/org-suspend-indent-before-revert)
  (add-hook 'after-revert-hook #'aero/org-restore-indent-after-revert))

(package! org-appear "awth13/org-appear"
  :custom (org-hide-emphasis-markers t)
  :hook (org-mode . org-appear-mode))

(package! org-modern "minad/org-modern"
  :hook ((org-mode . org-modern-mode)
         (org-agenda-finalize-hook . org-modern-agenda))
  :custom
  (org-modern-star 'replace)

  ;; disable table styling in TUI mode where Unicode box chars render poorly
  (org-modern-table (when (display-graphic-p) t))
  (org-modern-table-vertical (when (display-graphic-p) 1))
  (org-modern-table-horizontal (when (display-graphic-p) 0.1)))

(package! evil-org-mode "Somelauw/evil-org-mode"
  :after (evil org)
  :preface
  (defun aero/evil-org-agenda-mode ()
    "Shim in org-agenda evil mode."
    (require 'evil-org-agenda)
    (evil-org-agenda-set-keys))

  :hook ((org-mode . evil-org-mode)
         (org-agenda-mode . aero/evil-org-agenda-mode)))

(package! org-fancy-priorities "harrybournis/org-fancy-priorities"
  :after (org)
  :hook (org-mode . org-fancy-priorities-mode)
  :custom

  ;; Based on the Eisenhower matrix. "!" means urgent, arrows represent importance. "_" is a
  ;; "backburner" lowest priority. #A is an emergency priority, likely overriding other tasks.
  (org-fancy-priorities-list '("!!↑↑" "!↑" "!↓" "↑" "·" "↓" "_")))

(package! org-super-agenda "alphapapa/org-super-agenda"
  :preface
  (defun aero/org-super-agenda-without-keymap ()
    "Stops super-agenda from overriding evil-org bindings."
    (org-super-agenda-mode)
    (setq org-super-agenda-header-map nil))

  (defvar aero/org-super-agenda-timer nil)

  (defun aero/org-super-agenda-refresh ()
    "If *Org Agenda* is visible, select its window and do a proper org-agenda-redo."
    (when-let* ((win (get-buffer-window "*Org Agenda*")))
      (with-selected-window win
        (org-agenda-redo))))

  (defun aero/org-super-agenda-start-timer ()
    "Start an idle timer to refresh the super agenda after 60 seconds of inactivity."
    (interactive)
    (unless aero/org-super-agenda-timer
      (setq aero/org-super-agenda-timer
            (run-with-idle-timer 60 t #'aero/org-super-agenda-refresh))))

  (defun aero/org-super-agenda-stop-timer ()
    (interactive)
    (when aero/org-super-agenda-timer
      (cancel-timer aero/org-super-agenda-timer)
      (setq aero/org-super-agenda-timer nil)))

  :hook ((org-agenda-after-show . recenter)
         (org-agenda-mode . aero/org-super-agenda-start-timer)
         (org-agenda-mode . aero/org-super-agenda-without-keymap))

  :custom
  (org-super-agenda-groups
   '((:name "Daily Routine - In Progress" :and (:todo "STARTED" :tag "ritual" :not (:time-grid t)))
     (:name "Daily Routine" :and (:tag "ritual" :not (:time-grid t)))
     (:name "Holidays" :tag "holiday" :category ("Holiday" "Anniversaries"))
     (:name "Outstanding meetings" :and (:scheduled past :tag "meeting"))
     (:time-grid t)
     (:name "Reviews to do" :and (:tag "review"
                                  :todo "REVIEW"
                                  :not (:todo ("WAITING" "BLOCKED" "BACKLOG"))))
     (:name "Support" :tag "support")
     (:name "Waiting/blocked" :todo ("WAITING" "BLOCKED"))
     (:name "Past due" :and (:deadline past :not (:todo ("WAITING" "BLOCKED"))))
     (:name "Due today" :and (:deadline today :not (:todo ("WAITING" "BLOCKED"))))
     (:name "PRs" :and (:tag "ticket" :todo "PR"))
     (:name "Tickets" :todo ("TICKET") :tag "ticket")
     (:name "Class" :tag "school" :tag "class")
     (:name "Prioritized" :not (:todo ("WAITING" "BLOCKED" "BACKLOG")
                                :tag "holiday"
                                :category ("Holiday" "Anniversaries")))
     (:name "Backlog" :todo "BACKLOG")))

  ;; add space between dates by adding space after the final group
  (org-super-agenda-final-group-separator "\n")

  ;; Force the agenda to not override evil keys on the header
  ;; https://github.com/alphapapa/org-super-agenda/issues/239
  (org-super-agenda-header-map nil)

  :config
  ;; Stop the timer if the agenda buffer is killed
  (add-hook 'kill-buffer-hook
            (lambda ()
              (when (string= (buffer-name) "*Org Agenda*")
                (aero/org-super-agenda-stop-timer)))))

(package! org-download "abo-abo/org-download"
  :after (org general)
  :commands (org-download-clipboard org-download-yank org-download-screenshot)
  :custom (org-download-method 'directory)
  :init
  (aero-mode-leader-def
    :keymaps 'org-mode-map
    "ic" '(org-download-clipboard :wk "insert image from clipboard")))

(defun aero/org-agenda-list ()
  "`org-agenda', skipping command menu to list."
  (interactive)
  (org-agenda nil "a"))

(defun aero/org-class-agenda-list ()
  "`org-agenda', skipping command menu to list."
  (interactive)
  (org-agenda nil "s"))

(defun aero/org-agenda-todo ()
  "`org-agenda', skipping command menu to todos."
  (interactive)
  (org-agenda nil "t"))

(defun aero/org-agenda-new ()
  "Create a new task at the current agenda item."
  (interactive)
  (org-agenda-switch-to)
  (org-capture 0))

(defun insert-todays-timestamp-at-entry-end ()
  "Insert today's timestamp at the end of the current org entry."
  (interactive)
  (save-excursion
    (org-back-to-heading t)
    (end-of-line)
    (insert " ")
    (org-insert-time-stamp (current-time) nil)))

(defun aero/local-quit-agenda ()
  "Quit agenda buffer in current frame only, without affecting other frames.
  Switches to previous buffer and removes agenda buffer from window history
  so aero/alternate-buffer won't immediately return to it."
  (interactive)
  (let* ((agenda-buf (current-buffer))
         (current-window (selected-window))
         ;; Get the buffer that was before the agenda in this window's history
         (prev-buf (cl-find agenda-buf (window-prev-buffers) :key #'car :test-not #'eq)))
    ;; Switch to the previous buffer
    (if prev-buf
        (switch-to-buffer (car prev-buf))
      (switch-to-buffer (other-buffer agenda-buf)))
    ;; Remove agenda buffer from this window's previous buffer list
    (set-window-prev-buffers current-window
                             (cl-remove agenda-buf (window-prev-buffers current-window) :key #'car))
    ;; Also bury it globally
    (bury-buffer agenda-buf)))
(with-eval-after-load 'org-agenda
  (define-key org-agenda-mode-map "q" #'aero/local-quit-agenda))

(package! org-roam :auto
  :after (general org)
  :functions (org-roam-node-find
              org-roam-capture
              org-roam-node-insert
              org-roam-alias-add
              org-roam-refile)

  :custom
  (org-roam-directory (expand-file-name "roam" aero/thornlog-path))
  (org-roam-database-connector 'sqlite-builtin)
  (org-roam-db-update-on-save t)
  (org-roam-mode-sections
   (list #'org-roam-backlinks-section
         #'org-roam-reflinks-section
         #'org-roam-unlinked-references-section))

  (org-id-locations-file (expand-file-name ".org-id-locations" aero-cache-dir))

  (org-roam-capture-templates
   '(("d" "default" plain "%?"
      :target (file+head "%<%Y%m%d%H%M%S>-${slug}.org" "#+title: ${title}\n")
      :immediate-finish t
      :unnarrowed t)))

  (org-roam-node-display-template
   (concat "${title} " (propertize "${tags}" 'face 'org-tag)))

  :init
  (defun aero/org-roam-node-insert-dwim ()
    "Insert a roam node link. If region is active, wrap it; otherwise insert after point."
    (interactive)
    (unless (use-region-p)
      (goto-char (min (1+ (point)) (line-end-position))))
    (org-roam-node-insert))

  (aero-leader-def
    "vf" 'org-roam-node-find
    "vF" 'org-roam-capture
    "vi" '(aero/org-roam-node-insert-dwim :wk "insert roam node")
    "vc" '(org-id-get-create :wk "create org ID for node")
    "va" 'org-roam-alias-add
    "vr" 'org-roam-refile
    "vS" '(aero/org-roam-db-sync-incremental :wk "incremental sync")
    "vs" '(aero/org-roam-db-sync-full :wk "full sync")
    "vV" '(aero/org-roam-db-vacuum :wk "vacuum database"))

  :config
  (org-roam-db-autosync-mode))

(package! verb :auto
  :commands (verb-send-request-on-point-other-window-stay)
  :after (org general)
  :init
  (aero-mode-leader-def
    :keymaps 'org-mode-map
    "RET" 'verb-send-request-on-point-other-window-stay))

(package! esup "jschaf/esup"
  :commands (esup)
  :config
  (defun esup-read-results ()
    "Read all `esup-result' objects from `esup-incoming-results-buffer'.

HACKED by Aero to add nil checking."
    (let (results sep-end-point)
      (with-current-buffer (get-buffer esup-incoming-results-buffer)
        (goto-char esup-last-result-start-point)
        (message "at %s" esup-last-result-start-point)
        (unless (eobp)
          (while (setq sep-end-point (esup-next-separator-end-point))
            (when-let* ((result (car (esup-read-result (point)))))
              (push result results))
            (setq esup-last-result-start-point sep-end-point)
            (goto-char esup-last-result-start-point))))
      (nreverse results))))

(add-to-list 'auto-mode-alist '("/[^./]*\\'" . text-mode))
(add-to-list 'auto-mode-alist '("\\(README\\|readme\\)\\'" . text-mode))
(add-to-list 'auto-mode-alist '("/\\.dir-locals\\.el\\'" . emacs-lisp-mode))
(add-to-list 'auto-mode-alist '("/Cask\\'" . emacs-lisp-mode))
(add-to-list 'auto-mode-alist '("Makefile" . makefile-mode))

(package! cc-mode :builtin
  :mode (("\\.c\\'" . c-mode)
         ("\\.h\\'" . c-mode)
         ("\\.cpp\\'" . cpp-mode)
         ("\\.hpp\\'" . cpp-mode))
  :preface
  (defun aero/c-mode-common-hook ()
    "Hook to run in all C modes"
    (set (make-local-variable 'parens-require-spaces) nil))
  :hook (c-mode-common . aero/c-mode-common-hook))

(package! sh-script :builtin :defer t
  :mode ("\\.\\(sh\\|bash\\|zsh\\|zsh-theme\\)\\'" . sh-mode)
  :config
  (defun indent-paragraph ()
    (interactive)
    (save-excursion
      (mark-paragraph) (indent-region (region-beginning) (region-end)))))

(package! markdown-mode "jrblevin/markdown-mode"
  :after (general smartparens)
  :mode (("\\.md\\'" . gfm-mode)
         ("\\.markdown\\'" . gfm-mode)
         ("\\.mdc\\'" . gfm-mode)
         ("github\\.com.*\\.txt\\'" . gfm-mode))
  :hook (markdown-mode . flyspell-mode)

  :custom
  (markdown-mode-syntax-table (make-syntax-table text-mode-syntax-table))
  (markdown-header-scaling t)
  (markdown-display-remote-images t)
  (markdown-header-scaling-values '(1.3 1.2 1.1 1.0 1.0 1.0))
  (markdown-enable-wiki-links t)
  (markdown-italic-underscore t)
  (markdown-make-gfm-checkboxes-buttons t)
  (markdown-gfm-additional-languages '("sh"))
  (markdown-fontify-code-blocks-natively t)

  :config
  (sp-local-pair 'gfm-mode "- [ " "]"))

(package! yaml-mode (:repo "yoshiki/yaml-mode")
  :mode "\\.ya?ml\\'")

(package! web-mode "fxbois/web-mode"
  :mode "\\.\\(jsp\\|tpl\\|php\\|xml\\|html?\\|erb\\|svg\\|mjs\\|jsx\\|s?css\\|astro\\)\\'"
  :custom (web-mode-enable-engine-detection t)
  :config
  (unless (treesitterp) (add-to-list 'auto-mode-alist '("\\.tsx\\'" . web-mode))))

(package! jest "thornjad/emacs-jest"
  :commands (jest jest-file jest-test)
  :after (general))

(package! clojure-mode :auto :mode "\\.\\(cljs?\\|cljs.*\\|edn\\|boot\\)\\'")

(package! python-mode :auto
  :after (general)
  :mode "\\.py\\'"
  :custom
  (python-indent-guess-indent-offset t)
  (python-indent-guess-indent-offset-verbose nil)
  :init
  (setq-default python-shell-interpreter "python3")
  (setq-default python-indent-offset 4)

  :config
  (defvar python-mode-initialized nil))

(package! toml-mode :auto
  :mode "\\(\\.toml\\|Cargo\\.lock\\)\\'")

(package! docker-compose-mode :auto :mode "docker-compose.*\.yml\\'")
(package! dockerfile-mode :auto :mode "Dockerfile[a-zA-Z.-]*\\'")

(package! applescript-mode :auto :mode "\\.applescript\\'")

(package! nhexl-mode :auto :defer t)

(package! terraform-mode :auto :mode "\\.tf\\'")

(package! graphql-mode :auto :mode "\\.graphql\\'")

(package! csv-mode :auto :mode "\\.csv\\'")

(add-hook
 'orson-mode-hook
 (lambda ()
   (setq-local indent-tabs-mode nil)
   (prettify-symbols-mode nil)))

(package! elm-mode :auto :hook (elm-mode . elm-indent-mode))

(package! tcl :builtin
  :mode ("\\(\\.tcl\\|\\.test\\)\\'" . tcl-mode)
  :custom
  (tcl-application "tclsh")
  :config
  (add-to-list 'tcl-type-alist '("namespace" "eval" tcl-expr tcl-commands)))

(package! rivet-mode "thornjad/rivet-mode")

(package! smartparens "Fuco1/smartparens"
  :after (general) :defer 5
  :functions (show-smartparens-global-mode
              sp-kill-sexp sp-local-pair
              sp-local-pairs sp-pair
              sp-up-sexp)
  :after (evil general)
  :hook ((after-init . smartparens-global-mode))

  :init
  (setq sp-show-pair-from-inside t)
  (smartparens-global-mode +1)

  :config
  (defun aero/smart-closing-parenthesis ()
    "Insert a closing pair delimiter or move point past existing delimiter.

If the expression at point is already balanced and there is a closing delimiter
for that expression on the current line, move point forward past the closing
delimiter. If the expression is balanced but there is no closing delimiter on
the current line, insert a literal ')' character. If the expression is not
balanced, insert a closing delimiter for the current expression. This command
uses Smartparens navigation commands and therefore recognizes pair delimiters
that have been defined using `sp-pair' or `sp-local-pair'.

If smartparens-mode is not active, simply insert a literal ')' character."
    (interactive)
    (if (bound-and-true-p smartparens-mode)
        (let* ((sp-navigate-close-if-unbalanced t)
               (current-pos (point))
               (current-line (line-number-at-pos current-pos))
               next-pos next-line)
          (aero/voidvar! sp-navigate-close-if-unbalanced)
          (save-excursion
            (let ((buffer-undo-list)
                  (modified (buffer-modified-p)))
              (unwind-protect
                  (progn
                    (sp-up-sexp)
                    (setq next-pos (point)
                          next-line (line-number-at-pos)))
                (primitive-undo (length buffer-undo-list)
                                buffer-undo-list)
                (set-buffer-modified-p modified))))
          (cond
           ((and (= current-line next-line)
                 (not (= current-pos next-pos)))
            (sp-up-sexp))
           (t
            (insert-char ?\)))))
      (insert-char ?\))))

  (require 'smartparens-config)
  (show-smartparens-global-mode t)

  (defun aero/copy-sexp-as-kill (&optional arg)
    "Copy the sexp to the kill ring without killing."
    (interactive)
    (funcall #'sp-kill-sexp arg t))

  (defun aero/sp-wrap-double-quote () (interactive) (sp-wrap-with-pair "\""))
  (defun aero/sp-wrap-single-quote () (interactive) (sp-wrap-with-pair "'"))
  (defun aero/sp-wrap-backtick () (interactive) (sp-wrap-with-pair "`"))
  (defun aero/sp-wrap-angle () (interactive) (sp-wrap-with-pair "<"))

  (general-define-key
   :states '(normal visual)
   :prefix "SPC"
   "s^" '(sp-beginning-of-sexp :which-key "beginning of sexp")
   "s$" '(sp-end-of-sexp :which-key "end of sexp")
   "sh" '(sp-backward-sexp :which-key "back")
   "sl" '(sp-forward-sexp :which-key "forward")
   "sw" '(:ignore t :which-key "wrap")
   "sw(" 'sp-wrap-round
   "sw{" 'sp-wrap-curly
   "sw[" 'sp-wrap-square
   "sw<" 'aero/sp-wrap-angle
   "sw\"" '(aero/sp-wrap-double-quote :wk "wrap double quote")
   "sw'" '(aero/sp-wrap-single-quote :wk "wrap single quote")
   "sw`" '(aero/sp-wrap-backtick :wk "wrap backtick")
   "swr" 'sp-rewrap-sexp
   "su" '(sp-unwrap-sexp :which-key "unwrap")
   "sk" '(sp-kill-sexp :which-key "kill")
   "sK" '(aero/copy-sexp-as-kill :wk "copy as kill"))

  (sp-local-pair 'web-mode "<?" "?>")
  (sp-local-pair 'web-mode "{" "}")
  (sp-local-pair 'web-mode "{ " " }")
  (sp-local-pair 'web-mode "{%" "%}")
  (sp-local-pair 'web-mode "{% " " %}")
  (sp-local-pair 'web-mode "{{ " " }}")
  (sp-local-pair 'web-mode "`" "`")
  (sp-local-pair 'org-mode "$" "$")
  (sp-local-pair 'org-mode "=" "=")
  (sp-local-pair 'org-mode "/" "/" :trigger-wrap "/" )
  (sp-local-pair 'markdown-mode "```" "```" :post-handlers '(:add ("||\n[i]" "RET")))

  (sp-pair "{" "}" :post-handlers '(:add ("||\n[i]" "RET")))
  (sp-pair "[" "]" :post-handlers '(:add ("||\n[i]" "RET")))
  (sp-pair "(" ")" :post-handlers '(:add ("||\n[i]" "RET")))

  (define-key evil-insert-state-map ")" 'aero/smart-closing-parenthesis))

(package! flymake :builtin
  :after (general)
  :custom
  (flymake-fringe-indicator-position 'left-fringe)
  (flymake-wrap-around t)
  (flymake-no-changes-timeout 0.6)

  :config
  (aero-leader-def
    "en" 'flymake-goto-next-error
    "ep" 'flymake-goto-prev-error
    "eb" 'flymake-show-buffer-diagnostics))

(package! flyspell :builtin
  :after (general)
  :hook ((prog-mode . flyspell-prog-mode)
         (text-mode . flyspell-mode))
  :config
  (defvar aero-etc-dir)
  (setq
   flyspell-issue-message-flag nil
   ispell-personal-dictionary (expand-file-name "ispell/personal_dictionary.aws" aero/thornlog-path)
   flyspell-sort-corrections nil)

  (add-to-list 'ispell-skip-region-alist '("#\\+BEGIN_SRC" . "#\\+END_SRC"))
  (add-to-list 'ispell-skip-region-alist '("#\\+BEGIN_EXAMPLE" . "#\\+END_EXAMPLE"))

  (aero-leader-def
    "psP" 'flyspell-prog-mode
    "psN" 'flyspell-goto-next-error
    "psw" 'flyspell-word
    "psb" 'flyspell-buffer
    "psr" 'flyspell-region))

(package! shrface (:host github :repo "chenyanming/shrface")
  :defer t
  :after (eww)
  :hook (eww-after-render . shrface-mode)
  :custom (shrface-href-versatile t)
  :config
  (shrface-basic)
  (shrface-trial)
  (shrface-default-keybindings))

(package! shr-tag-pre-highlight "xuchunyang/shr-tag-pre-highlight.el"
  :after (shr)
  :config
  (add-to-list 'shr-external-rendering-functions '(pre . shr-tag-pre-highlight)))

(defun aero-elfeed-org ()
  "Set `elfeed-feeds' from the org file."
  (interactive)
  (require 'org-element)
  (setq elfeed-feeds
        (with-temp-buffer
          (insert-file-contents aero/thornlog-elfeed-org-file)
          (org-mode)
          (let (links)
            (org-element-map (org-element-parse-buffer) 'link
              (lambda (element)
                (let ((raw-link (org-element-property :raw-link element))
                      tags)

                  ;; Traverse up the tree to collect tags from parent headlines
                  (while (setq element (org-element-property :parent element))
                    (when (eq (org-element-type element) 'headline)
                      (let ((headline-tags (org-element-property :tags element)))
                        (when headline-tags
                          (setq tags (append tags (mapcar 'intern headline-tags)))))))
                  (when-let* ((feed-title (org-entry-get element "feed_title")))
                    (setf (elfeed-meta (elfeed-db-get-feed raw-link) :title) feed-title))
                  (push (if tags (cons raw-link tags) raw-link) links))))
            links)))
  (elfeed-log 'info "aero-elfeed-org loaded %i feeds" (length elfeed-feeds)))

;; Run once when elfeed loads up
(with-eval-after-load 'elfeed
  (aero-elfeed-org))

(package! aero-claude :localpackage
  :commands (aero/claude aero/claude-force-redisplay)
  :init
  (aero-leader-def
    "ac" 'aero/claude
    "as" 'aero/claude-force-redisplay))

(package! xterm-color :auto
  :commands (xterm-color-filter)
  :init
  (setq compilation-environment '("TERM=xterm-256color"))
  (defun aero/advice-compilation-filter (f proc string)
    (funcall f proc (xterm-color-filter string)))
  (advice-add 'compilation-filter :around #'aero/advice-compilation-filter))

(when (bound-and-true-p module-file-suffix)  ; Requires Emacs modules
  (package! vterm :auto :defer t
    :after (general)
    :custom
    (vterm-max-scrollback 5000)
    (vterm-kill-buffer-on-exit t)
    (vterm-term-environment-variable "xterm-256color") ; Better TUI compatibility

    :init
    ;; HACK vterm clumsily forces vterm-module.so to compile when the package is loaded. This is
    ;; necessary to prevent compilation when use-package is evaluated during byte- or
    ;; native-compilation of _this_ file.
    (when noninteractive
      (advice-add #'vterm-module-compile :override #'ignore)
      (provide 'vterm-module))

    (aero-leader-def
      "S'" 'vterm)

    :config
    ;; disable smartparens in vterm and let vterm handle ) natively
    (add-hook 'vterm-mode-hook
              (lambda ()
                (setq-local evil-insert-state-cursor 'bar)
                (smartparens-mode -1)
                (evil-local-set-key 'insert ")" #'vterm--self-insert)
                (evil-insert-state)))

    ;; bind Shift-Enter to insert literal newline (Ctrl-J)
    (define-key vterm-mode-map (kbd "<S-return>")
                (lambda ()
                  (interactive)
                  (vterm-send-key "j" nil nil t)))))

(package! eshell :builtin
  :after (general evil)
  :commands eshell
  :defines (evil-move-cursor-back
            eshell-save-history-on-exit
            eshell-history-size
            eshell-glob-case-insensitive
            eshell-ls-initial-args
            eshell-cmpl-dir-ignore
            eshell-visual-commands
            eshell-visual-subcommands)
  :functions (eshell-previous-input
              eshell-next-input)
  :config
  (with-eval-after-load 'esh-mode
    (define-key eshell-mode-map (kbd "M-h") #'windmove-left)
    (define-key eshell-mode-map (kbd "M-l") #'windmove-right)
    (define-key eshell-mode-map (kbd "M-p") #'eshell-previous-input)
    (define-key eshell-mode-map (kbd "M-n") #'eshell-next-input)
    (define-key eshell-mode-map (kbd "M-r") #'consult-history))

  (setq
   eshell-save-history-on-exit t
   eshell-buffer-maximum-lines 12000
   eshell-glob-case-insensitive t
   eshell-aliases-file (expand-file-name "eshell-alias" aero-etc-dir)
   eshell-history-size 350
   eshell-ls-initial-args "-lah"
   eshell-cmpl-dir-ignore "\\`\\(\\.\\.?\\|CVS\\|\\.svn\\|\\.git\\)/\\'"
   eshell-visual-commands '("vi" "screen" "top" "less" "more" "lynx"
                            "ncftp" "pine" "tin" "trn" "elm" "vim"
                            "nmtui" "alsamixer" "htop" "el" "elinks"
                            "ssh" "nethack" "dtop" "dstat" "docker-compose")
   eshell-visual-subcommands '(("git" "log" "diff" "show"))
   eshell-cmpl-cycle-completions nil ; tab cycles the completion list
   eshell-buffer-maximum-lines 12000 ; auto truncate after 12k lines
   eshell-history-size 500 ; history size
   eshell-buffer-shorthand t ; buffer shorthand -> echo foo > #'buffer
   eshell-plain-echo-behavior t ; treat 'echo' like shell echo
   eshell-banner-message '(format "%s %s\n"
                                  (propertize (format " %s " (string-trim (buffer-name)))
                                              'face 'mode-line-highlight)
                                  (propertize (current-time-string)
                                              'face 'font-lock-keyword-face))
   eshell-scroll-to-bottom-on-input 'all
   eshell-kill-processes-on-exit t
   eshell-hist-ignoredups t
   eshell-error-if-no-glob t  ; mimics zsh behavior
   completion-ignore-case t)

  ;; Enable autopairing in eshell
  (add-hook 'eshell-mode-hook #'smartparens-mode)

  ;; Try to load in PATH
  (let ((default-directory (expand-file-name "~")))
    (setq eshell-path-env (getenv "PATH")))

  ;; doesn't handle less too well
  ;; (setenv "PAGER" "cat")
  (setenv "PAGER" "bat")
  (setenv "TERM" "xterm-256color")

  ;; Remove hscroll-margin in shells, otherwise you get jumpiness when the
  ;; cursor comes close to the left/right edges of the window.
  (add-hook 'eshell-mode-hook
            (lambda () (setq-local hscroll-margin 0
                                   evil-move-cursor-back nil)))

  ;; Use tab to cycle completions
  (add-hook 'eshell-mode-hook (lambda () (setq-local pcomplete-cycle-completions nil)))

  (defalias 'eshell/emacs 'find-file)

  (defun eshell/e (pattern)
    (if (stringp pattern)
        (find-file pattern)
      (mapc #'find-file (mapcar #'expand-file-name pattern))))

  (defun eshell/rmdanglingdockers ()
    (let ((dangling-images (shell-command-to-string "docker images -f \"dangling=true\" -q")))
      (if (string-empty-p dangling-images)
          (message "No dangling images found.")
        (eshell-command (concat "docker rmi " dangling-images)))))

  (defun eshell/dockerkillorphans ()
    (let ((orphan-volumes (shell-command-to-string "docker volume ls -qf dangling=true")))
      (if (string-empty-p orphan-volumes)
          (message "No orphan volumes found.")
        (eshell-command (concat "docker volume rm " orphan-volumes)))))

  (defun eshell/dockercleanup ()
    (eshell/dockerkillorphans)
    (eshell/rmdanglingdockers))

  ;; So the history vars are defined
  (require 'em-hist)
  (when (boundp 'eshell-save-history-on-exit)
    ;; Don't ask, just save
    (setq eshell-save-history-on-exit t))

  (with-eval-after-load 'esh-opt
    (require 'em-cmpl)
    (require 'em-prompt)
    (require 'em-term)))

(package! lichess :auto
  :commands (lichess lichess-tv lichess-game-watch)
  :custom
  (lichess-ai-default-level 3))