#+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]]
  - [[#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]]
  - [[#enabling-toc][Enabling toc]]
  - [[#org-bullets][Org bullets]]
  - [[#auto-tangle][Auto-tangle]]
  - [[#org-download][Org-download]]
- [[#better-ux][Better UX]]
  - [[#vertico][Vertico]]
  - [[#consult][Consult]]
  - [[#embark][Embark]]
- [[#eshell][Eshell]]
  - [[#fish-completions][Fish completions]]
  - [[#eat][Eat]]
- [[#lsp][LSP]]
  - [[#flycheck][Flycheck]]
  - [[#lsp-ui][lsp-ui]]
  - [[#lsp-booster][LSP-booster]]
  - [[#corfu][Corfu]]
  - [[#tree-sitter][Tree-sitter]]
  - [[#snippets][Snippets]]
  - [[#languages][Languages]]
  - [[#direnv][Direnv]]
  - [[#better-scratch][Better scratch]]
- [[#dired][Dired]]
  - [[#bindings][Bindings]]
  - [[#dired-hacks][Dired hacks]]
- [[#sql][Sql]]
- [[#additional-apps][Additional apps]]
  - [[#telegram-lol][Telegram lol]]
  - [[#magit][Magit]]
  - [[#exwm][EXWM]]
  - [[#jupyter][Jupyter]]
  - [[#orgnote][Orgnote]]
  - [[#copilot][Copilot]]

* 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
** 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
** 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
** Auto-tangle
#+begin_src emacs-lisp
  (use-package org-auto-tangle
    :ghook 'org-mode-hook)
#+end_src
** Org-download
#+begin_src emacs-lisp
  (use-package org-download
    :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
    :init
    (setq completion-styles '(orderless basic)
          completion-category-defaults nil
          completion-category-overrides '((file (styles partial-completion)))))
#+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 1)
#+end_src
*** Debugging
#+begin_src emacs-lisp
  (use-package dape
    :config
    (setq dape-cwd-fn 'projectile-project-root))
#+end_src
*** Truncate lines
#+begin_src emacs-lisp
  (global-visual-line-mode t)
#+end_src
*** No littering
#+begin_src emacs-lisp
  (use-package no-littering)
#+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 vundo
    :custom
    (vundo-glyph-alist vundo-unicode-symbols)
    (vundo-compact-display t))
#+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)))
#+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
* LSP
#+begin_src emacs-lisp
  (use-package lsp-mode
    :custom
    (lsp-completion-provider :none)
    :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))


  (setq lsp-sqls-workspace-config-path nil
	lsp-sqls-connections
	'(((driver . "postgresql") (dataSourceName . "host=127.0.0.1 port=38746 user=sirius_2024 password=changed dbname=postgres sslmode=disable"))))
#+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
    :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
** Languages
*** 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
   ("\\.phtml\\'"
    "\\.tpl\\.php\\'"
    "\\.[agj]sp\\'"
    "\\.as[cp]x\\'"
    "\\.erb\\'"
    "\\.mustache\\'"
    "\\.djhtml\\'"))
#+end_src
*** JavaScript
#+begin_src emacs-lisp
  ;; (use-package js2-mode)
#+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"))
#+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-transient))
#+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 magit
    :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