emacs configuration

;; -*- mode: emacs-lisp; lexical-binding: t; -*-
; Do not edit this file directly!
; This file was generated by running ~org-babel-tangle~ on dotfiles.org

(defvar elpaca-installer-version 0.11)
(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 :depth 1 :inherit ignore
                              :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 (apply #'call-process `("git" nil ,buffer t "clone"
                                                  ,@(when-let* ((depth (plist-get order :depth)))
                                                      (list (format "--depth=%d" depth) "--no-single-branch"))
                                                  ,(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)
    (let ((load-source-file-function nil)) (load "./elpaca-autoloads"))))
(add-hook 'after-init-hook #'elpaca-process-queues)
(elpaca `(,@elpaca-order))

;; Install use-package support
(elpaca elpaca-use-package
  ;; Enable use-package :ensure support for Elpaca.
  (elpaca-use-package-mode)
  (setq use-package-always-ensure t))

(setq elpaca-ignored-dependencies
      (delq 'transient
            (delq 'org elpaca-ignored-dependencies)))

(elpaca-wait) ;; Block until current queue processed.

;; https://github.com/progfolio/elpaca/issues/181
(use-package auctex
  :ensure (auctex :pre-build (("./autogen.sh")
                              ("./configure"
                               "--without-texmf-dir")
                              ("make"))))
(elpaca-wait) ;; esure auctex is installed properly

(use-package compat) ; might as well add it here so elpaca doesn't show it as an orphan

(use-package exec-path-from-shell
  :config
  (when (memq window-system '(mac ns x))
    (exec-path-from-shell-initialize)))

;(menu-bar-mode -1)
(tool-bar-mode -1)
(when window-system (scroll-bar-mode -1))

(setq frame-resize-pixelwise t)

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

(require 'saveplace)
(setq-default save-place t)

(show-paren-mode 1)
(setq-default indent-tabs-mode nil)
(setq apropos-do-all t
      require-final-newline t
      load-prefer-newer t
      ediff-window-setup-function 'ediff-setup-windows-plain
      save-place-file (concat user-emacs-directory "places")
      backup-directory-alist `(("." . ,(concat user-emacs-directory
                                               "backups"))))

;; Speed up tramp
;; https://www.gnu.org/software/emacs/manual/html_node/tramp/Frequently-Asked-Questions.html
(setq vc-ignore-dir-regexp
      (format "\\(%s\\)\\|\\(%s\\)"
              vc-ignore-dir-regexp
              tramp-file-name-regexp))

;; Ensure tramp works on guix remotes
;; https://lists.gnu.org/archive/html/help-guix/2016-10/msg00049.html
(require 'tramp)
(setq tramp-remote-path
      (append tramp-remote-path
              '(tramp-own-remote-path
                "~/.guix-profile/bin" "~/.guix-profile/sbin"
                "/run/current-system/profile/bin" 
                "/run/current-system/profile/sbin")))

(setq tramp-remote-process-environment
      '("GUIX_LOCPATH=\"$HOME/.guix-profile/lib/locale\""))

(blink-cursor-mode 0)
;; When emacs asks for "yes" or "no", let "y" or "n" suffice
(fset 'yes-or-no-p 'y-or-n-p)
(setq inhibit-startup-message t)
(setq ring-bell-function 'ignore)
(setq confirm-kill-emacs 'yes-or-no-p)
(setq-default fill-column 80)
(setq sentence-end-double-space nil)

(setq auth-source-save-behavior nil)
(setq custom-file (concat user-emacs-directory "custom.el"))
(setq woman-fill-frame t)
(load custom-file)

(setq user-full-name "Akira Kyle"
      user-mail-address "akira@akirakyle.com")

(setq css-indent-offset 2)

(use-package eww
  :ensure nil
  :custom
  (eww-auto-rename-buffer 'title)
  ;; https://github.com/alphapapa/unpackaged.el#eww-imenu-support
  :config
  (defun unpackaged/imenu-eww-headings ()
    "Return alist of HTML headings in current EWW buffer for Imenu.
Suitable for `imenu-create-index-function'."
    (let ((faces '(shr-h1 shr-h2 shr-h3 shr-h4 shr-h5 shr-h6 shr-heading)))
      (save-excursion
        (save-restriction
          (widen)
          (goto-char (point-min))
          (cl-loop for next-pos = (next-single-property-change (point) 'face)
                   while next-pos
                   do (goto-char next-pos)
                   for face = (get-text-property (point) 'face)
                   when (cl-typecase face
                          (list (cl-intersection face faces))
                          (symbol (member face faces)))
                   collect (cons (buffer-substring (point-at-bol) (point-at-eol)) (point))
                   and do (forward-line 1))))))

  (add-hook 'eww-mode-hook
            (lambda ()
              (setq-local imenu-create-index-function #'unpackaged/imenu-eww-headings)))
  )

(use-package doom-themes
  :config
  (load-theme 'doom-one t)
  (doom-themes-org-config))

(use-package all-the-icons)

(use-package doom-modeline
  :init
  (setq doom-modeline-icon t);(display-graphic-p)
  (column-number-mode 1)
  (doom-modeline-mode 1)
  ;;(setq doom-modeline-window-width-limit 80);;fill-column
  ;;(setq doom-modeline-minor-modes nil)
  )

(defvar-local hidden-mode-line-mode nil)

(define-minor-mode hidden-mode-line-mode
  "Minor mode to hide the mode-line in the current buffer."
  :init-value nil
  :global t
  :variable hidden-mode-line-mode
  :group 'editing-basics
  (if hidden-mode-line-mode
      (setq hide-mode-line mode-line-format
            mode-line-format nil)
    (setq mode-line-format hide-mode-line
          hide-mode-line nil))
  (force-mode-line-update)
  ;; Apparently force-mode-line-update is not always enough to
  ;; redisplay the mode-line
  (redraw-display)
  (when (and (called-interactively-p 'interactive)
             hidden-mode-line-mode)
    (run-with-idle-timer
     0 nil 'message
     (concat "Hidden Mode Line Mode enabled.  "
             "Use M-x hidden-mode-line-mode to make the mode-line appear."))))

;; If you want to hide the mode-line in every buffer by default
;; (add-hook 'after-change-major-mode-hook 'hidden-mode-line-mode)

(use-package minibuffer-statusbar
  :straight (minibuffer-statusbar :type git :host github 
                                  :repo "akirakyle/minibuffer-statusbar")
  :config
  (minibuffer-statusbar-mode t)
  (global-eldoc-mode -1))

(setq split-height-threshold nil) ;40)
(setq split-width-threshold 160) ;100) ;nil) 

;(use-package hl-line-mode
;  :no-require t
;  :config
  (global-hl-line-mode t)
  (make-variable-buffer-local 'global-hl-line-mode)
  (add-hook 'vterm-mode-hook (lambda () (setq global-hl-line-mode nil)))
;)

(use-package whitespace
  :ensure nil
  :config
  (setq whitespace-style '(face lines-char))
  (add-hook 'prog-mode-hook 'whitespace-mode))

(use-package general
  :demand t
  :config
  ;;(define-key key-translation-map (kbd "C-h") (kbd "<DEL>"))
  (general-define-key
    ;;:keymaps 'override
   "C-h" (general-simulate-key "<backspace>"))

  (general-define-key 
    :keymaps 'override
    "C-<tab>" #'(lambda () (interactive) (switch-to-buffer nil)))

  (defun my-start-app (command) 
    (interactive (list (read-shell-command "$ ")))
    (start-process-shell-command command nil command))

  (defun my-toggle-window-split ()
    (interactive)
    (if (eq (count-windows) 1)
        (progn
          (split-window-right)
          (other-window 1)
          (switch-to-buffer nil)
          (other-window 1))
      (delete-other-windows)))

  (general-create-definer my-leader-def
    :prefix "SPC"
    :prefix-command 'my-leader-prefix-cmd
    :states '(normal visual motion)
    :keymaps 'override)

  (general-define-key 
    :keymaps '(override exwm-mode-map)
    "C-SPC" 'my-leader-prefix-cmd)

  ;; make iterated prefix commands like C-u C-u C-u actually work
  (general-define-key 
    :keymaps 'universal-argument-map
    "SPC u" 'universal-argument-more
    "C-SPC u" 'universal-argument-more)

  (general-create-definer my-local-leader-def
    :prefix ","
    :states '(normal visual motion)
    :keymaps 'override)

  (my-leader-def
    "SPC" 'execute-extended-command
    "u" 'universal-argument
    "'" 'vterm
    "a"  '(:ignore t :which-key "apps")
    "as"  '(:ignore t :which-key "shell")
    "ase" 'eshell
    "ass" 'shell
    "ast" 'ansi-term
    "asv" 'vterm
    "aw" 'woman
    "w"  '(:ignore t :which-key "windows")
    "ww" 'my-toggle-window-split
    "w/" 'split-window-right
    "w-" 'split-window-below
    "w=" 'balance-windows
    "wd" 'delete-window
    "b"  'consult-buffer ;'switch-to-buffer
    "C-b"  'consult-buffer ;'switch-to-buffer
    ;;"c"  '(:ignore t :which-key "cd")
    "c"  '(:ignore t :which-key "buffers")
    "cc" 'ibuffer
    "ck" 'kill-current-buffer
    "cu" 'revert-buffer
    "cd" 'cd
    "cw" 'widen
    "q"  '(:ignore t :which-key "quit")
    "qq" 'save-buffers-kill-emacs
    "f"  '(:ignore t :which-key "files")
    "ff" 'find-file
    "fs" 'save-buffer
    "fa" 'save-some-buffers
    ;;"h"  'help
    "h"  '(:ignore t :which-key "help")
    "hh" 'describe-symbol
    "hm" 'describe-mode
    "hk" 'describe-key
    "hf" 'describe-function
    "hv" 'describe-variable
    "hb" 'describe-bindings
    "j"  '(:ignore t :which-key "jump")
    "ji" 'consult-imenu ;'imenu
    "s"  '(:ignore t :which-key "search")
    "e" 'my-start-app
    "z" 'describe-bindings
    "tv" 'visual-line-mode
    "tt" 'toggle-truncate-lines
    "tw" 'whitespace-mode
    )
  )

(elpaca-wait)

(use-package which-key
  :config
  (which-key-mode)
  )

;(use-package undo-tree
;  :init
;  (setq undo-tree-auto-save-history nil)
;  :config
;  (global-undo-tree-mode)
;  )
(use-package vundo)

(use-package evil
  :init
  (setq evil-want-keybinding nil
        evil-disable-insert-state-bindings t
        ;; evil-want-minibuffer t
        evil-want-C-u-scroll t
        evil-want-C-i-jump nil
        evil-move-cursor-back nil
        evil-move-beyond-eol t
        evil-undo-system 'undo-redo)
  (setq evil-normal-state-cursor '(box "DarkGoldenrod2")
        evil-insert-state-cursor '((bar . 2) "chartreuse3")
        evil-emacs-state-cursor '(box "SkyBlue2")
        evil-hybrid-state-cursor '((bar . 2) "SkyBlue2")
        evil-replace-state-cursor '((hbar . 2) "chocolate")
        evil-evilified-state-cursor '(box "LightGoldenrod3")
        evil-visual-state-cursor '((hbar . 2) "gray")
        evil-motion-state-cursor '(box "plum3")
        evil-lisp-state-cursor '(box "HotPink1")
        evil-iedit-state-cursor '(box "firebrick1")
        evil-iedit-insert-state-cursor '((bar . 2) "firebrick1")
        )
  :config
  (evil-mode 1)
  (evil-set-initial-state 'term-mode 'emacs)
  (define-key evil-normal-state-map (kbd "j") 'evil-next-visual-line)
  (define-key evil-normal-state-map (kbd "k") 'evil-previous-visual-line)
  )
(use-package evil-collection
  :after evil
  ;;:custom
  ;;(evil-collection-setup-minibuffer nil)
  :config
  ; see https://github.com/emacs-evil/evil-collection/pull/397
  ; overshadows bindings in emacs-webkit and xwidget-webkit
  ;(setq evil-collection-mode-list (delete 'simple evil-collection--supported-modes))

  (evil-collection-init)
  )
(use-package evil-matchit
  :after evil
  :config
  (global-evil-matchit-mode 1))
(use-package evil-surround
  :after evil
  :config
  ; https://github.com/emacs-evil/evil-surround/pull/48
  ;(evil-define-key 'visual evil-surround-mode-map "s" 'evil-surround-region)
  ;(evil-define-key 'visual evil-surround-mode-map "S" 'evil-substitute)
  (global-evil-surround-mode 1))
(use-package evil-tex
  :after evil
  )
;;(use-package evil-easymotion
;;  :config
;;  (evilem-default-keybindings "SPC j")
;;  )

(use-package smartparens
  :config
  (sp-local-pair 'org-mode "$" "$")
  (sp-local-pair 'org-mode '"\\[" "\\]")
  (add-hook 'prog-mode-hook #'smartparens-mode)
  (add-hook 'org-mode-hook #'smartparens-mode)
  )
(use-package rainbow-delimiters
  :config
  (add-hook 'prog-mode-hook #'rainbow-delimiters-mode)
  )

(use-package ivy
  :init
  (setq recentf-max-saved-items 50)
  (setq ivy-use-virtual-buffers t)
  (setq enable-recursive-minibuffers t)
  (setq ivy-count-format "(%d/%d) ")
  (setq ivy-height 20)
  :config
  (ivy-mode 1)
  (general-def
    :keymaps 'ivy-minibuffer-map
    "C-<return>" 'ivy-immediate-done
    "C-d" 'ivy-scroll-up-command
    "C-u" 'ivy-scroll-down-command
    )
  )

(use-package counsel
  :config
  (counsel-mode 1)
  (my-leader-def "sa" 'counsel-ag)
  (my-leader-def "fg" 'counsel-git)
  )

(use-package swiper
  :config
  (general-define-key "C-s" 'swiper)
  (my-leader-def "ss" 'swiper)
  )

(use-package ivy-avy)

(use-package amx)

(use-package ivy-rich
  :init
  (setq ivy-rich-parse-remote-buffer nil)
  ;;(setq ivy-format-function #'ivy-format-function-line)
  :config
  (ivy-rich-mode 1)
  (ivy-rich-project-root-cache-mode 1)
  )

;use-package ivy-posframe
;  :config
;  (put 'ivy-posframe 'face-alias 'default)
;  (setq ivy-posframe-border-width 5)
;  (setq ivy-posframe-display-functions-alist '((t . ivy-posframe-display-at-frame-center)))
;  (setq ivy-posframe-display-functions-alist
;      '((swiper          . ivy-posframe-display-at-point)
;        (complete-symbol . ivy-posframe-display-at-point)
;        (t               . ivy-posframe-display-at-frame-center)))
;  ;(ivy-posframe-mode 1)
;  )

(use-package vertico
  :ensure (vertico :files (:defaults "extensions/*"))
  :init
  (vertico-mode)
  (setq vertico-count 16
        vertico-cycle t)

  ;(require 'vertico-directory)
  (general-def
    :keymaps 'vertico-map
    "C-d" 'vertico-scroll-up
    "C-u" 'vertico-scroll-down
    ;"RET" 'vertico-directory-enter
    "DEL" 'vertico-directory-delete-char
    )
  )

(use-package vertico-directory
  :ensure nil
  :after vertico)

;; Persist history over Emacs restarts. Vertico sorts by history position.
(use-package savehist
  :ensure nil
  :init
  (savehist-mode))

(use-package emacs
  :ensure nil
  :init
  ;; 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)

  ;; Enable recursive minibuffers
  (setq enable-recursive-minibuffers t))

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

(use-package consult
  :config
  (consult-customize
   consult-buffer
   :preview-key "M-.")

  ; https://github.com/minad/consult/issues/651
  (defun consult--buffer-sort-mru(xs)
    (append (cdr xs) (list (car xs))))
  (plist-put consult--source-buffer :items
             (lambda() (consult--buffer-query :sort 'mru :as #'buffer-name)))

  (general-define-key "C-s" 'consult-line)
  (my-leader-def "ss" 'consult-line)
  (my-leader-def "sa" 'consult-ripgrep)
  (my-leader-def "fp" 'consult-project-buffer)
  (recentf-mode)

  ; from the consult wiki https://github.com/minad/consult/wiki
  (defvar consult--previous-point nil
    "Location of point before entering minibuffer.
Used to preselect nearest headings and imenu items.")

  (defun consult--set-previous-point ()
    "Save location of point. Used before entering the minibuffer."
    (setq consult--previous-point (point)))

  (advice-add #'consult-org-heading :before #'consult--set-previous-point)
  (advice-add #'consult-outline :before #'consult--set-previous-point)

  (advice-add #'vertico--update :after #'consult-vertico--update-choose)

  (defun consult-vertico--update-choose (&rest _)
    "Pick the nearest candidate rather than the first after updating candidates."
    (when (and consult--previous-point
               (memq current-minibuffer-command
                     '(consult-org-heading consult-outline)))
      (setq vertico--index
            (max 0 ; if none above, choose the first below
                 (1- (or (seq-position
                          vertico--candidates
                          consult--previous-point
                          (lambda (cand point-pos) ; counts on candidate list being sorted
                            (> (cl-case current-minibuffer-command
                                 (consult-outline
                                  (car (consult--get-location cand)))
                                 (consult-org-heading
                                  (get-text-property 0 'consult--candidate cand)))
                               point-pos)))
                         (length vertico--candidates))))))
    (setq consult--previous-point nil))
  )

;(use-package consult-ag
;  :config
;  (my-leader-def "sa" 'consult-ag)
;  )

(use-package all-the-icons-completion
  :config
  (add-hook 'marginalia-mode-hook #'all-the-icons-completion-marginalia-setup)
  )

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

(use-package embark
  :bind
  (("C-." . embark-act))
   ;("C-;" . embark-dwim)        ;; good alternative: M-.
   ;("C-h B" . embark-bindings)) ;; alternative for `describe-bindings'

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

  (defvar my-org-roam-map
    (let ((map (make-sparse-keymap)))
      ;(define-key map (kbd "t") 'org-roam-buffer-toggle)
      (define-key map (kbd "i") 'org-roam-node-insert)
      (define-key map (kbd "f") 'org-roam-node-find)
      ;(define-key map (kbd "r") 'org-roam-ref-find)
      ;(define-key map (kbd "g") 'org-roam-show-graph)
      ;(define-key map (kbd "c") 'org-roam-capture)
      ;(define-key map (kbd "j") 'org-roam-dailies-capture-today)
      map)
    "Keymap for 'org-roam' v2.")

  ; make available my-org-roam-map to embark-act
  (add-to-list 'embark-keymap-alist '(org-roam-node . my-org-roam-map))
  )

;; Consult users will also want the embark-consult package.
(use-package embark-consult
  :after (embark consult))

(use-package avy
  :config
  (avy-setup-default)
  (setq avy-all-windows nil)
  (setq avy-keys '(?a ?o ?e ?u ?h ?t ?n ?s))
  (setq avy-timeout-seconds 0.2)
  (general-define-key :states 'normal "gc" 'evil-avy-goto-char-timer);;evil-avy-goto-char-2)
  (general-define-key :states '(normal insert) "C-'" 'evil-avy-goto-char-timer);;evil-avy-goto-char-2)
  )

(use-package ace-link
  :config
  (ace-link-setup-default)
  (general-define-key :states 'normal :keymaps 'Info-mode-map "o" 'ace-link-info)
  (general-define-key :states 'normal :keymaps 'help-mode-map "o" 'ace-link-help)
  (general-define-key :states 'normal :keymaps 'help-mode-map "o" 'ace-link-help)
  (my-local-leader-def :keymaps 'org-mode-map "o" 'ace-link-org)
  )

(use-package ace-window
  :config
  (setq aw-keys '(?h ?t ?n ?s))
  (setq aw-scope 'frame)
  (general-define-key :keymaps 'override  "M-<tab>" 'ace-window)
  )

(use-package corfu
  :init
  (setq tab-always-indent 'complete
        ;corfu-auto t
        ;corfu-auto-delay 0
        corfu-preselect-first nil
        corfu-quit-at-boundary nil
        ;corfu-quit-no-match t
        )
  :config
  (global-corfu-mode)

  (defun corfu-enable-always-in-minibuffer ()
    "Enable Corfu in the minibuffer if Vertico is not active."
    (unless (bound-and-true-p vertico--input)
      ;; (setq-local corfu-auto nil) Enable/disable auto completion
      (corfu-mode 1)))
  (add-hook 'minibuffer-setup-hook #'corfu-enable-always-in-minibuffer 1)
  )

(use-package kind-icon
  :after corfu
  :custom
  (kind-icon-default-face 'corfu-default) ; to compute blended backgrounds correctly
  :config
  (add-to-list 'corfu-margin-formatters #'kind-icon-margin-formatter))

modified   tempel.el
@@ -598,7 +598,8 @@ This is meant to be a source in `tempel-template-sources'."
   (let ((completion-at-point-functions (list capf))
         completion-cycle-threshold)
     (tempel--save)
-    (or (completion-at-point) (user-error "%s: No completions" capf))))
+    (completion-at-point)))
+    ;(or (completion-at-point) (user-error "%s: No completions" capf))))

 (defun tempel--completion-table (templates)
   "Return a completion table for a list of TEMPLATES.

(use-package tempel
  :bind
  (:map tempel-map
        ([tab] . tempel-next)
        ([backtab] . tempel-previous))
  :init
  ;;(add-to-list 'org-structure-template-alist '("p" . "src python"))
  (defun my-templates ()
    (cond ((derived-mode-p 'org-mode)
           '((today (format-time-string "%Y-%m-%d"))
             (bl "#+begin_" (p "src" block) " " p n r n "#+end_" (s block))
             (py "#+begin_src python" n r n "#+end_src")
             (jl "#+begin_src julia" n r n "#+end_src")
             (el "#+begin_src emacs-lisp" n> r> n> "#+end_src")
             (ll "#+begin_src gptel" n> r> n> "#+end_src")
             (be "\\begin{" (p "align" env) "}" n r n "\\end{" (s env) "}")
             ))
          ((derived-mode-p 'tex-mode)
           '(
             (be "\\begin{" (p "align" env) "}" n r n "\\end{" (s env) "}")
             ))))
  (setq tempel-template-sources '(my-templates))
  )

(use-package cape
  :init
  (setq cape-dabbrev-check-other-buffers 'some)

  :config

  (bind-key  "C-c l" 'cape-tex)
  (defun my-org-emacs-lisp-capf ()
    (when (and (org-in-src-block-p 'inside)
               (string= "emacs-lisp"
                        (org-element-property
                         :language (org-element-at-point))))
      (elisp-completion-at-point)))

  (defun my-org-capf ()
    (setq-local completion-at-point-functions
                '(tempel-expand ;tempel-complete
                  ;jupyter-org-completion-at-point
                  my-org-emacs-lisp-capf
                  pcomplete-completions-at-point
                  cape-dabbrev
                  cape-file t)))

  (add-hook 'org-mode-hook #'my-org-capf)

  (setq completion-at-point-functions
        '(tempel-expand ;tempel-complete
          pcomplete-completions-at-point
          cape-dabbrev
          cape-file t))

  ;(add-hook 'prog-mode-hook 'tempel-setup-capf)
  ;(add-hook 'text-mode-hook 'tempel-setup-capf)
  )

(use-package consult-eglot
  :init
  (my-leader-def "al" 'consult-eglot-symbols)
  )

(use-package lsp-mode
  :init
  ;; set prefix for lsp-command-keymap (few alternatives - "C-l", "C-c l")
  (setq lsp-keymap-prefix nil)
  (defun my-lsp-which-key-setup ()
    (let ((lsp-keymap-prefix "SPC a l"))
      (my-leader-def "al" lsp-command-map)
      (lsp-enable-which-key-integration t)))

  (setq lsp-enable-snippet nil)
  :hook ((latex-mode . lsp)
         ;(lsp-mode . lsp-enable-which-key-integration)
         (lsp-mode . my-lsp-which-key-setup))
  :commands lsp)

(use-package lsp-ui :commands lsp-ui-mode)
(use-package consult-lsp :commands consult-lsp-diagnostics)

;; optionally if you want to use debugger
;;(use-package dap-mode)
;; (use-package dap-LANGUAGE) to load the dap adapter for your language

(use-package flyspell
  :ensure nil
  :init
  (setq ispell-program-name "aspell")
  :config
  (add-hook 'org-mode-hook #'flyspell-mode)
  (add-hook 'TeX-mode-hook #'flyspell-mode)
  (add-hook 'message-mode-hook #'flyspell-mode)
  )
(use-package flyspell-correct
  :config
  (my-leader-def
    "sc" 'flyspell-correct-wrapper
    )
  )

(use-package consult-flyspell
  :config
  (setq consult-flyspell-select-function nil
        consult-flyspell-set-point-after-word t
        consult-flyspell-always-check-buffer nil))

(use-package simple-httpd)

;(use-package geiser
;  :init
;  (setq geiser-active-implementations '(guile)))

(use-package jupyter
  :after (org ob-gptel)
  ;:defer t
  ;:ensure (jupyter :host github :repo "akirakyle/emacs-jupyter")
  :config
  (org-babel-do-load-languages
   'org-babel-load-languages
   '(
     (emacs-lisp . t)
     (org . t)
     (shell . t)
     (latex . t)
     (julia . t)
     (python . t)
     (gptel . t)
     (jupyter . t) ; must be last
     ))
  ; prevents warning: ‘org-element-at-point’ cannot be used in non-Org buffer
  ;(remove-hook 'org-mode-hook 'jupyter-org-interaction-mode)
  )

(use-package buffer-env
  :config
  (eval-when-compile (require 'cl-lib))
  (defun buffer-env-inherit (fn &rest args)
    "Call FN with ARGS using the buffer-local process environment.
Intended as an advice around commands that start a process after
switching buffers."
    (cl-letf (((default-value 'process-environment) process-environment)
              ((default-value 'exec-path) exec-path))
      (apply fn args)))

  (add-hook 'hack-local-variables-hook 'buffer-env-update)
  (advice-add 'shell-command-to-string :around #'buffer-env-inherit)
  (advice-add 'async-shell-command :around #'buffer-env-inherit)
  (advice-add 'org-babel-eval :around #'buffer-env-inherit)
  (advice-add 'jupyter-command :around #'buffer-env-inherit)
  ;; order matters for the following!
  (advice-add 'vterm-mode :around #'buffer-env-inherit)
  (advice-add 'vterm-mode :before #'buffer-env-update)
)

(use-package tex-mode
  :ensure nil
  :init
  (setq TeX-view-program-selection '((output-pdf "pdf-tools")))
  (setq TeX-view-program-list '(("pdf-tools" "TeX-pdf-tools-sync-view")))
  (add-hook 'TeX-after-compilation-finished-functions
            #'TeX-revert-document-buffer)
  (add-hook 'LaTeX-mode-hook #'visual-line-mode)
  (add-hook 'LaTeX-mode-hook (lambda () (whitespace-mode -1)))
  (setq TeX-command-extra-options "\"-shell-escape\"")
  )

(use-package cdlatex
  :init
  (org-defkey org-cdlatex-mode-map ";" 'cdlatex-math-symbol)
  (setq cdlatex-math-symbol-prefix ?\;)
  (defun my-tempel-expand ()
    (tempel-expand t))
  ; I've edited tempel--interactive not to error so this works
  (add-hook 'cdlatex-tab-hook #'my-tempel-expand)
  (add-hook 'LaTeX-mode-hook #'turn-on-cdlatex)
  (add-hook 'org-mode-hook #'turn-on-org-cdlatex)
  )

diff --git a/cdlatex.el b/cdlatex.el
index 4c85b87..0d657dd 100644
--- a/cdlatex.el
+++ b/cdlatex.el
@@ -443,7 +443,8 @@ indicating the label types for which it should be true."

 (defcustom cdlatex-math-symbol-prefix ?`
   "Prefix key for `cdlatex-math-symbol'.
-This may be a character, a string readable with `read-kbd-macro', or a
+This may be a character, a string readable with `read-kbd-macro'
+(doesn't work because of format specificer in cdlatex-math-symbol) , or a
 Lisp vector."
   :group 'cdlatex-math-support
   :type '(choice

(use-package laas
  :ensure (laas :repo "~/data/code/LaTeX-auto-activating-snippets")
  :hook ((LaTeX-mode org-mode) . laas-mode)
  :init
  (setq laas-enable-auto-space nil)
  )

(use-package pdf-tools
  :mode (("\\.pdf\\'" . pdf-view-mode))
  :config
  (evil-collection-define-key 'normal 'pdf-view-mode-map
    "u" 'pdf-view-scroll-down-or-previous-page
    "d" 'pdf-view-scroll-up-or-next-page
    "J" 'pdf-view-next-page-command
    "K" 'pdf-view-previous-page-command
    "<right>" 'image-forward-hscroll
    "<left>" 'image-backward-hscroll
    (kbd "C-u") 'pdf-view-scroll-down-or-previous-page
    (kbd "C-d") 'pdf-view-scroll-up-or-next-page
    (kbd "C-s") 'pdf-occur
    )
  (setq pdf-view-use-scaling t)
  (setq pdf-view-resize-factor 1.1)
  (setq pdf-cache-image-limit 8)
  (setq image-cache-eviction-delay 1)
  ; https://github.com/politza/pdf-tools/issues/467
  ; https://github.com/politza/pdf-tools/issues/177
  (add-hook 'pdf-view-mode-hook #'pdf-links-minor-mode)
  (add-hook 'pdf-view-mode-hook #'pdf-isearch-minor-mode)
  (add-hook 'pdf-view-mode-hook #'pdf-history-minor-mode)

  ; Not quite the same issue I was having but relevant since it still fixes it
  ; https://github.com/politza/pdf-tools/issues/201
  ; This fixes the performance issue switching evil states
  ; I suspect this was due to changing the cursor and was especially bad on large monitors
  ;(evil-set-initial-state 'pdf-view-mode 'normal)
  (add-hook 'pdf-view-mode-hook
            (lambda ()
              (set (make-local-variable 'evil-normal-state-cursor) (list nil))))
  (setq pdf-annot-activate-created-annotations t)
  (setq pdf-annot-default-annotation-properties
        `((t (label . ,user-full-name))
          (text (icon . "Comment")
                (color . "#ff0000"))
          (highlight (color . "yellow"))
          (squiggly (color . "orange"))
          (strike-out(color . "red"))
          (underline (color . "blue"))))
  )

(use-package nov
  :mode (("\\.epub\\'" . nov-mode))
  )

(use-package markdown-mode)

(use-package lua-mode
  :config
  )

(use-package julia-vterm)
(use-package ob-julia-vterm
  :after (org)
  :config
  (defalias 'org-babel-execute:julia 'org-babel-execute:julia-vterm)
  (defalias 'org-babel-variable-assignments:julia 'org-babel-variable-assignments:julia-vterm)
  )
(use-package julia-snail
  :ensure (julia-snail :repo "akirakyle/julia-snail")
  :hook (julia-mode . julia-snail-mode)
  :init
  (setq julia-snail-extensions '(ob-julia))
  :config
  (org-babel-do-load-languages
   'org-babel-load-languages
   '(
     (emacs-lisp . t)
     (org . t)
     (shell . t)
     (latex . t)
     (julia . t)
     (python . t)
     ;(gptel . t)
     ))
  )

(use-package julia-mode)
(use-package ob-julia
  :ensure (ob-julia :repo "~/data/code/emacs-ob-julia")
  :after (gptel)
  :config
  (org-babel-do-load-languages
   'org-babel-load-languages
   '(
     (emacs-lisp . t)
     (org . t)
     (shell . t)
     (latex . t)
     (julia . t)
     (python . t)
     (gptel . t)
     ))
  )

(use-package json-mode)

(use-package haskell-mode)
;(use-package tidal
;  :config
;  (add-hook 'tidal-mode-hook (lambda () (interactive-haskell-mode 0))))

(use-package swift-mode)

(use-package ibuffer
  :ensure nil
  :config
  (general-def
    :states 'normal
    :keymaps 'ibuffer-mode-map
    "<tab>" 'ibuffer-visit-buffer-other-window-noselect)
  )

(setq delete-by-moving-to-trash t)
(setq trash-directory "~/.Trash")

(setq dired-listing-switches "-alhv")
(setq dired-guess-shell-alist-user
      (list (list "\\.pdf" "open")))
(put 'dired-find-alternate-file 'disabled nil)

(general-def
  :keymaps 'dired-mode-map
  :states 'normal
  "gj" 'dired-next-subdir
  "gk" 'dired-prev-subdir
  )

(elpaca-wait)
(add-hook 'eshell-mode-hook
          #'(lambda ()
              (define-key eshell-mode-map (kbd "<tab>") 'completion-at-point)))

(evil-define-key 'insert eshell-mode-map 
  (kbd "C-p") 'eshell-previous-input 
  (kbd "C-n") 'eshell-next-input)

(setq shell-default-height 40)
(setq shell-default-position 'full)
(setq shell-default-full-span nil)
(setq shell-default-term-shell "/usr/local/bin/bash")
;;(setq shell-default-shell 'shell)
(push (cons "\\*shell\\*" display-buffer--same-window-action) display-buffer-alist)
;;(setq term-color-black ((t (:foreground "dim gray"))))

(evil-define-key 'normal comint-mode-map (kbd "C-p") 'comint-previous-input
  (kbd "C-n") 'comint-next-input)
(evil-define-key 'insert comint-mode-map (kbd "C-p") 'comint-previous-input
  (kbd "C-n") 'comint-next-input)
(evil-define-key 'normal comint-mode-map (kbd "C-l") 'comint-clear-buffer)
(evil-define-key 'insert comint-mode-map (kbd "C-l") 'comint-clear-buffer)
(evil-define-key 'normal term-raw-map (kbd "C-p") 'term-send-up
  (kbd "C-n") 'term-send-down)
(evil-define-key 'insert term-raw-map (kbd "C-p") 'term-send-up
  (kbd "C-n") 'term-send-down)

(setq term-char-mode-point-at-process-mark nil)

(use-package vterm)

(use-package magit
  :init
  (setq magit-diff-refine-hunk 'all
        magit-process-connection-type nil)
  :config
  (my-leader-def
   "g"  '(:ignore t :which-key "git")
   "gs" 'magit-status
   )
  (define-key magit-mode-map (kbd "M-<tab>") nil)
  (define-key magit-section-mode-map (kbd "C-<tab>") nil)
  (define-key magit-section-mode-map (kbd "M-<tab>") nil)
  (evil-collection-define-key 'normal 'magit-section-mode-map
    [C-tab] nil
    [M-tab] nil
    )
  )

(use-package mu4e
  :ensure nil
  :load-path  "/opt/homebrew/share/emacs/site-lisp/mu/mu4e/"
  :init
  (setq mu4e-completing-read-function 'completing-read)

  (setq mu4e-change-filenames-when-moving t
        mu4e-headers-time-format "%I:%M %p"
        mu4e-headers-date-format "%y-%m-%d"
        ;;mu4e-split-view 'vertical
        ;;mu4e-split-view 'single-window
        ;;mu4e-headers-visible-columns 80
        mu4e-get-mail-command "mbsync -a"
        mu4e-headers-fields '((:maildir . 12)
                              (:flags . 4)
                              (:human-date . 9)
                              ;;(:mailing-list . 10)
                              (:from . 24)
                              (:subject))
        mu4e-headers-sort-field ':date
        mu4e-headers-sort-direction 'ascending
        mu4e-view-show-addresses t
        mu4e-compose-format-flowed t
        mu4e-compose-dont-reply-to-self t
        mu4e-headers-results-limit 1000
        message-send-mail-function 'message-smtpmail-send-it ; For message-mode (Gnus)
        send-mail-function 'smtpmail-send-it ; For mail-mode (Rmail)
        ;;smtpmail-stream-type 'starttls
        ;;mu4e-view-prefer-html nil
        )

  ;; customize the reply-quote-string
  (setq message-citation-line-format "On %a, %b %d, %Y at %I:%M %p, %f wrote:\n")
  ;; choose to use the formatted string
  (setq message-citation-line-function 'message-insert-formatted-citation-line)

  :config

  (general-define-key
   :states 'normal
   :keymaps 'mu4e-view-mode-map
   "o" 'ace-link-mu4e
   "O" 'mu4e-view-open-attachment)
;;(define-key mu4e-view-mode-map (kbd "f") 'mu4e-view-go-to-url)

  (my-leader-def
   "am" 'mu4e
   )

  <<email.org:mu4e-blk()>>

  ;;(defun my-mu4e-html2text (msg)
  ;;  "My html2text function; shows short message inline, show
  ;;long messages in some external browser (see `browse-url-generic-program')."
  ;;  (let ((html (or (mu4e-message-field msg :body-html) "")))
  ;;    (if (> (length html) 20000)
  ;;        (progn
  ;;          (mu4e-action-view-in-browser msg)
  ;;          "[Viewing message in external browser]")
  ;;      (mu4e-shr2text msg))))

  (setq mu4e-html2text-command 'mu4e-shr2text); my-mu4e-html2text

  (defun my-mu4e-action-view-in-browser (msg)
  "Show current MSG in browser if it includes an HTML-part.
The variables `browse-url-browser-function',
`browse-url-handlers', and `browse-url-default-handlers'
determine which browser function to use."
  (with-temp-buffer
    (insert-file-contents-literally
     (mu4e-message-field msg :path) nil nil nil t)
    (run-hooks 'gnus-article-decode-hook)
    (when (re-search-forward "<!DOCTYPE[^>]*>" nil t)
      (replace-match ""))
    (when (re-search-forward "<html[^>]*>" nil t)
      (replace-match "<html>"))
    (let ((header (cl-loop for field in '("from" "to" "cc" "date" "subject")
                           when (message-fetch-field field)
                           concat (format "%s: %s\n" (capitalize field) it)))
          (parts (mm-dissect-buffer t t)))
      ;; If singlepart, enforce a list.
      (when (and (bufferp (car parts))
                 (stringp (car (mm-handle-type parts))))
        (setq parts (list parts)))
      ;; Process the list
      (unless (gnus-article-browse-html-parts parts header)
        (mu4e-warn "Message does not contain a \"text/html\" part"))
      (mm-destroy-parts parts))))

  (setq mu4e-view-actions
        '(("capture message" . mu4e-action-capture-message)
          ("view in browser" . my-mu4e-action-view-in-browser)
          ("show this thread" . mu4e-action-show-thread)))

  (add-hook 'mu4e-view-mode-hook (lambda () (visual-line-mode 1)))

  (custom-theme-set-faces
   'user
   '(variable-pitch ((t (:family "DejaVu Sans" :height 120)))))

  (add-hook 'message-mode-hook (lambda () (whitespace-mode -1)))
  (add-hook 'message-mode-hook (lambda () (auto-fill-mode -1)))
  (add-hook 'message-mode-hook (lambda () (visual-line-mode 1)))
  )

;(use-package pass)

;(add-hook 'xwidget-webkit-mode-hook 'posframe-delete-all)

(use-package webkit
  :straight (webkit :type git :host github :repo "akirakyle/emacs-webkit"
                    :branch "main"
                    :files (:defaults "*.js" "*.css" "*.so")
                    :pre-build ("nix-shell" "--command" "make clean && make"))
  :init
  (setq browse-url-browser-function 'webkit-browse-url)
  ;(setq browse-url-browser-function 'xwidget-webkit-browse-url)
  (setq webkit-browse-url-force-new t)
  (setq webkit-search-prefix "https://google.com/search?q=")
  (setq webkit-ace-chars "aoeuidhtns")
  ;(setq webkit-dark-mode t)
  :config
  (my-leader-def
    "," 'webkit
    )

  (defun webkit--display-progress (progress)
    (setq webkit--progress-formatted
          (if (equal progress 100.0)
              ""
            (format "%s%.0f%%  " (all-the-icons-faicon "spinner") progress)))
    (force-mode-line-update))

  (defun my-mu4e-action-view-in-webkit (msg)
    (add-hook 'webkit-new-hook #'webkit-enable-javascript)
    (webkit-browse-url (concat "file://"
                               (mu4e~write-body-to-html msg)) t)
    (remove-hook 'webkit-new-hook #'webkit-enable-javascript))

  ;(add-to-list 'mu4e-view-actions
  ;             '("open in browser" . mu4e-action-view-in-browser) t)

(defun my-webkit-secure ()
  (interactive)
  (let ((cookie-file "~/.emacs.d/webkit/cookies-centos"))
    (webkit-set-proxy "socks://localhost:8000")
    (delete-file (expand-file-name cookie-file))
    (webkit-set-cookie-file cookie-file)))

(defun my-webkit-secure-start ()
  (interactive)
  (start-process "socks" "*socks*" "ssh" "centos" "ip a")
  (start-process "socks" "*socks*" "ssh" "-CND" "8000" "centos"))

)

(use-package webkit-ace
  :straight nil)

(use-package webkit-dark
  :straight nil)

(use-package evil-collection-webkit
  :straight nil
  :config
  (evil-collection-xwidget-setup)
  )

(use-package gptel
  :init
  (setq gptel-default-mode 'org-mode)
  :config
  (gptel-make-anthropic "Claude" :stream t :key gptel-api-key)

  (gptel-make-preset 'org-gpt5
    :description "Preset for gpt5 in org mode"
    :backend "ChatGPT"
    :system "You are a large language model and a helpful assistant living in an Emacs org mode buffer. Respond concisely."
    :model 'gpt-5
    )
  (gptel-make-preset 'org-opus
    :description "Preset for opus 4.5 in org mode"
    :backend "Claude"
    :system "You are a large language model and a helpful assistant living in an Emacs org mode buffer. Respond concisely."
    :model 'claude-opus-4-5-20251101
    )
  (gptel-make-preset 'org-sonnet
    :description "Preset for Claude Sonnet 4.5 in org mode"
    :backend "Claude"
    :system "You are a large language model and a helpful assistant living in an Emacs org mode buffer. Respond concisely."
    :model 'claude-sonnet-4-5-20250929
    )
  ;(advice-add
  ; 'gptel--request-data
  ; :around
  ; (lambda (orig-fn &rest args)
  ;   (when (cl-typep (car args) 'gptel-anthropic)
  ;     (let ((result (apply orig-fn args)))
  ;       (cons :tools (cons '[(:type "web_search_20250305"
  ;                                   :name "web_search"
  ;                                   :max_uses 5)] result))))))
  )

(use-package ob-gptel
  :ensure (ob-gptel :repo "~/data/code/ob-gptel")
  :hook ((org-mode . ob-gptel-install-completions))
  :defines ob-gptel-install-completions
  :init
  (setq gptel-use-context 'system)
  :config
  ;(add-to-list 'org-babel-load-languages '(gptel . t)) ;; added in jupyter config...
  ;; Optional, for better completion-at-point
  (defun ob-gptel-install-completions ()
    (add-hook 'completion-at-point-functions
              'ob-gptel-capf nil t)))

(use-package inline-diff
  :ensure (inline-diff :repo "https://code.tecosaur.net/tec/inline-diff")
  :config
  (my-leader-def "dd" 'inline-diff-transient)
  )

(use-package gptel-inline-diff
  :ensure nil
  :after (gptel inline-diff)
  :config
  (my-leader-def "dg" 'gptel-inline-diff-region)
  )

;;(use-package desktop
;;  :init
;;  (setq desktop-restore-frames nil)
;;  )

(use-package gcmh
  :init
  (setq gcmh-high-cons-threshold #x10000000)
  :config
  (gcmh-mode 1)
  )

;(server-start)