#+Title: spl3g's Emacs config
#+AUTHOR: spl3g
#+STARTUP: showeverything
#+OPTIONS: toc:2

* Table Of Contents :toc:
- [[#progs-to-load-first][Progs to load first]]
  - [[#elpaca][elpaca]]
  - [[#from-minimal-emacsd][From minimal-emacs.d]]
  - [[#no-littering][No littering]]
  - [[#save-history][Save history]]
  - [[#meow-mode][Meow mode]]
  - [[#general-keybindings][General keybindings]]
  - [[#which-key][Which key]]
- [[#gui-tweaks][GUI tweaks]]
  - [[#disable-gui-shit][Disable gui shit]]
  - [[#fonts][Fonts]]
  - [[#display-line-numbers][Display line numbers]]
  - [[#icons][Icons]]
  - [[#modeline][Modeline]]
  - [[#scroll][Scroll]]
  - [[#indent-guide][Indent guide]]
- [[#org-mode][Org mode]]
  - [[#org-modern][Org modern]]
  - [[#toc][TOC]]
  - [[#requests-from-org-mode][Requests from org-mode]]
- [[#better-ux][Better UX]]
  - [[#vertico][Vertico]]
  - [[#consult][Consult]]
  - [[#embark][Embark]]
  - [[#pairs][Pairs]]
  - [[#debugging][Debugging]]
  - [[#truncate-lines][Truncate lines]]
  - [[#rainbow-delimiters][Rainbow delimiters]]
  - [[#better-help][Better *help*]]
  - [[#better-other-window][Better other-window]]
  - [[#undo-tree][Undo Tree]]
  - [[#dumb-jump][Dumb jump]]
  - [[#command-sorting-and-filtering][Command sorting and filtering]]
  - [[#multiple-cursors][Multiple Cursors]]
- [[#eshell][Eshell]]
  - [[#open-eshell][Open eshell]]
  - [[#fish-completions][Fish completions]]
  - [[#eat][Eat]]
  - [[#highlighting][Highlighting]]
- [[#lsp][LSP]]
  - [[#error-checking][Error checking]]
  - [[#corfu][Corfu]]
  - [[#tree-sitter][Tree-sitter]]
  - [[#snippets][Snippets]]
  - [[#formatting][Formatting]]
  - [[#languages][Languages]]
  - [[#direnv][Direnv]]
  - [[#better-scratch][Better scratch]]
- [[#dired][Dired]]
  - [[#bindings][Bindings]]
  - [[#media-files][Media files]]
  - [[#casual-dired][Casual dired]]
- [[#sql][Sql]]
- [[#additional-apps][Additional apps]]
  - [[#magit][Magit]]

* Progs to load first
** elpaca
#+begin_src emacs-lisp
  (setq elpaca-core-date 20240622)
  (defvar elpaca-installer-version 0.7)
  (defvar elpaca-directory (expand-file-name "elpaca/" user-emacs-directory))
  (defvar elpaca-builds-directory (expand-file-name "builds/" elpaca-directory))
  (defvar elpaca-repos-directory (expand-file-name "repos/" elpaca-directory))
  (defvar elpaca-order '(elpaca :repo "https://github.com/progfolio/elpaca.git"
                                :ref nil
                                :files (:defaults "elpaca-test.el" (:exclude "extensions"))
                                :build (:not elpaca--activate-package)))
  (let* ((repo  (expand-file-name "elpaca/" elpaca-repos-directory))
         (build (expand-file-name "elpaca/" elpaca-builds-directory))
         (order (cdr elpaca-order))
         (default-directory repo))
    (add-to-list 'load-path (if (file-exists-p build) build repo))
    (unless (file-exists-p repo)
      (make-directory repo t)
      (when (< emacs-major-version 28) (require 'subr-x))
      (condition-case-unless-debug err
          (if-let ((buffer (pop-to-buffer-same-window "*elpaca-bootstrap*"))
                   ((zerop (call-process "git" nil buffer t "clone"
                                         (plist-get order :repo) repo)))
                   ((zerop (call-process "git" nil buffer t "checkout"
                                         (or (plist-get order :ref) "--"))))
                   (emacs (concat invocation-directory invocation-name))
                   ((zerop (call-process emacs nil buffer nil "-Q" "-L" "." "--batch"
                                         "--eval" "(byte-recompile-directory \".\" 0 'force)")))
                   ((require 'elpaca))
                   ((elpaca-generate-autoloads "elpaca" repo)))
              (progn (message "%s" (buffer-string)) (kill-buffer buffer))
            (error "%s" (with-current-buffer buffer (buffer-string))))
        ((error) (warn "%s" err) (delete-directory repo 'recursive))))
    (unless (require 'elpaca-autoloads nil t)
      (require 'elpaca)
      (elpaca-generate-autoloads "elpaca" repo)
      (load "./elpaca-autoloads")))
  (add-hook 'after-init-hook #'elpaca-process-queues)
  (elpaca `(,@elpaca-order))

  (elpaca elpaca-use-package
    ;; Enable :elpaca use-package keyword.
    (elpaca-use-package-mode)
    ;; Assume :elpaca t unless otherwise specified.
    (setq elpaca-use-package-by-default t))

  (elpaca-wait)
  (use-package benchmark-init
    :config
    (add-hook 'after-init-hook 'benchmark-init/deactivate))
#+end_src
** From minimal-emacs.d
*** Misc
#+begin_src emacs-lisp
  ;; switch-to-buffer runs pop-to-buffer-same-window instead
  (setq switch-to-buffer-obey-display-actions t)

  (setq show-paren-delay 0.1
        show-paren-highlight-openparen t
        show-paren-when-point-inside-paren t
        show-paren-when-point-in-periphery t)

  (setq whitespace-line-column nil)  ; whitespace-mode
  (setq comint-prompt-read-only t)
  (setq comint-buffer-maximum-size 2048)

  (setq compilation-always-kill t
        compilation-ask-about-save nil
        compilation-scroll-output 'first-error)

  (setq truncate-string-ellipsis "…")

  ;; Configure Emacs to ask for confirmation before exiting
  (setq confirm-kill-emacs 'y-or-n-p)

  ;; Delete by moving to trash in interactive mode
  (setq delete-by-moving-to-trash (not noninteractive))
#+end_src
*** Files
#+begin_src emacs-lisp
  ;; Disable the warning-suppress-types "X and Y are the same file". Ignoring this warning is
  ;; acceptable since it will redirect you to the existing buffer regardless.
  (setq find-file-suppress-same-file-warnings t)

  ;; Resolve symlinks when opening files, so that any operations are conducted
  ;; from the file's true directory (like `find-file').
  (setq find-file-visit-truename t
        vc-follow-symlinks t)

  ;; Skip confirmation prompts when creating a new file or buffer
  (setq confirm-nonexistent-file-or-buffer nil)

  (setq uniquify-buffer-name-style 'forward)

  (setq mouse-yank-at-point t)
#+end_src
*** Backup files
#+begin_src emacs-lisp
  ;; Avoid generating backups or lockfiles to prevent creating world-readable
  ;; copies of files.
  (setq create-lockfiles nil)
  (setq make-backup-files nil)

  (setq backup-directory-alist
        `(("." . ,(expand-file-name "backup" user-emacs-directory))))
  (setq tramp-backup-directory-alist backup-directory-alist)
  (setq backup-by-copying-when-linked t)
  (setq backup-by-copying t)  ; Backup by copying rather renaming
  (setq delete-old-versions t)  ; Delete excess backup versions silently
  (setq version-control t)  ; Use version numbers for backup files
  (setq kept-new-versions 5)
  (setq kept-old-versions 5)
  (setq vc-make-backup-files nil)  ; Do not backup version controlled files
#+end_src
*** Auto save
#+begin_src emacs-lisp
  ;; Enable auto-save to safeguard against crashes or data loss. The
  ;; `recover-file' or `recover-session' functions can be used to restore
  ;; auto-saved data.
  (setq auto-save-default t)

  ;; Do not auto-disable auto-save after deleting large chunks of
  ;; text. The purpose of auto-save is to provide a failsafe, and
  ;; disabling it contradicts this objective.
  (setq auto-save-include-big-deletions t)

  ;; Auto save options
  (setq kill-buffer-delete-auto-save-files t)
#+end_src
*** Auto revert
=Auto-revert= in Emacs is a feature that automatically updates the
contents of a buffer to reflect changes made to the underlying file
on disk.

#+begin_src emacs-lisp
  (setq revert-without-query (list ".")  ; Do not prompt
        auto-revert-stop-on-user-input nil
        auto-revert-verbose t)

  ;; Revert other buffers (e.g, Dired)
  (setq global-auto-revert-non-file-buffers t)
  (add-hook 'after-init-hook #'global-auto-revert-mode)
#+end_src
*** Recentf
=recentf= is an Emacs package that maintains a list of recently
accessed files, making it easier to reopen files you have worked on
recently.
#+begin_src emacs-lisp
  (setq recentf-max-saved-items 300) ; default is 20
  (setq recentf-auto-cleanup 'mode)
  (add-hook 'after-init-hook #'recentf-mode)
#+end_src
*** Save place
=save-place-mode= enables Emacs to remember the last location within a file
upon reopening. This feature is particularly beneficial for resuming work at
the precise point where you previously left off.
#+begin_src emacs-lisp
  (setq save-place-file (expand-file-name "saveplace" user-emacs-directory))
  (setq save-place-limit 600)
  (add-hook 'after-init-hook #'save-place-mode)
#+end_src
*** Frames and windows
#+begin_src emacs-lisp
                                          ; Resizing the Emacs frame can be costly when changing the font. Disable this
  ;; to improve startup times with fonts larger than the system default.
  (setq frame-resize-pixelwise t)

  ;; However, do not resize windows pixelwise, as this can cause crashes in some
  ;; cases when resizing too many windows at once or rapidly.
  (setq window-resize-pixelwise nil)

  (setq resize-mini-windows 'grow-only)
#+end_src
*** Scrolling
#+begin_src emacs-lisp
  ;; Enables faster scrolling through unfontified regions. This may result in
  ;; brief periods of inaccurate syntax highlighting immediately after scrolling,
  ;; which should quickly self-correct.
  (setq fast-but-imprecise-scrolling t)

  ;; Move point to top/bottom of buffer before signaling a scrolling error.
  (setq scroll-error-top-bottom t)

  ;; Keeps screen position if the scroll command moved it vertically out of the
  ;; window.
  (setq scroll-preserve-screen-position t)
#+end_src
*** Cursor
#+begin_src emacs-lisp
  (blink-cursor-mode -1)

  ;; Don't blink the paren matching the one at point, it's too distracting.
  (setq blink-matching-paren nil)
#+end_src
*** Annoyances
#+begin_src emacs-lisp
  ;; No beeping or blinking
  (setq visible-bell nil)
  (setq ring-bell-function #'ignore)

  ;; This controls how long Emacs will blink to show the deleted pairs with
  ;; `delete-pair'. A longer delay can be annoying as it causes a noticeable pause
  ;; after each deletion, disrupting the flow of editing.
  (setq delete-pair-blink-delay 0.03)
#+end_src
*** Indent and formatting
#+begin_src emacs-lisp
  (setq-default left-fringe-width  8)
  (setq-default right-fringe-width 8)

  ;; Do not show an arrow at the top/bottom the fringe and empty lines
  (setq-default indicate-buffer-boundaries nil)
  (setq-default indicate-empty-lines nil)

  ;; Continue wrapped lines at whitespace rather than breaking in the
  ;; middle of a word.
  (setq-default word-wrap t)

  ;; Prefer spaces over tabs. Spaces offer a more consistent default compared to
  ;; 8-space tabs. This setting can be adjusted on a per-mode basis as needed.
  (setq-default indent-tabs-mode nil
                tab-width 4)

  ;; Enable multi-line commenting which ensures that `comment-indent-new-line'
  ;; properly continues comments onto new lines, which is useful for writing
  ;; longer comments or docstrings that span multiple lines.
  (setq comment-multi-line t)

  ;; We often split terminals and editor windows or place them side-by-side,
  ;; making use of the additional horizontal space.
  (setq-default fill-column 80)

  ;; Disable the obsolete practice of end-of-line spacing from the
  ;; typewriter era.
  (setq sentence-end-double-space nil)

  ;; According to the POSIX, a line is defined as "a sequence of zero or
  ;; more non-newline characters followed by a terminating newline".
  (setq require-final-newline t)

  ;; Remove duplicates from the kill ring to reduce clutter
  (setq kill-do-not-save-duplicates t)

  ;; Ensures that empty lines within the commented region are also commented out.
  ;; This prevents unintended visual gaps and maintains a consistent appearance,
  ;; ensuring that comments apply uniformly to all lines, including those that are
  ;; otherwise empty.
  (setq comment-empty-lines t)

  ;; Eliminate delay before highlighting search matches
  (setq lazy-highlight-initial-delay 0)
#+end_src
*** Filetype
#+begin_src emacs-lisp
  ;; Do not notify the user each time Python tries to guess the indentation offset
  (setq python-indent-guess-indent-offset-verbose nil)

  (setq sh-indent-after-continuation 'always)

  (setq dired-clean-confirm-killing-deleted-buffers nil
        dired-recursive-deletes 'top
        dired-recursive-copies  'always
        dired-create-destination-dirs 'ask)
#+end_src
*** Font / text scale
#+begin_src emacs-lisp
  ;; Avoid automatic frame resizing when adjusting settings.
  (setq global-text-scale-adjust-resizes-frames nil)
#+end_src
*** Ediff
#+begin_src emacs-lisp
  ;; Configure Ediff to use a single frame and split windows horizontally
  (setq ediff-window-setup-function #'ediff-setup-windows-plain
        ediff-split-window-function #'split-window-horizontally)
#+end_src
** No littering
#+begin_src emacs-lisp
  (use-package no-littering
    :demand t
    :config
    (no-littering-theme-backups))
#+end_src
** Save history
#+begin_src emacs-lisp
  (use-package savehist :ensure nil
    :init
    (setq savehist-file "~/.config/emacs/var/savehist.el")
    :config
    (setq history-length 500)
    (setq savehist-additional-variables '(kill-ring search-ring))
    (savehist-mode t))
#+end_src
** Meow mode
#+begin_src emacs-lisp
  (use-package meow
    :config
    (defun meow-negative-find ()
      "Find text backward."
      (interactive)
      (let ((current-prefix-arg -1))
        (call-interactively #'meow-find)))

    (defun meow-negative-till ()
      "Find text backward."
      (interactive)
      (let ((current-prefix-arg -1))
        (call-interactively #'meow-till)))
    (defun meow-setup ()
      (setq meow-cheatsheet-layout meow-cheatsheet-layout-qwerty)
      (meow-motion-overwrite-define-key
       '("j" . meow-next)
       '("k" . meow-prev)
       '("<escape>" . ignore))
      (meow-leader-define-key
       ;; SPC j/k will run the original command in MOTION state.
       '("j" . "H-j")
       '("k" . "H-k")
       ;; Use SPC (0-9) for digit arguments.
       '("1" . meow-digit-argument)
       '("2" . meow-digit-argument)
       '("3" . meow-digit-argument)
       '("4" . meow-digit-argument)
       '("5" . meow-digit-argument)
       '("6" . meow-digit-argument)
       '("7" . meow-digit-argument)
       '("8" . meow-digit-argument)
       '("9" . meow-digit-argument)
       '("0" . meow-digit-argument)
       '("/" . meow-keypad-describe-key)
       '("?" . meow-cheatsheet)
       '("bk" . kill-this-buffer))
      (meow-normal-define-key
       '("0" . meow-expand-0)
       '("9" . meow-expand-9)
       '("8" . meow-expand-8)
       '("7" . meow-expand-7)
       '("6" . meow-expand-6)
       '("5" . meow-expand-5)
       '("4" . meow-expand-4)
       '("3" . meow-expand-3)
       '("2" . meow-expand-2)
       '("1" . meow-expand-1)
       '("-" . negative-argument)
       '(";" . meow-reverse)
       '("," . meow-inner-of-thing)
       '("." . meow-bounds-of-thing)
       '("[" . meow-beginning-of-thing)
       '("]" . meow-end-of-thing)
       '("a" . meow-append)
       '("A" . meow-open-below)
       '("b" . meow-back-word)
       '("B" . meow-back-symbol)
       '("c" . meow-change)
       '("d" . meow-delete)
       '("D" . meow-backward-delete)
       '("e" . meow-next-word)
       '("E" . meow-next-symbol)
       '("f" . meow-find)
       '("F" . meow-negative-find)
       '("g" . meow-cancel-selection)
       '("G" . meow-grab)
       '("h" . meow-left)
       '("H" . meow-left-expand)
       '("i" . meow-insert)
       '("I" . meow-open-above)
       '("j" . meow-next)
       '("J" . meow-next-expand)
       '("k" . meow-prev)
       '("K" . meow-prev-expand)
       '("l" . meow-right)
       '("L" . meow-right-expand)
       '("m" . meow-join)
       '("n" . meow-search)
       '("o" . meow-block)
       '("O" . meow-to-block)
       '("p" . meow-yank)
       '("q" . meow-quit)
       '("Q" . meow-goto-line)
       '("r" . meow-replace)
       '("R" . meow-swap-grab)
       '("s" . meow-kill)
       '("t" . meow-till)
       '("T" . meow-negative-till)
       '("u" . meow-undo)
       '("U" . meow-undo-in-selection)
       '("v" . meow-visit)
       '("w" . meow-mark-word)
       '("W" . meow-mark-symbol)
       '("x" . meow-line)
       '("X" . meow-goto-line)
       '("y" . meow-save)
       '("Y" . meow-sync-grab)
       '("z" . meow-pop-selection)
       '("'" . repeat)
       '("<escape>" . ignore)))
    (meow-setup)
    (meow-global-mode 1))
#+end_src
** General keybindings
#+begin_src emacs-lisp
  (use-package general
    :config
    ;; SPC as the global leader key
    (general-create-definer spl3g/leader-keys
      :prefix "C-c")

    (spl3g/leader-keys
      ;; Buffers
      "b" '(:ignore t :wk "Buffer")
      "bi" '(ibuffer :wk "ibuffer")
      "bk" '(kill-current-buffer :wk "Kill this buffer")
      "bn" '(next-buffer :wk "Next buffer")
      "bp" '(previous-buffer :wk "Previous buffer")
      "br" '(revert-buffer :wk "Reload buffer")
      "." '(find-file :wk "Find file")
      ;; Splits
      "w" '(:ignore t :wk "Splits")
      "wv" '(split-window-right :wk "Split vertical")
      "ws" '(split-window-below :wk "Split")
      "ww" '(other-window :wk "Cycle throug windows")
      "wc" '(delete-window :wk "Close window")
      "wd" '(delete-window :wk "Close window")
      "wl" '(windmove-right :wk "")
      "wj" '(windmove-down :wk "")
      "wk" '(windmove-up :wk "")
      "wh" '(windmove-left :wk "")
      "wo" '(delete-other-windows :wk "")
      ;; Files
      "f" '(:ignore t :wk "Files")
      "fc" '((lambda () (interactive) (find-file user-init-file)) :wk "Edit emacs config")
      ;; Compilation
      "r" '(recompile :wk "Recompile")
      ;; Open
      "o" '(:ignore t :wk "Open")
      "ot" '(my/open-eshell :wk "Open eshell")))
  (elpaca-wait)
#+end_src
** Which key
#+begin_src emacs-lisp
  (use-package which-key
    :ensure nil
    :init
    (which-key-mode))
#+end_src
* GUI tweaks
** Disable gui shit
#+begin_src emacs-lisp
  (defun spl3g/disable-scroll-bars (frame)
    (modify-frame-parameters frame
                             '((vertical-scroll-bars . nil)
                               (horizontal-scroll-bars . nil))))
  (add-hook 'after-make-frame-functions 'spl3g/disable-scroll-bars)
#+end_src
** Fonts
#+begin_src emacs-lisp
  (set-face-attribute 'default nil
                      :font "FiraCode Nerd Font"
                      :height 110
                      :weight 'medium)
  (set-face-attribute 'fixed-pitch nil
                      :font "FiraCode Nerd Font"
                      :height 110
                      :weight 'medium)
  (set-face-attribute 'variable-pitch nil
                      :font "Noto Serif"
                      :height 110
                      :weight 'medium)
  (set-face-attribute 'font-lock-comment-face nil
                      :slant 'italic)
  (set-face-attribute 'font-lock-keyword-face nil
                      :weight 'bold)
#+end_src
** Display line numbers
#+begin_src emacs-lisp
  (add-hook 'prog-mode-hook 'display-line-numbers-mode)
  (visual-line-mode 1)
#+end_src
** Icons
#+begin_src emacs-lisp
  (use-package all-the-icons
    :defer t
    :ensure t
    :if (display-graphic-p))
#+end_src
** Modeline
#+begin_src emacs-lisp
  (defvar after-load-theme-hook nil
    "Hook run after a color theme is loaded using `load-theme'.")
  (defadvice load-theme (after run-after-load-theme-hook activate)
    "Run `after-load-theme-hook'."
    (run-hooks 'after-load-theme-hook))

  (defadvice consult-theme (after run-after-load-theme-hook activate)
    "Run `after-load-theme-hook'."
    (run-hooks 'after-load-theme-hook))

  (defun widen-mode-line ()
    "Widen the mode-line."
    (interactive)
    (set-face-attribute 'mode-line nil
                        :inherit 'mode-line
                        :box '(:line-width 8 :style flat-button))
    (set-face-attribute 'mode-line-inactive nil
                        :inherit 'mode-line-inactive
                        :box '(:line-width 8 :style flat-button)))

  (add-hook 'after-load-theme-hook 'widen-mode-line)

  (use-package mood-line
    ;; Enable mood-line
    :config
    (mood-line-mode)
    :custom
    (mood-line-segment-modal-meow-state-alist
     '((normal "N" . mood-line-meow-normal)
       (insert "I" . mood-line-meow-insert)
       (keypad "K" . mood-line-meow-keypad)
       (beacon "B" . mood-line-meow-beacon)
       (motion "M" . mood-line-meow-motion)))
    (mood-line-glyph-alist mood-line-glyphs-fira-code)
    :custom-face
    (mood-line-meow-beacon ((t (:inherit 'font-lock-function-name-face :weight bold))))
    (mood-line-meow-insert ((t (:inherit 'font-lock-string-face :weight bold))))
    (mood-line-meow-keypad ((t (:inherit 'font-lock-keyword-face :weight bold))))
    (mood-line-meow-motion ((t (:inherit 'font-lock-constant-face :weight bold))))
    (mood-line-meow-normal ((t (:inherit 'font-lock-variable-use-face :weight bold)))))
#+end_src
** Scroll
#+begin_src emacs-lisp
  (setq scroll-margin 5
        scroll-conservatively 101
        mouse-wheel-progressive-speed nil)
#+end_src
** Indent guide
#+begin_src emacs-lisp
  (use-package indent-guide
    :hook (prog-mode . indent-guide-mode))
#+end_src
* Org mode
#+begin_src emacs-lisp
    (use-package org-mode :ensure nil
      :custom
      (text-mode-ispell-word-completion nil)
      (org-hide-emphasis-markers t)
      (org-startup-indented t)
      :mode "\\.org\\'")
#+end_src
** Org modern
#+begin_src emacs-lisp
  (use-package org-modern
    :ghook 'org-mode-hook)
#+end_src
*** Modern Indent
#+begin_src emacs-lisp
  (use-package org-modern-indent
    :ensure (:host github :repo "jdtsmith/org-modern-indent")
    :hook
    (org-modern-mode . org-modern-indent-mode))
#+end_src
** TOC
#+begin_src emacs-lisp
  (use-package toc-org
    :ghook 'org-mode-hook)
#+end_src
** Requests from org-mode
#+begin_src emacs-lisp
  (use-package verb
    :hook (org-mode . verb-mode)
    :general (:keymaps 'org-mode-map
                       "C-c C-r" verb-command-map))
#+end_src
* Better UX
** Vertico
#+begin_src emacs-lisp
  (use-package vertico
    :init
    (vertico-mode)
    :general
    (:keymaps 'vertico-map
              "M-j" 'vertico-next
              "M-k" 'vertico-previous
              "RET" 'vertico-directory-enter
              "DEL" 'vertico-directory-delete-char
              "M-DEL" 'vertico-directory-delete-word))

  (use-package emacs :ensure nil
    :init
    ;; Add prompt indicator to `completing-read-multiple'.
    ;; We display [CRM<separator>], e.g., [CRM,] if the separator is a comma.
    (defun crm-indicator (args)
      (cons (format "[CRM%s] %s"
                    (replace-regexp-in-string
                     "\\`\\[.*?]\\*\\|\\[.*?]\\*\\'" ""
                     crm-separator)
                    (car args))
            (cdr args)))
    (advice-add #'completing-read-multiple :filter-args #'crm-indicator)

    ;; Do not allow the cursor in the minibuffer prompt
    (setq minibuffer-prompt-properties
          '(read-only t cursor-intangible t face minibuffer-prompt))
    (add-hook 'minibuffer-setup-hook #'cursor-intangible-mode)

    ;; Emacs 28: Hide commands in M-x which do not work in the current mode.
    ;; Vertico commands are hidden in normal buffers.
    ;; (setq read-extended-command-predicate
    ;;       #'command-completion-default-include-p)

    ;; Enable recursive minibuffers
    (setq enable-recursive-minibuffers t))
#+end_src
*** Marginalia
#+begin_src emacs-lisp
  (use-package marginalia
    :bind (:map minibuffer-local-map
                ("M-A" . marginalia-cycle))
    :init
    (marginalia-mode))
#+end_src
** Consult
#+begin_src emacs-lisp
  (use-package consult
    :general
    ;; my binds
    (:prefix "C-c"
             "f r" 'consult-recent-file
             "," 'consult-buffer
             "os" 'my/select-eshell)

    ;; general
    (:prefix "C-c"
             "k" 'consult-kmacro
             "m" 'consult-man
             "i" 'consult-info)

    ;; one lonely command that i dont use
    (:prefix "C-x"
             "M-:" 'consult-complex-command)

    ;; 'registers' and pop
    ("M-#" 'consult-register-load
     "M-'" 'consult-register-store
     "M-y" 'consult-yank-pop)

    ;; 'goto'
    (:prefix "M-g"
             "" '(:ignore t :wk "consult goto")
             "c" 'consult-compile-error
             "f" 'consult-goto-line
             "M-g" 'consult-goto-line
             "o" 'consult-outline
             "I" 'consult-imenu)

    ;; 'search'
    (:prefix "M-s"
             "" '(:ignore t :wk "consult search")
             "d" 'consult-fd
             "r" 'consult-ripgrep
             "g" 'consult-git-grep
             "l" 'consult-line
             "L" 'consult-line-multi
             "k" 'consult-keep-lines
             "u" 'consult-focus-lines
             "e" 'consult-isearch-history)

    ;; Isearch
    (:prefix "M-s" :keymaps 'isearch-mode-map
             "e" 'consult-isearch-history
             "l" 'consult-line
             "L" 'consult-line-multi)
    (:keymaps 'isearch-mode-map
              "M-e" 'consult-isearch-history
              "M-r" 'consult-history)

    ;; Minibuffer history
    (:keymaps 'minibufer-local-map
              "M-s" 'consult-history
              "M-r" 'consult-history)
    :hook
    (completion-list-mode . consult-preview-at-point-mode)

    :init
    (setq register-preview-delay 0
          register-preview-function #'consult-register-format)

    (advice-add #'register-preview :override #'consult-register-window)

    :config
    (defun my/select-eshell ()
      (interactive)
      (let* ((eshell-buffers (consult--buffer-query :sort 'visibility
                                                    :as 'consult--buffer-pair
                                                    :mode 'eshell-mode))
             (eshell-windows (remove nil (mapcar (lambda (buffer)
                                                   (let* ((b (cdr buffer))
                                                          (window (get-buffer-window b))
                                                          (name (buffer-name b)))
                                                     (when window
                                                       (cons
                                                        name
                                                        window))))
                                                 eshell-buffers)))
             (selected-buffer (consult--read
                               eshell-buffers
                               :category 'buffer
                               :history  'buffer-name-history
                               :lookup 'consult--lookup-cdr))
             (selected-window (if (length> eshell-windows 1)
                                  (consult--read
                                   eshell-windows
                                   :lookup 'consult--lookup-cdr)
                                (cdar eshell-windows))))
        (if selected-window
            (progn
              (select-window selected-window)
              (switch-to-buffer selected-buffer))
          (switch-to-buffer-other-window selected-buffer))))

    (consult-customize
     consult-theme :preview-key '(:debounce 0.2 any)
     consult-ripgrep consult-git-grep consult-grep
     consult-bookmark consult-recent-file consult-xref
     consult--source-bookmark consult--source-file-register
     consult--source-recent-file consult--source-project-recent-file
     ;; :preview-key "M-."
     :preview-key '(:debounce 0.4 any))
    (setq consult-narrow-key "C-+"))

#+end_src
** Embark
#+begin_src emacs-lisp
  (use-package embark
    :bind
    (("C-." . embark-act)         ;; pick some comfortable binding
     ("C-;" . embark-dwim)        ;; good alternative: M-.
     ("C-h B" . embark-bindings)) ;; alternative for `describe-bindings'

    :init

    ;; Optionally replace the key help with a completing-read interface
    (setq prefix-help-command #'embark-prefix-help-command)

    ;; Show the Embark target at point via Eldoc. You may adjust the
    ;; Eldoc strategy, if you want to see the documentation from
    ;; multiple providers. Beware that using this can be a little
    ;; jarring since the message shown in the minibuffer can be more
    ;; than one line, causing the modeline to move up and down:

    ;; (add-hook 'eldoc-documentation-functions #'embark-eldoc-first-target)
    ;; (setq eldoc-documentation-strategy #'eldoc-documentation-compose-eagerly)

    :config

    ;; Hide the mode line of the Embark live/completions buffers
    (add-to-list 'display-buffer-alist
                 '("\\`\\*Embark Collect \\(Live\\|Completions\\)\\*"
                   nil
                   (window-parameters (mode-line-format . none)))))

  ;; Consult users will also want the embark-consult package.
  (use-package embark-consult
    :hook (embark-collect-mode . consult-preview-at-point-mode))
#+end_src

** Pairs
#+begin_src emacs-lisp
  (electric-pair-mode t)
#+end_src
** Debugging
#+begin_src emacs-lisp
  (use-package jsonrpc)
  (use-package dape
    :commands dape
    :after jsonrpc
    :config
    (setq dape-cwd-fn 'projectile-project-root))
#+end_src
** Truncate lines
#+begin_src emacs-lisp
  (global-visual-line-mode t)
#+end_src
** Rainbow delimiters
#+begin_src emacs-lisp
  (use-package rainbow-delimiters
    :hook (prog-mode . rainbow-delimiters-mode))
#+end_src
** Better *help*
#+begin_src emacs-lisp
  (use-package helpful
    :bind (("C-h f" . helpful-callable)
           ("C-h v" . helpful-variable)
           ("C-h k" . helpful-key)
           ("C-h x" . helpful-command)
           ("C-c C-d" . helpful-at-point)
           ("C-h F" . helpful-function)))
#+end_src
** Better other-window
#+begin_src emacs-lisp
  (use-package ace-window
    :custom
    (aw-keys '(?h ?j ?k ?l ?g ?a ?s ?d ?f))
    (aw-scope 'frame)
    :bind (("M-o" . ace-window)
           ("C-c w w" . ace-window)))
#+end_src
** Undo Tree
#+begin_src emacs-lisp
  (use-package undo-tree
    :init
    (global-undo-tree-mode))
#+end_src
** Dumb jump
#+begin_src emacs-lisp
  (use-package dumb-jump
    :hook (xref-backend-functions . dumb-jump-xref-activate))
#+end_src
** Command sorting and filtering
#+begin_src emacs-lisp
  (use-package prescient
    :config
    (prescient-persist-mode)
    (setq completion-styles '(prescient basic)
          completion-category-overrides '((file (styles basic partial-completion))))
    :custom-face
    (prescient-primary-highlight ((t (:inherit 'font-lock-keyword-face)))))
  (use-package corfu-prescient
    :after corfu
    :config
    (corfu-prescient-mode))
  (use-package vertico-prescient
    :after vertico
    :config
    (vertico-prescient-mode))
#+end_src
** Multiple Cursors
#+begin_src emacs-lisp 
  (use-package multiple-cursors
    :defer t
    :config
    (global-set-key (kbd "C-S-c C-S-c") 'mc/edit-lines)
    (global-set-key (kbd "C->") 'mc/mark-next-like-this)
    (global-set-key (kbd "C-<") 'mc/mark-previous-like-this)
    (global-set-key (kbd "C-c C-<") 'mc/mark-all-like-this))
#+end_src
* Eshell
#+begin_src emacs-lisp
  (add-hook 'eshell-mode-hook
            (lambda ()
              (setq-local corfu-auto nil)))
  (add-hook 'eshell-exec-hook (lambda (p)
                                (buffer-disable-undo)))
  (add-hook 'eshell-kill-hook (lambda (p s)
                                (buffer-enable-undo)))
  (setq eshell-history-size 500
        eshell-history-append t)
#+end_src
** Open eshell
#+begin_src emacs-lisp
  (defun my/open-eshell ()
    (interactive)
    (defvar current-prefix-arg)
    (let* ((project (project-current))
           (func (if project
                     'project-eshell
                   'eshell))
           (buffer-name (if project
                            (format "*%s-eshell*" (project-name project))
                          "*eshell*"))
           (current-prefix-arg t))
      (if (not (get-buffer buffer-name))
          (let ((buf (funcall func)))
            (switch-to-buffer (other-buffer buf))
            (switch-to-buffer-other-window buf))
        (switch-to-buffer-other-window buffer-name))))
#+end_src
** Fish completions
#+begin_src emacs-lisp
  (use-package fish-completion
    :hook (eshell-mode . fish-completion-mode))
#+end_src
** Eat
#+begin_src emacs-lisp
  (use-package eat
    :hook
    (eshell-mode . eat-eshell-mode)
    :custom
    (eat-enable-auto-line-mode t)
    :custom-face
    (ansi-color-bright-blue ((t (:inherit 'ansi-color-blue))))
    (ansi-color-bright-red ((t (:inherit 'ansi-color-red))))
    (ansi-color-bright-red ((t (:inherit 'ansi-color-red))))
    (ansi-color-bright-cyan ((t (:inherit 'ansi-color-cyan))))
    (ansi-color-bright-black ((t (:inherit 'ansi-color-black))))
    (ansi-color-bright-green ((t (:inherit 'ansi-color-green))))
    (ansi-color-bright-white ((t (:inherit 'ansi-color-white))))
    (ansi-color-bright-yellow ((t (:inherit 'ansi-color-yellow))))
    (ansi-color-bright-magenta ((t (:inherit 'ansi-color-magenta)))))
#+end_src
** Highlighting
#+begin_src emacs-lisp
  (use-package eshell-syntax-highlighting
    :hook (eshell-mode . eshell-syntax-highlighting-mode))
#+end_src
* LSP
#+begin_src emacs-lisp
  (use-package lsp-mode
    :custom
    (lsp-completion-provider :none)
    (lsp-enable-suggest-server-download nil)
    (lsp-keymap-prefix "C-c s")
    :init
    (defun lsp-mode-setup-completion ()
      (setf (alist-get 'styles (alist-get 'lsp-capf completion-category-defaults))
            '(prescient)))

    :hook
    (lsp-completion-mode . lsp-mode-setup-completion)
    (nix-mode . lsp-mode)
    (typescript-ts-mode . lsp-mode)
    (go-ts-mode . lsp-mode)
    (web-mode . lsp-mode))
#+end_src
*** LSP UI things
#+begin_src emacs-lisp
      (use-package lsp-ui
        :hook (lsp-mode . lsp-ui-mode)
        :bind (:map lsp-ui-mode-map
                    ([remap xref-find-definitions] . lsp-ui-peek-find-definitions)
                    ([remap xref-find-references] . lsp-ui-peek-find-references))
        :custom
        (lsp-ui-doc-enable nil))
#+end_src
** Error checking
#+begin_src emacs-lisp
  (use-package flycheck
    :init
    (global-flycheck-mode)
    :config
    (add-to-list 'display-buffer-alist
                 '("\\*Flycheck"
                   (display-buffer-reuse-window display-buffer-at-bottom)
                   (reusable-frames . visible)
                   (window-height . 0.35))))
#+end_src
** Corfu
#+begin_src emacs-lisp
  (use-package corfu
    :hook (emacs-startup . global-corfu-mode)
    :bind (:map corfu-map
                ("M-j" . corfu-next)
                ("M-k" . corfu-previous)
                ([remap previous-line] . nil)
                ([remap next-line] . nil))
    :custom
    (corfu-preselect 'prompt)
    (corfu-auto t)
    (corfu-popupinfo-delay 0.5)
    (corfu-auto-delay 0.1)
    (corfu-auto-prefix 2)
    (corfu-count 16)
    (corfu-max-width 120)
    (corfu-scroll-margin 4)
    (corfu-on-exact-match nil)
    (tab-always-indent 'complete)
    :config
    (global-corfu-mode)
    (corfu-popupinfo-mode))
#+end_src
*** Cape
#+begin_src emacs-lisp
  (use-package cape
    :after corfu
    :custom
    (dabbrev-ignored-buffer-modes '(archive-mode image-mode eshell-mode))
    :config
    (advice-add #'lsp-completion-at-point :around #'cape-wrap-noninterruptible)
    (advice-add #'lsp-completion-at-point :around #'cape-wrap-nonexclusive)
    (add-to-list 'completion-at-point-functions #'cape-dabbrev)
    (add-to-list 'completion-at-point-functions #'cape-file)
    (add-to-list 'completion-at-point-functions #'cape-elisp-block))
#+end_src
** Tree-sitter
#+begin_src emacs-lisp
  (use-package treesit-auto
    :custom
    (treesit-auto-install 'prompt)
    :config
    (treesit-auto-add-to-auto-mode-alist 'all)
    (global-treesit-auto-mode))
#+end_src
** Snippets
#+begin_src emacs-lisp
  (use-package tempel
    :general (:keymaps 'tempel-map
                       "M-TAB" 'tempel-next)
    :custom
    (tempel-trigger-prefix "<")
    :init
    (add-to-list 'completion-at-point-functions #'tempel-complete))
  (use-package tempel-collection
    :ensure t
    :after tempel)
#+end_src
** Formatting
#+begin_src emacs-lisp
  (use-package apheleia
    :ghook 'prog-mode-hook)
#+end_src
** Languages
*** Python
#+begin_src emacs-lisp
  (use-package lsp-pyright
    :after lsp)
#+end_src
*** Rust
#+begin_src emacs-lisp
  (use-package rust-mode
    :mode "\\.rs\\'")
  ;; (use-package cargo-mode
  ;;   :after rust-mode
  ;;   :hook
  ;;   (rust-ts-mode . cargo-minor-mode)
  ;;   :config
  ;;   (setq compilation-scroll-output t))
#+end_src
*** Fish
#+begin_src emacs-lisp
  (use-package fish-mode
    :mode "\\.fish\\'")
#+end_src
*** Nix
#+begin_src emacs-lisp
  (use-package nix-mode
    :mode ("\\.nix\\'" "\\.nix.in\\'"))
#+end_src
*** Web
#+begin_src emacs-lisp
  (use-package web-mode
    :mode
    ("\\.html\\'"
     "\\.phtml\\'"
     "\\.tpl\\.php\\'"
     "\\.[agj]sp\\'"
     "\\.as[cp]x\\'"
     "\\.erb\\'"
     "\\.mustache\\'"
     "\\.djhtml\\'")
    :hook (eb-mode . (lambda () (electric-pair-local-mode -1))))
  ;; (use-package emmet-mode
  ;;   :ghook 'web-mode)
#+end_src
*** TypeScript
#+begin_src emacs-lisp
  (use-package typescript-ts-mode
    :defer t
    :ensure nil
    :custom
    (typescript-ts-mode-indent-offset tab-width))
#+end_src
*** Odin
#+begin_src emacs-lisp
  (use-package odin-mode
    :ensure (:repo "https://git.sr.ht/~mgmarlow/odin-mode")
    :bind (:map odin-mode-map
                ("C-c C-r" . 'odin-run-project)
                ("C-c C-c" . 'odin-build-project)
                ("C-c C-t" . 'odin-test-project))
    :mode "\\.odin\\'"
    :config
    (with-eval-after-load 'lsp-mode
      (add-to-list 'lsp-language-id-configuration '(odin-mode . "odin"))

      (lsp-register-client (make-lsp-client
                            :new-connection (lsp-stdio-connection "ols")
                            :activation-fn (lsp-activate-on "odin")
                            :server-id 'ols))))

#+end_src
*** Gleam
#+begin_src emacs-lisp
  (use-package gleam-ts-mode
    :ensure (:host github :repo "gleam-lang/gleam-mode" :branch "gleam-ts-mode")
    :mode "\\.gleam\\'"
    :config
    (with-eval-after-load 'lsp-mode
      (add-to-list 'lsp-language-id-configuration '(gleam-ts-mode . "gleam"))

      (lsp-register-client (make-lsp-client
                            :new-connection (lsp-stdio-connection '("glas" "--stdio"))
                            :activation-fn (lsp-activate-on "gleam")
                            :server-id 'glas))))
#+end_src
*** Go
#+begin_src emacs-lisp
  (use-package go-ts-mode
    :defer t
    :ensure nil
    :custom
    (go-ts-mode-indent-offset tab-width))
#+end_src
** Direnv
#+begin_src emacs-lisp
  (use-package direnv
    :config
    (direnv-mode))
#+end_src
** Better scratch
#+begin_src emacs-lisp
  (use-package scratch
    :commands scratch)
#+end_src
* Dired
** Bindings
#+begin_src emacs-lisp
  (use-package dired :ensure nil
    :ensure nil
    :commands (dired dired-jump)
    :bind (:map dired-mode-map
                ("h" . dired-up-directory)
                ("l" . dired-find-file))
    :custom
    (dired-listing-switches "-hal --group-directories-first")
    (dired-dwim-target t))
#+end_src
** Media files
#+begin_src emacs-lisp
  (use-package ready-player
    :custom
    (ready-player-set-global-bindings nil)
    :after dired
    :config
    (ready-player-mode))
#+end_src
** Casual dired
#+begin_src emacs-lisp
    (use-package casual-dired
      :after dired
      :bind (:map dired-mode-map
                  ("C-o" . #'casual-dired-tmenu)
                  ("s" . #'casual-dired-sort-by-tmenu)
                  ("/" . #'casual-dired-search-replace-tmenu)))
#+end_src
* Sql
#+begin_src emacs-lisp
  (use-package sql-indent
    :hook (sql-mode . sqlind-minor-mode))

  (setq sql-connection-alist
        '(("postgres-sirius"
           (sql-product 'postgres)
           (sql-user "sirius_2024")
           (sql-password "changed")
           (sql-server "127.0.0.1")
           (sql-database "postgres")
           (sql-port 38746))))

  (setq sql-sqlite-program "sqlite3")
#+end_src
* Additional apps
*** Casual calc
#+begin_src emacs-lisp
  (use-package casual-calc
    :bind (:map
           calc-mode-map
           ("C-o" . casual-calc-tmenu)
           :map
           calc-alg-map
           ("C-o" . casual-calc-tmenu))
    :after (calc))
#+end_src
** Magit
#+begin_src emacs-lisp
  (use-package transient)
  (use-package magit
    :after transient
    :bind (("C-c o g" . magit)))
#+end_src