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

* Table Of Contents :toc:
- [[#progs-to-load-first][Progs to load first]]
  - [[#optimisations][Optimisations]]
  - [[#elpaca][elpaca]]
  - [[#native-comp-warnings][Native comp warnings]]
  - [[#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]]
  - [[#theme][Theme]]
  - [[#icons][Icons]]
  - [[#modeline][Modeline]]
  - [[#scroll][Scroll]]
  - [[#dashboard][Dashboard]]
  - [[#disable-ring-bell][Disable ring-bell]]
  - [[#indent-guide][Indent guide]]
  - [[#misc][Misc]]
- [[#projects][Projects]]
- [[#org-mode][Org mode]]
  - [[#org-modern][Org modern]]
  - [[#enabling-toc][Enabling toc]]
  - [[#org-bullets][Org bullets]]
- [[#better-ux][Better UX]]
  - [[#vertico][Vertico]]
  - [[#consult][Consult]]
  - [[#embark][Embark]]
  - [[#pairs][Pairs]]
  - [[#debugging][Debugging]]
  - [[#truncate-lines][Truncate lines]]
  - [[#rainbow-delimiters][Rainbow delimiters]]
  - [[#crux][Crux]]
  - [[#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]]
  - [[#fish-completions][Fish completions]]
  - [[#eat][Eat]]
  - [[#highlighting][Highlighting]]
- [[#lsp][LSP]]
  - [[#flycheck][Flycheck]]
  - [[#lsp-ui][lsp-ui]]
  - [[#lsp-booster][LSP-booster]]
  - [[#corfu][Corfu]]
  - [[#tree-sitter][Tree-sitter]]
  - [[#snippets][Snippets]]
  - [[#formatting][Formatting]]
  - [[#languages][Languages]]
  - [[#direnv][Direnv]]
  - [[#better-scratch][Better scratch]]
- [[#dired][Dired]]
  - [[#bindings][Bindings]]
  - [[#dired-hacks][Dired hacks]]
  - [[#dired-quick-sort][Dired quick sort]]
  - [[#async-copy][Async copy]]
  - [[#media-files][Media files]]
- [[#sql][Sql]]
- [[#additional-apps][Additional apps]]
  - [[#magit][Magit]]
  - [[#jupyter][Jupyter]]
  - [[#orgnote][Orgnote]]
  - [[#copilot][Copilot]]
  - [[#dash][Dash]]
  - [[#gptel][gptel]]

* Progs to load first
** Optimisations
#+begin_src emacs-lisp
  (setq gc-cons-threshold 100000000)
  (setq read-process-output-max (* 1024 1024))
#+end_src
** elpaca
#+begin_src emacs-lisp
  (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)
#+end_src
** Native comp warnings
#+begin_src emacs-lisp
 (setq native-comp-async-report-warnings-errors nil)
#+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
    :demand t
    :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-this-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 "~/.config/emacs/config.org")) :wk "Edit emacs config")
      "fu" '(crux-sudo-edit :wk "Sudo edit file")
      ;; Compilation
      "r" '(recompile :wk "Recompile")))
  (elpaca-wait)
#+end_src
** Which key
#+begin_src emacs-lisp
  (use-package which-key
    :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
  (setq default-frame-alist '((font . "Sauce Code Pro Nerd Font")))
  (set-face-attribute 'default nil
		      :font "SauceCodePro Nerd Font"
		      :height 110
		      :weight 'medium)
  (set-face-attribute 'fixed-pitch nil
		      :font "SauceCodePro Nerd Font"
		      :height 110
		      :weight 'medium)
  (set-face-attribute 'variable-pitch nil
		      :font "Rubik"
		      :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

** Theme
#+begin_src emacs-lisp
  ;; (use-package catppuccin-theme
  ;;   :config
  ;;   ;; (setq catppuccin-flavor 'macchiato)
  ;;   (load-theme 'catppuccin t))
  ;; (use-package monokai-pro-theme
  ;;   :config
  ;;   (load-theme 'monokai-pro-octagon t))
#+end_src
** Icons
#+begin_src emacs-lisp
  (use-package all-the-icons
    :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

** Dashboard
#+begin_src emacs-lisp
      (use-package dashboard
        :init
        (dashboard-setup-startup-hook)
        :config
        (setq initial-buffer-choice (lambda () (get-buffer-create "*dashboard*")))
        (setq dashboard-banner-logo-title "Yep, it's emacs, not vim")
        (setq dashboard-startup-banner 'official)
        (setq dashboard-center-content t)
        (setq dashboard-items '((projects . 5)
                                (recents . 5)
                                (bookmarks . 5)
                                (registers . 5))))
#+end_src
** Disable ring-bell
#+begin_src emacs-lisp
  (setq ring-bell-function 'ignore)
#+end_src
** Indent guide
#+begin_src emacs-lisp
  (use-package indent-guide
    :hook (prog-mode . indent-guide-mode))
#+end_src
** Misc
#+begin_src emacs-lisp
  (setq window-resize-pixelwise t)
  (setq frame-resize-pixelwise t)
  (save-place-mode t)
  (defalias 'yes-or-no #'y-or-n-p)
#+end_src
* Projects
#+begin_src emacs-lisp
  (use-package projectile
    :init
    (projectile-mode)
    :config
    (define-key projectile-mode-map (kbd "C-c p") 'projectile-command-map))
#+end_src
* Org mode
#+begin_src emacs-lisp
  (add-hook 'org-mode-hook 'org-indent-mode)
  (require 'org-tempo)
  (use-package org-mode :ensure nil
    :mode "\\.org\\'")
#+end_src
** Org modern
#+begin_src emacs-lisp
  (use-package org-modern
    :ghook 'org-mode-hook)
#+end_src
** Enabling toc
#+begin_src emacs-lisp
  (use-package toc-org
    :ghook 'org-mode-hook)
#+end_src
** Org bullets
#+begin_src emacs-lisp
  (use-package org-bullets
    :ghook 'org-mode-hook)
#+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
*** Ordeless
#+begin_src emacs-lisp
  (use-package orderless)
#+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)

    ;; 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)

    ;; '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)
    (eshell-mode . (lambda ()
                     (keymap-set eshell-mode-map "M-h" 'consult-history)))

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

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

    :config
    (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
*** Consult-lsp
#+begin_src emacs-lisp
  (use-package consult-lsp
    :after consult lsp
    :general
    (:keymaps 'lsp-mode-map :prefix "M-g"
              "f" 'consult-lsp-diagnostics
              "s" 'consult-lsp-symbols
              "S" 'consult-lsp-file-symbols))
#+end_src
*** Consult-dir
#+begin_src emacs-lisp
  (use-package consult-dir
    :ensure t
    :general
    (:prefix "C-x" :keymaps 'vertico-map
             "C-d" '('consult-dir :keymaps nil)
             "C-d" 'consult-dir
             "C-j" 'consult-dir-jump-file))
#+end_src
** Embark
#+begin_src emacs-lisp
  (use-package embark
    :ensure t

    :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
    :ensure t ; only need to install it, embark loads it after consult if found
    :hook config.el
    (embark-collect-mode . consult-preview-at-point-mode))
#+end_src
** Pairs
#+begin_src emacs-lisp
  (electric-pair-mode t)
  (defun my/disable-puni-in-minibuffer ()
    "Disable `puni-mode' in minibuffer unless when eval-expression"
    (unless (eq this-command 'eval-expression)
      (puni-disable-puni-mode)))
  (use-package puni
    :hook
    (minibuffer-setup . my/disable-puni-in-minibuffer)
    :config
    (puni-global-mode))
#+end_src
** Debugging
#+begin_src emacs-lisp
  (use-package jsonrpc)
  (use-package 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
** Crux
#+begin_src emacs-lisp
  (use-package crux
    :bind (("C-c o t" . crux-visit-shell-buffer)))
#+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
    :bind (("C-x o" . ace-window)
           ("C-c w w" . ace-window)))
#+end_src
** Undo Tree
#+begin_src emacs-lisp
  (use-package undo-tree
    :config
    (global-undo-tree-mode))
#+end_src
** Dumb jump
#+begin_src emacs-lisp
  (use-package dumb-jump
    :config
    (add-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)
    :custom-face
    (prescient-primary-highlight ((t (:inherit 'orderless-match-face-0)))))
    (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
    :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)
                  (corfu-mode)))
      (add-to-list 'display-buffer-alist
                   '("*eshell*"
                     (display-buffer-reuse-window display-buffer-at-bottom)
                     (window-height . 0.35)))
      (add-hook 'eshell-exec-hook (lambda (p)
                                    (buffer-disable-undo)))
      (add-hook 'eshell-kill-hook (lambda (p s)
                                    (buffer-enable-undo)))
#+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))
#+end_src
** Highlighting
#+begin_src emacs-lisp
  (use-package eshell-syntax-highlighting
    :config
    (eshell-syntax-highlighting-global-mode 1))
#+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))
            '(orderless)))

    :hook
    (lsp-completion-mode . lsp-mode-setup-completion)
    (prog-mode . lsp-mode))
#+end_src
** Flycheck
#+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
** lsp-ui
#+begin_src emacs-lisp
  (use-package lsp-ui
    :custom
    (lsp-ui-doc-show-with-mouse nil))
#+end_src
** LSP-booster
#+begin_src emacs-lisp
  (defun lsp-booster--advice-json-parse (old-fn &rest args)
    "Try to parse bytecode instead of json."
    (or
     (when (equal (following-char) ?#)
       (let ((bytecode (read (current-buffer))))
	 (when (byte-code-function-p bytecode)
	   (funcall bytecode))))
     (apply old-fn args)))
  (advice-add (if (progn (require 'json)
			 (fboundp 'json-parse-buffer))
		  'json-parse-buffer
		'json-read)
	      :around
	      #'lsp-booster--advice-json-parse)

  (defun lsp-booster--advice-final-command (old-fn cmd &optional test?)
    "Prepend emacs-lsp-booster command to lsp CMD."
    (let ((orig-result (funcall old-fn cmd test?)))
      (if (and (not test?)                             ;; for check lsp-server-present?
	       (not (file-remote-p default-directory)) ;; see lsp-resolve-final-command, it would add extra shell wrapper
	       lsp-use-plists
	       (not (functionp 'json-rpc-connection))  ;; native json-rpc
	       (executable-find "emacs-lsp-booster"))
	  (progn
	    (message "Using emacs-lsp-booster for %s!" orig-result)
	    (cons "emacs-lsp-booster" orig-result))
	orig-result)))
  (advice-add 'lsp-resolve-final-command :around #'lsp-booster--advice-final-command)
#+end_src
** Corfu
#+begin_src emacs-lisp
  (use-package corfu
    :bind (:map corfu-map
		("M-j" . corfu-next)
		("M-k" . corfu-previous))
    :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)
    :init
    (global-corfu-mode)
    (corfu-popupinfo-mode))

#+end_src
*** Cape
#+begin_src emacs-lisp
  (use-package cape
    :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
*** Additional langs
#+begin_src emacs-lisp
  (use-package tree-sitter-langs) 
#+end_src
** Snippets
#+begin_src emacs-lisp
  (use-package tempel
   :general (:keymaps 'tempel-map
                       "M-TAB" 'tempel-next)
    :custom
    (tempel-trigger-prefix "<")
    :config
    (add-to-list 'completion-at-point-functions #'tempel-complete))
  (use-package tempel-collection
    :ensure t
    :after tempel)
  (use-package yasnippet)
  (use-package yasnippet-snippets
    :after yasnippet)
  (use-package yasnippet-capf
    :config
    (add-to-list 'completion-at-point-functions #'yasnippet-capf))
#+end_src
** Formatting
#+begin_src emacs-lisp
  (use-package apheleia
    :config
    (apheleia-global-mode +1))
#+end_src
** Languages
*** Go
#+begin_src emacs-lisp
  (use-package go-ts-mode
    :ensure nil
    :hook (go-ts-mode . (lambda () (yas-minor-mode-on))))
#+end_src
*** Python
#+begin_src emacs-lisp
  (use-package py-autopep8
    :hook (python-mode . py-autopep8-mode))
  (use-package lsp-pyright)
#+end_src
*** Rust
#+begin_src emacs-lisp
  (use-package rust-mode
    :mode "\\.rs\\'")
  (use-package cargo-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\\'"))
  ;; (use-package nix-drv-mode :elpaca nil
  ;;   :ensure nix-mode
  ;;   :mode "\\.drv\\'")
  ;; (use-package nix-shell :elpaca nil
  ;;   :ensure nix-mode
  ;;   :commands (nix-shell-unpack nix-shell-configure nix-shell-build))
  ;; (use-package nix-repl :elpaca nil
  ;;   :ensure nix-mode
#+end_src
*** Web
#+begin_src emacs-lisp
  (use-package web-mode
    :mode
    ("\\.html\\'"
     "\\.phtml\\'"
     "\\.tpl\\.php\\'"
     "\\.[agj]sp\\'"
     "\\.as[cp]x\\'"
     "\\.erb\\'"
     "\\.mustache\\'"
     "\\.djhtml\\'"
     "\\.vue\\'")
    :hook (eb-mode . (lambda () (electric-pair-local-mode -1))))
  (use-package emmet-mode
    :ghook 'web-mode)
#+end_src
*** JavaScript
#+begin_src emacs-lisp
  (defun my/typescript-indent ()
    (setq-local typescript-ts-mode-indent-offset 4)
    (setq-local tab-width 4))
  (add-hook 'typescript-ts-mode-hook 'my/typescript-indent)
#+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))
    :config
    (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\\'")
 
  (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
** Direnv
#+begin_src emacs-lisp
  (use-package direnv
    :config
    (direnv-mode))
#+end_src
** Better scratch
#+begin_src emacs-lisp
  (use-package 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
** Dired hacks
#+begin_src emacs-lisp
  (use-package dired-ranger
    :bind (:map dired-mode-map
                ("r c" . dired-ranger-copy)
                ("r m" . dired-ranger-move)
                ("r p" . dired-ranger-paste)
                ("\\" . dired-ranger-bookmark)
                ("`" . dired-ranger-bookmark-visit)))
  (use-package dired-narrow
    :bind (:map dired-mode-map
                ("n" . dired-narrow)))
#+end_src
** Dired quick sort
#+begin_src emacs-lisp
  (use-package dired-quick-sort
    :config
    (dired-quick-sort-setup))
#+end_src
** Async copy
#+begin_src emacs-lisp
  (use-package dired-rsync
    :general (:prefix "C-c" :keymaps 'dired-mode-map
		      "C-r" 'dired-rsync
		      "C-x" 'dired-rsync-ent))
#+end_src
** Media files
#+begin_src emacs-lisp
  (use-package ready-player
    :ensure (:host github :repo "xenodium/ready-player"))
#+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
** Magit
#+begin_src emacs-lisp
  (use-package transient :ensure t)
  (use-package magit
    :after transient
    :bind (("C-c o g" . magit)))
#+end_src
** Jupyter
#+begin_src emacs-lisp
  ;; (use-package code-cells)
#+end_src
** Orgnote
#+begin_src emacs-lisp
  (use-package orgnote
    :defer t)
#+end_src
** Copilot
#+begin_src emacs-lisp
  ;; (use-package copilot
  ;;   :elpaca nil (:host github :repo "copilot-emacs/copilot.el" :files ("dist" "*.el"))
  ;;   :hook (python-ts-mode . copilot-mode)
  ;;   :bind ("M-RET" . copilot-accept-completion))
#+end_src
** Dash
#+begin_src emacs-lisp
  (use-package consult-dash
    :general
    ("M-s D" 'consult-dash))
#+end_src
** gptel
#+begin_src emacs-lisp
  (use-package gptel
    :after transient
    :custom
    (gptel-default-mode #'org-mode)
    :config
    (gptel-make-ollama "ollama"
      :host "localhost:11434"
      :stream t
      :models '("llama3:latest"
                "phi3:latest"
                "qwen:7b"
                "qwen:4b"))
    (gptel-make-openai "TogetherAI"
      :host "api.together.xyz"
      :key "cfc62f705be4ee701a498faa8bd65b5a1ab377d47354a0bb90e0d0a230366e8f"
      :stream t
      :models '("meta-llama/Llama-3-70b-chat-hf"
                "codellama/CodeLlama-13b-Instruct-hf"
                "codellama/CodeLlama-34b-Instruct-hf")))
#+end_src