Use elpaca instead of straight

Some big changes related to that, and to use-package
2024-10-23 09:08:11 +03:00 · 2024-10-23 09:08:11 +03:00 · c7b0c1c6c2
commit c7b0c1c6c2
parent ecf3d4195a
50 changed files with 1262 additions and 365 deletions
--- a/lisp/icejam-avy.el
+++ b/lisp/icejam-avy.el
@ -9,12 +9,13 @@
 ;; Avy is a navigation manager.

 ;;; Code:
-(use-package avy :straight t :defer t
-  :config
+(use-package avy :ensure t)
+
+(with-eval-after-load 'avy
  (setq avy-timeout-seconds 1)
-  :bind (:map icejam-keys-mode-map
-              ([(hyper j)] . avy-goto-char-timer)) ;; Jump to text.
-  )
+  ;; Jump to text in sight with CMD-j
+  (define-key icejam-keys-mode-map [(hyper j)] 'avy-goto-char-timer))
+

 (provide 'icejam-avy)
 ;;; icejam-avy.el ends here
--- a/lisp/icejam-base.el
+++ b/lisp/icejam-base.el
@ -40,15 +40,15 @@
 (global-set-key (kbd "RET") 'newline)

 ;;;;;;;;; Easy copying of data ;;;;;;;;;;;;;;;
-(use-package easy-kill :straight t :defer t
+(use-package easy-kill :ensure t :defer t
  :config (global-set-key [remap kill-ring-save] 'easy-kill))

 ;; Move buffers around with buffer keys
-(use-package buffer-move :straight t :defer t)
+(use-package buffer-move :ensure t :defer t)


 ;; Garbage collection magic hack
-(use-package gcmh :straight t
+(use-package gcmh :ensure t
  :config (gcmh-mode 1)
  (setq gcmh-verbose nil
        gcmh-idle-delay 'auto
@ -96,13 +96,13 @@
 ;; Allow to execute path from shell
 (use-package exec-path-from-shell
  :if (memq window-system '(x mac ns))
-  :straight t
+  :ensure t
  :config (add-to-list 'exec-path "/usr/local/bin")
  (dolist (var '("DEFT_PATH" "LANG" "LC_CTYPE"))
    (add-to-list 'exec-path-from-shell-variables var))
  (exec-path-from-shell-initialize))

-(use-package direnv :straight t :config (direnv-mode))
+(use-package direnv :ensure t :config (direnv-mode))

 ;; Draw underline lower
 (setq x-underline-at-descent-line t)
@ -114,12 +114,12 @@
      indicate-empty-lines nil)

 ;;;;;;;;;;;;;;;;; Treemacs
-(use-package treemacs :straight t :defer t
+(use-package treemacs :ensure t :defer t
  :config (treemacs-follow-mode 1) ;; Follow the current project.
  :bind (:map icejam-keys-mode-map
              ([(hyper b)] . treemacs))) ;; Show the folder tree

-(use-package treemacs-all-the-icons :defer t :requires (treemacs) :straight t
+(use-package treemacs-all-the-icons :defer t :requires (treemacs) :ensure t
  :config
  (treemacs-load-theme "all-the-icons")
  (treemacs-project-follow-mode t))
@ -127,14 +127,14 @@
 ;;;;;;;;;;;;;;;;; Record frequency of different commands. Review them later
 (use-package keyfreq
  :defer t
-  :straight t
+  :ensure t
  :config
  (keyfreq-mode t)
  (keyfreq-autosave-mode t))

 ;;;;;;;;;;;;;;;;; Show hints about key combinations
 (use-package which-key
-  :straight t
+  :ensure t
  :config
  (setq which-key-idle-delay 0.5)
  (which-key-mode t))
--- a/lisp/icejam-company-yasnippet.el
+++ b/lisp/icejam-company-yasnippet.el
@ -3,37 +3,36 @@
 ;;; Company completion framework configuration
 ;;; Code:

-(use-package yasnippet
-  :straight t
-  :defer t)
+(use-package yasnippet :ensure t
+  :config
+  (yas-global-mode t))

 (use-package yasnippet-snippets
-  :straight t
-  :defer t
+  :ensure t
  :requires (yasnippet)
  :config
  (unbind-key "C-c & C-n" yas-minor-mode-map)
  (unbind-key "C-c & C-s" yas-minor-mode-map)
  (unbind-key "C-c & C-v" yas-minor-mode-map))

-(yas-global-mode t)
-
 (use-package company
  :commands (company-indent-or-complete-common company-yasnippet)
+  :ensure t
+  :config (global-company-mode t)
+  :demand t
  :requires (yasnippet
-             yasnippet-snippets)
-  :straight t
-  :defer t)
+             yasnippet-snippets))

 (use-package company-box
-  :straight t
+  :ensure t
  :defer t
  :requires (company)
-  :hook (((company-mode) . company-box-mode)))
+  :hook (company-mode . company-box-mode))

-(global-company-mode t)
+;; (global-company-mode t)

 ;; Hacks for orderless
+(with-eval-after-load 'company
 (defun just-one-face (fn &rest args)
  (let ((orderless-match-faces [completions-common-part]))
    (apply fn args)))
@ -99,7 +98,7 @@

 (define-key text-mode-map (kbd "C-c y") 'company-yasnippet)
 (define-key text-mode-map (kbd "<f13>") 'icejam-insert-space-and-complete)
-(define-key text-mode-map (kbd "TAB") 'company-indent-or-complete-common)
+(define-key text-mode-map (kbd "TAB") 'company-indent-or-complete-common))

 (provide 'icejam-company-yasnippet)
 ;;; icejam-company-yasnippet.el ends here
--- a/lisp/icejam-completing-read.el
+++ b/lisp/icejam-completing-read.el
@ -5,7 +5,7 @@

 (require 'icejam-keys-mode)

-(use-package vertico :straight t :defer t
+(use-package vertico :ensure t :defer t
  :init
  (vertico-mode)
  :custom
@ -42,7 +42,7 @@
  (add-hook 'minibuffer-setup-hook #'cursor-intangible-mode))

 ;; Optionally use the `orderless' completion style.
-(use-package orderless :straight t :defer t
+(use-package orderless :ensure t :defer t
  :custom
  ;; Configure a custom style dispatcher (see the Consult wiki)
  ;; (orderless-style-dispatchers '(+orderless-consult-dispatch orderless-affix-dispatch))
@ -51,9 +51,9 @@
  (completion-category-defaults nil)
  (completion-category-overrides '((file (styles partial-completion)))))

-(use-package marginalia :straight t :defer t :init (marginalia-mode))
-(use-package consult :straight t :defer t)
-(use-package helpful :straight t :defer t)
+(use-package marginalia :ensure t :defer t :init (marginalia-mode))
+(use-package consult :ensure t :defer t)
+(use-package helpful :ensure t :defer t)

 (with-eval-after-load 'consult
  (define-key icejam-keys-mode-map (kbd "C-c a") 'consult-ripgrep)
--- a/lisp/icejam-copilot.el
+++ b/lisp/icejam-copilot.el
@ -10,34 +10,39 @@

 ;;; Code:
 (use-package copilot
-  :straight (:host github :repo "copilot-emacs/copilot.el" :files ("*.el"))
-  :ensure t)
+  :ensure (:host github :repo "copilot-emacs/copilot.el" :files ("*.el"))
+  :bind (:map copilot-completion-map
+              ("<tab>" . copilot-accept-completion)
+              ("TAB" . copilot-accept-completion)))

 ;; Do not enable copilot by default because it sorta sucks?
 ;; (add-hook 'prog-mode-hook 'copilot-mode)
-(define-key copilot-completion-map (kbd "<tab>") 'copilot-accept-completion)
-(define-key copilot-completion-map (kbd "TAB") 'copilot-accept-completion)
+;; (define-key copilot-completion-map (kbd "<tab>") 'copilot-accept-completion)
+;; (define-key copilot-completion-map (kbd "TAB") 'copilot-accept-completion)

 ;; Enable Anthropic Claude LLM support for chat (it also sucks)
-(use-package gptel :straight t :ensure t)
-
 (defcustom anthropic-api-key "api-key" "The value of your Anthropic API key."
  :type 'string
  :group 'icejam
  :initialize 'custom-initialize-set)

-(setq
- gptel-model "claude-3-5-sonnet-20240620"
- gptel-backend (gptel-make-anthropic "Claude" :stream t :key (lambda () anthropic-api-key)))
+(use-package gptel :ensure t
+  :config
+  (setq
+   gptel-model "claude-3-5-sonnet-20240620"
+   gptel-backend (gptel-make-anthropic "Claude"
+                   :stream t
+                   :key (lambda () anthropic-api-key))))
+

 ;; Pretend to be 'AI editor'.
-(use-package elysium :straight t :ensure t
-  :custom (elysium-window-size 0.33) ; The elysium buffer will be 1/3 your screen
+(use-package elysium :ensure t
+  :custom
+  (elysium-window-size 0.33) ; The elysium buffer will be 1/3 your screen
  (elysium-window-style 'vertical)) ; Can be customized to horizontal

 ;; Merging with SMerge
-(require 'smerge-mode)
-(add-hook 'prog-mode-hook 'smerge-mode)
+(use-package smerge-mode :ensure nil :hook (prog-mode . smerge-mode))

 (provide 'icejam-copilot)
 ;;; icejam-copilot.el ends here
--- a/lisp/icejam-custom-init.el
+++ b/lisp/icejam-custom-init.el
@ -14,21 +14,55 @@
 (setq gc-cons-threshold 500000000)
 (setq gc-cons-percentage 0.6)

-;;; Use straight.el for package management
-(defvar bootstrap-version)
-(let ((bootstrap-file
-       (expand-file-name "straight/repos/straight.el/bootstrap.el" user-emacs-directory))
-      (bootstrap-version 5))
-  (unless (file-exists-p bootstrap-file)
-    (with-current-buffer
-        (url-retrieve-synchronously
-         "https://raw.githubusercontent.com/raxod502/straight.el/develop/install.el"
-         'silent 'inhibit-cookies)
-      (goto-char (point-max))
-      (eval-print-last-sexp)))
-  (load bootstrap-file nil 'nomessage))
+;;; Use elpaca for package management.
+(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 :depth 1
+                              :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)
+    (load "./elpaca-autoloads")))
+(add-hook 'after-init-hook #'elpaca-process-queues)
+(elpaca `(,@elpaca-order))

-(straight-use-package 'use-package)
+(elpaca elpaca-use-package
+  ;; Enable use-package :ensure support for Elpaca.
+  (elpaca-use-package-mode))
+
+
+(defun icejam-elpaca-write-lock ()
+  "Write elpaca lock file."
+  (interactive)
+  (elpaca-write-lockfile (concat user-emacs-directory "elpaca.lock")))

 ;; I don't know why this needs to be here and with a lisp directory, but
 ;; normal subdirs.el file doesn't work.
@ -57,14 +91,14 @@
 (require 'icejam-vundo)
 (require 'icejam-speed-type)

-;; Themes
+;; ;; Themes
 (require 'icejam-themes)
 (require 'icejam-fonts)

-;; Actual supported languages and file syntax.
+;; ;; Actual supported languages and file syntax.
 (require 'icejam-lang-clang)
 (require 'icejam-lang-clojure)
-(require 'icejam-lang-common-lisp)
+;; ;; (require 'icejam-lang-common-lisp)
 (require 'icejam-lang-dart)
 (require 'icejam-lang-dhall)
 (require 'icejam-lang-elisp)
@ -89,7 +123,7 @@
 (require 'icejam-lang-web)
 (require 'icejam-lang-ziglang)

-;; Diminish modeline litter
+;; ;; Diminish modeline litter
 (require 'icejam-diminish)

 ;; Restore GC to normal, but still high
--- a/lisp/icejam-dashboard.el
+++ b/lisp/icejam-dashboard.el
@ -11,7 +11,7 @@
 ;;; Code:

 (use-package dashboard
-  :straight t
+  :ensure (:wait t)
  :config
  (dashboard-setup-startup-hook)

--- a/lisp/icejam-deft.el
+++ b/lisp/icejam-deft.el
@ -7,7 +7,7 @@
 (require 'icejam-transient)

 (use-package deft
-  :straight t
+  :ensure t
  :defer t
  :config (setq
           deft-directory (substitute-in-file-name "$DEFT_PATH")
--- a/lisp/icejam-diminish.el
+++ b/lisp/icejam-diminish.el
@ -9,7 +9,7 @@
 ;; diminish minor modes

 ;;; Code:
-(use-package diminish :straight t)
+(use-package diminish :ensure (:wait t))

 (eval-after-load 'flyspell '(diminish 'flyspell-mode))
 (eval-after-load 'flycheck '(diminish 'flycheck-mode))
--- a/lisp/icejam-flycheck.el
+++ b/lisp/icejam-flycheck.el
@ -3,11 +3,10 @@
 ;;; Code:

 ;; Use flycheck globally to check syntax and compile languages
-(use-package flycheck
-  :commands flycheck-define-checker
-  :straight t
-  :defer t
-  :config (global-flycheck-mode t)
+(use-package flycheck :ensure t)
+
+(with-eval-after-load 'flycheck
+  (global-flycheck-mode t)
  (setq flycheck-emacs-lisp-load-path 'inherit)
  (unbind-key "C-c ! C-c" flycheck-mode-map)
  (unbind-key "C-c ! C-w" flycheck-mode-map)
--- a/lisp/icejam-ispell.el
+++ b/lisp/icejam-ispell.el
@ -4,7 +4,7 @@
 ;;; Code:

 (use-package ispell
-  :straight t
+  :ensure nil
  :config (setq ispell-program-name "aspell")
  (setq ispell-extra-args
        '("--run-together" "--run-together-limit=5" "--run-together-min=2"))
@ -17,8 +17,8 @@
                                (unbind-key "C-c $" flyspell-mode-map)
                                (unbind-key "C-M-i" flyspell-mode-map)))

-(use-package flyspell-correct :straight t :after flyspell :defer t)
-(use-package flyspell-correct-ivy :straight :after flyspell-correct :defer t)
+(use-package flyspell-correct :ensure t :after flyspell :defer t)
+(use-package flyspell-correct-ivy :ensure t :after flyspell-correct :defer t)

 (provide 'icejam-ispell)
 ;;; icejam-ispell.el ends here
--- a/lisp/icejam-lsp.el
+++ b/lisp/icejam-lsp.el
@ -8,8 +8,7 @@
 (setenv "LSP_USE_PLISTS" "true")

 (use-package lsp-mode
-  :straight t
-  :defer t
+  :ensure (:depth 5)
  :requires (company)
  :config
  (setq-default lsp-file-watch-threshold 10000
@ -70,7 +69,7 @@
  :hook ((typescript-mode . lsp-deferred)))

 (use-package lsp-ui
-  :straight t
+  :ensure t
  :requires (lsp-mode)
  :defer t
  :config
@ -82,7 +81,7 @@

 ;; Lsp debugger mode
 (use-package dap-mode
-  :straight t
+  :ensure t
  :defer t
  :requires (lsp-mode lsp-ui))

--- a/lisp/icejam-magit.el
+++ b/lisp/icejam-magit.el
@ -5,7 +5,7 @@
 (require 'icejam-keys-mode)

 (use-package magit
-  :straight t
+  :ensure t
  :defer t
  :bind (:map icejam-keys-mode-map
              ("<f5> c" . magit-checkout)
--- a/lisp/icejam-prog-mode.el
+++ b/lisp/icejam-prog-mode.el
@ -18,13 +18,13 @@
 ;;; Show trailing whitespace and remove whitespace on save
 (use-package whitespace
  :commands whitespace-mode
-  :straight t
+  :ensure nil
  :defer t
  :hook (((prog-mode text-mode conf-mode) . whitespace-mode)
         (before-save . whitespace-cleanup))
  :config
  (setq whitespace-style #'(face trailing empty)
-        ;;; Insert newline on save
+;;; Insert newline on save
        require-final-newline 't))

 (setq-default indent-tabs-mode nil)
@ -32,7 +32,7 @@
 ;; Use colorful, matching parens
 (use-package rainbow-delimiters
  :commands rainbow-delimiters-mode
-  :straight t
+  :ensure t
  :defer t
  :hook (((prog-mode text-mode) . rainbow-delimiters-mode))
  :init
@ -44,13 +44,13 @@
 ;;; Show hex (#aaa) colors as colors
 (use-package rainbow-mode
  :commands rainbow-mode
-  :straight t
+  :ensure t
  :hook ((prog-mode text-mode) . rainbow-mode))

 ;; Dash integration
 (use-package dash-at-point
  :commands dash-at-point
-  :straight t
+  :ensure t
  :defer t
  :config
  (add-to-list 'dash-at-point-mode-alist
@ -70,16 +70,16 @@
  (setq-local tab-stop-list (number-sequence step 200 step)))

 (use-package column-enforce-mode
-  :straight t
+  :ensure t
  :defer t
  :config (global-column-enforce-mode t))

 ;; PCRE to emacs regex translations
-(use-package pcre2el :straight t)
+(use-package pcre2el :ensure t)

 ;; Visual regexp
 (use-package visual-regexp-steroids
-  :straight t
+  :ensure t
  :requires (pcre2el)
  :config (setq vr/engine 'pcre2el))

--- a/lisp/icejam-speed-type.el
+++ b/lisp/icejam-speed-type.el
@ -11,7 +11,6 @@
 ;;; Code:

 (use-package speed-type
-  :straight t
  :ensure t
  :defer t)

--- a/lisp/icejam-themes.el
+++ b/lisp/icejam-themes.el
@ -2,67 +2,71 @@
 ;;; Commentary:
 ;;; Code:

-(use-package spaceline :straight t :defer t)
+(use-package spaceline :ensure t :defer t)

-(use-package base16-theme :straight t
-  :defer t
+(use-package base16-theme :ensure t
+  :init
+  (load-theme 'base16-atelier-forest-light t t)
+  (load-theme 'base16-harmonic16-light t t)
+  (load-theme 'base16-horizon-light t t)
+  (load-theme 'base16-humanoid-light t t)
+  (load-theme 'base16-zenburn t)
+  (load-theme 'base16-tomorrow-night-eighties t t)
+  (load-theme 'base16-darcula t t)
+  (load-theme 'base16-solarflare t t)
+  (load-theme 'base16-snazzy t t)
+  (load-theme 'base16-onedark t t)
+  (load-theme 'base16-gruvbox-dark-hard t t)
+  (load-theme 'modus-vivendi t t)
+  (load-theme 'base16-zenbones t t)
  :config
  ;; Set themes for terminal mode
  (setq base16-theme-256-color-source "colors"))

-(use-package apropospriate-theme :straight t :defer t)
-(use-package leuven-theme :straight t :defer t)
-(use-package modus-themes :straight t :defer t)
-(use-package darktooth-theme :straight t :defer t)
-(use-package cyberpunk-theme :straight t :defer t)
-(use-package color-theme-sanityinc-tomorrow :straight t :defer t)
-(use-package zenburn-theme :straight t :defer t)
+(use-package apropospriate-theme :ensure t
+  :init (load-theme 'apropospriate-light t t))
+(use-package leuven-theme :ensure t
+  :init
+  (load-theme 'leuven t t))
+(use-package modus-themes :ensure t)
+(use-package darktooth-theme :ensure t
+  :init
+  (load-theme 'darktooth t t))

-(use-package catppuccin-theme :straight t :defer t
+(use-package cyberpunk-theme :ensure t
+  :init
+  (load-theme 'cyberpunk t t))
+
+(use-package color-theme-sanityinc-tomorrow :ensure t
+  :init
+  ;; Dark themes
+  (load-theme 'sanityinc-tomorrow-eighties t t)
+  (load-theme 'sanityinc-tomorrow-night t t)
+  ;; Light theme
+  (load-theme 'sanityinc-tomorrow-day t t))
+
+(use-package zenburn-theme :ensure t
+  :init
+  (load-theme 'zenburn t t))
+(use-package catppuccin-theme :ensure t
+  :init (load-theme 'catppuccin t t)
  :config (setq catppuccin-flavor 'frappe))


 ;; Disable cursor blinking
 (blink-cursor-mode 0)

-;; Light themes
-(load-theme 'apropospriate-light t t)
-(load-theme 'leuven t t)
-(load-theme 'base16-atelier-forest-light t t)
-(load-theme 'base16-harmonic16-light t t)
-(load-theme 'base16-horizon-light t t)
-(load-theme 'base16-humanoid-light t t)
-(load-theme 'sanityinc-tomorrow-day t t)
-
-;; Dark themes
-(load-theme 'cyberpunk t t)
-(load-theme 'darktooth t t)
-(load-theme 'base16-zenburn t)
-(load-theme 'base16-tomorrow-night-eighties t t)
-(load-theme 'base16-darcula t t)
-(load-theme 'base16-solarflare t t)
-(load-theme 'base16-snazzy t t)
-(load-theme 'base16-onedark t t)
-(load-theme 'base16-gruvbox-dark-hard t t)
-(load-theme 'modus-vivendi t t)
-(load-theme 'base16-zenbones t t)
-(load-theme 'zenburn t t)
-(load-theme 'catppuccin t t)
-(load-theme 'sanityinc-tomorrow-eighties t t)
-(load-theme 'sanityinc-tomorrow-night t t)
-
 ;; My own theme modifications:
 (with-eval-after-load 'base16-theme
+  (setq base16-theme-256-color-source "colors")
  (require 'icejam-base16-zenburn)
-  (require 'icejam-base16-harmonic-light))
-
-(declare-function spaceline-emacs-theme nil)
+  (require 'icejam-base16-harmonic-light)
+  (enable-theme 'icejam-base16-zenburn))

 ;; This is spacemacs modeline but I have disabled it for now.
 ;; It doesn't seem like I need it for anything.
 ;; (spaceline-emacs-theme)
-
-(enable-theme 'icejam-base16-zenburn)
+(declare-function spaceline-emacs-theme nil)

 (provide 'icejam-themes)
 ;;; icejam-themes.el ends here
--- a/lisp/icejam-transient.el
+++ b/lisp/icejam-transient.el
@ -5,7 +5,7 @@

 (require 'icejam-avy)
 (require 'icejam-keys-mode)
-(use-package transient :straight t)
+(use-package transient :ensure (:wait t))

 (defun icejam-mark-and-indent-whole-buffer ()
  "Mark and indent whole buffer."
--- a/lisp/icejam-tree-sitter.el
+++ b/lisp/icejam-tree-sitter.el
@ -22,11 +22,11 @@
        (make-symbolic-link file target)))))

 ;;;;;;;;;;;;;;;;;;;;;; Tree sitter ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(use-package tree-sitter-langs :straight t
+(use-package tree-sitter-langs :ensure t
  :config
  (add-to-list 'treesit-extra-load-path (tree-sitter-langs--bin-dir)))

-;; (use-package tree-sitter-indent :straight t)
+;; (use-package tree-sitter-indent :ensure t)
 (add-hook 'tree-sitter-after-on-hook 'tree-sitter-hl-mode)

 (provide 'icejam-tree-sitter)
--- a/lisp/icejam-vundo.el
+++ b/lisp/icejam-vundo.el
@ -11,9 +11,7 @@
 ;;; Code:

 ;;;;;;;;;;;;;;;;; Use more advanced undo options
-(use-package vundo
-  :straight t
-  :defer t)
+(use-package vundo :ensure t :defer t)

 (provide 'icejam-vundo)
 ;;; icejam-vundo.el ends here
--- a/lisp/langs/icejam-lang-clojure.el
+++ b/lisp/langs/icejam-lang-clojure.el
@ -7,19 +7,19 @@

 (declare-function column-enforce-n "column-enforce-mode" (number))

-(use-package clojure-mode :defer t :straight t)
+(use-package clojure-mode :defer t :ensure t)

 (use-package cider
  :requires clojure-mode
  :commands cider-jack-in
  :defer t
-  :straight t
+  :ensure t
  :config (setq cider-annotate-completion-function t))

 (use-package clj-refactor
 	:requires (cider clojure-mode)
 	:defer t
-	:straight t)
+	:ensure t)

 ;; Transient
 (transient-define-prefix icejam-lang-cider-context-menu ()
--- a/lisp/langs/icejam-lang-common-lisp.el
+++ b/lisp/langs/icejam-lang-common-lisp.el
@ -11,8 +11,8 @@
 (require 'icejam-prog-mode)
 (require 'icejam-company-yasnippet)

-(use-package slime :straight t)
-(use-package slime-company :straight t
+(use-package slime :ensure t)
+(use-package slime-company :ensure t
  :requires (slime company))

 (setq inferior-lisp-program "sbcl")
--- a/lisp/langs/icejam-lang-dart.el
+++ b/lisp/langs/icejam-lang-dart.el
@ -4,8 +4,8 @@

 (require 'icejam-prog-mode)

-(use-package dart-mode :straight t :defer t)
-(use-package lsp-dart :defer t :straight t :requires (dart-mode lsp))
+(use-package dart-mode :ensure t :defer t)
+(use-package lsp-dart :defer t :ensure t :requires (dart-mode lsp))

 (defun icejam-lang-activate-dart-mode ()
  "Reconfigure dart mode for your own purposes."
--- a/lisp/langs/icejam-lang-dhall.el
+++ b/lisp/langs/icejam-lang-dhall.el
@ -5,7 +5,7 @@
 (require 'icejam-prog-mode)
 (require 'icejam-lsp)

-(use-package dhall-mode :straight t :defer t :requires (lsp))
+(use-package dhall-mode :ensure t :defer t :requires (lsp))

 (defun icejam-lang-activate-dhall-mode ()
  "Reconfigure dhall mode for your own purposes."
--- a/lisp/langs/icejam-lang-elisp.el
+++ b/lisp/langs/icejam-lang-elisp.el
@ -5,7 +5,7 @@
 (require 'icejam-prog-mode)
 (require 'icejam-transient)

-(use-package lispy :straight t :defer t)
+(use-package lispy :ensure (:wait t) :defer t)

 (declare-function column-enforce-n "column-enforce-mode" (number))
 (add-to-list 'auto-mode-alist '("/Eask\\'" . emacs-lisp-mode))
--- a/lisp/langs/icejam-lang-elixir.el
+++ b/lisp/langs/icejam-lang-elixir.el
@ -9,13 +9,13 @@
 (declare-function lsp "lsp-mode" nil)
 (declare-function column-enforce-n "column-enforce-mode" (number))

-(use-package elixir-mode :defer t :straight t)
-(use-package elixir-ts-mode :straight t
-  :requires (elixir-mode lsp-mode lsp-ui)
-  :defines (elixir-ts-mode-map))
+(use-package elixir-mode :defer t :ensure t)

-(add-to-list 'auto-mode-alist '("\\.exs\\'" . elixir-ts-mode))
-(add-to-list 'auto-mode-alist '("\\.ex\\'" . elixir-ts-mode))
+(use-package elixir-ts-mode :ensure t
+  :requires (elixir-mode lsp-mode lsp-ui)
+  :mode
+  ("\\.exs\\'" . elixir-ts-mode)
+  ("\\.ex\\'" . elixir-ts-mode))

 (transient-define-prefix icejam-elixir-lang-menu ()
  "Elixir Buffer Commands."
--- a/lisp/langs/icejam-lang-erlang.el
+++ b/lisp/langs/icejam-lang-erlang.el
@ -10,7 +10,7 @@

 (use-package erlang
  :defer t
-  :straight t
+  :ensure (:depth 1)
  :requires (lsp-mode lsp-ui))

 (cl-defun icejam-erlang-emacs-path (erlang-version)
--- a/lisp/langs/icejam-lang-fsharp.el
+++ b/lisp/langs/icejam-lang-fsharp.el
@ -15,7 +15,7 @@

 (use-package fsharp-mode
  :requires (lsp-mode lsp-ui)
-  :straight t
+  :ensure t
  :defer t)

 (defun icejam-activate-fsharp-mode ()
--- a/lisp/langs/icejam-lang-gleam.el
+++ b/lisp/langs/icejam-lang-gleam.el
@ -13,10 +13,10 @@
 (require 'icejam-prog-mode)

 (use-package gleam-ts-mode
-  :straight '(:type git
-              :host github
-              :repo "gleam-lang/gleam-mode"
-              :files ("gleam-ts-mode.el")))
+  :ensure (:type git
+                 :host github
+                 :repo "gleam-lang/gleam-mode"
+                 :files ("gleam-ts-mode.el")))

 (add-to-list 'auto-mode-alist '("\\.gleam\\'" . gleam-ts-mode))

--- a/lisp/langs/icejam-lang-golang.el
+++ b/lisp/langs/icejam-lang-golang.el
@ -15,7 +15,7 @@
 (use-package go-mode
  :requires (lsp-mode lsp-ui)
  :defer t
-  :straight t)
+  :ensure t)

 (defun icejam-activate-golang-mode ()
  "Activate my own Golang mode settings."
--- a/lisp/langs/icejam-lang-haskell.el
+++ b/lisp/langs/icejam-lang-haskell.el
@ -13,11 +13,11 @@
 (require 'icejam-prog-mode)

 (use-package haskell-mode
-  :straight t
+  :ensure t
  :defer t)

 (use-package lsp-haskell
-  :straight t
+  :ensure t
  :defer t
  :requires (lsp-mode lsp-ui haskell-mode))

--- a/lisp/langs/icejam-lang-javascript.el
+++ b/lisp/langs/icejam-lang-javascript.el
@ -8,12 +8,12 @@

 (use-package js2-mode
  :requires (web-mode company-web lsp-mode lsp-ui)
-  :straight t)
+  :ensure t)

-(use-package typescript-mode :straight t)
+(use-package typescript-mode :ensure t)

 ;; (use-package vue-mode
-;;   :straight t
+;;   :ensure t
 ;;   :defer t)

 ;; Use js2-mode for javascript editing
--- a/lisp/langs/icejam-lang-kotlin.el
+++ b/lisp/langs/icejam-lang-kotlin.el
@ -12,11 +12,11 @@

 (use-package kotlin-mode
 	:defer t
-	:straight t)
+	:ensure t)

 (use-package gradle-mode
 	:defer t
-	:straight t)
+	:ensure t)

 (defun icejam-activate-kotlin-mode ()
  "All things Kotlin."
--- a/lisp/langs/icejam-lang-lean.el
+++ b/lisp/langs/icejam-lang-lean.el
@ -6,11 +6,11 @@
 (require 'icejam-lsp)

 (use-package lean4-mode
-  :straight (lean4-mode
-	           :type git
-	           :host github
-	           :repo "leanprover/lean4-mode"
-	           :files ("*.el" "data"))
+  :ensure (lean4-mode
+	   :type git
+	   :host github
+	   :repo "leanprover/lean4-mode"
+	   :files ("*.el" "data"))
  :requires (lsp)
  :defer t)

--- a/lisp/langs/icejam-lang-markdown.el
+++ b/lisp/langs/icejam-lang-markdown.el
@ -4,10 +4,11 @@

 (require 'icejam-prog-mode)

-(use-package markdown-mode
-  :straight t
-  :defer t
-  :init (setq-default markdown-command "pandoc"))
+(unless (elpaca-installed-p 'markdown-mode)
+  (use-package markdown-mode
+    :ensure t
+    :defer t
+    :init (setq-default markdown-command "pandoc")))

 (defun icejam-lang-activate-markdown-mode ()
  "Reconfigure markdown mode for your own purposes."
--- a/lisp/langs/icejam-lang-ocaml.el
+++ b/lisp/langs/icejam-lang-ocaml.el
@ -6,12 +6,12 @@
 (require 'icejam-prog-mode)
 (declare-function lsp "lsp-mode" nil)

-(use-package merlin :defer t :straight t)
-(use-package opam-switch-mode :straight t :defer t)
-(use-package dune :defer t :straight t)
+(use-package merlin :defer t :ensure t)
+(use-package opam-switch-mode :ensure t :defer t)
+(use-package dune :defer t :ensure t)
 (use-package tuareg
  :defer t
-  :straight t
+  :ensure t
  :config (add-hook 'tuareg-mode-hook 'merlin-mode))

 (transient-define-prefix icejam-ocaml-lang-menu ()
--- a/lisp/langs/icejam-lang-other.el
+++ b/lisp/langs/icejam-lang-other.el
@ -11,29 +11,34 @@
 ;;; Code:

 ;; Infrastructure files
-(use-package dockerfile-mode :straight t :defer t)
-(use-package docker :straight t :defer t :ensure t)
-(use-package terraform-mode :straight t :defer t)
-(use-package ansible :straight t :defer t)
-(use-package nginx-mode :straight t :defer t)
-(use-package jenkinsfile-mode :straight t :defer t)
-(use-package lua-mode :straight t :defer t)
-(use-package graphql-mode :straight t :defer t)
-(add-to-list 'auto-mode-alist '("\\.graphqls\\'" . graphql-mode))
+(use-package dockerfile-mode :ensure t :defer t)
+(use-package docker :ensure t :defer t)
+(use-package terraform-mode :ensure t :defer t)
+(use-package ansible :ensure t :defer t)
+(use-package nginx-mode :ensure t :defer t)
+(use-package jenkinsfile-mode :ensure t :defer t)
+(use-package lua-mode :ensure t :defer t)
+
+;; Graphql schema definition files.
+(use-package graphql-mode :ensure t :defer t
+  :mode ("\\.graphqls\\'" . graphql-mode))

 ;; Yaml
-(use-package yaml-mode :straight t :defer t :requires (lsp))
+(declare-function lsp "lsp-mode" nil)
+(use-package yaml-mode :ensure t :defer t :requires (lsp))

-(defun icejam-lang-activate-yaml-mode ()
-  "Activate yaml-mode."
-  (lsp))
+(with-eval-after-load 'yaml-mode
+  (defun icejam-lang-activate-yaml-mode ()
+    "Activate yaml-mode."
+    (lsp))
+
+  (add-hook 'yaml-mode-hook 'icejam-lang-activate-yaml-mode))

-(add-hook 'yaml-mode-hook 'icejam-lang-activate-yaml-mode)

 ;; Other text files
-(use-package json-mode :straight t :defer t)
+(use-package json-mode :ensure t :defer t)
 (use-package git-modes
-  :straight t
+  :ensure t
  :defer t
  :hook ((gitignore-mode . whitespace-mode)
         (before-save . whitespace-cleanup)))
--- a/lisp/langs/icejam-lang-php.el
+++ b/lisp/langs/icejam-lang-php.el
@ -16,7 +16,7 @@

 (use-package php-mode
  :requires (lsp-mode lsp-ui)
-  :straight t)
+  :ensure t)

 (transient-define-prefix icejam-lang-php/context-menu ()
  "PHP Buffer Commands."
--- a/lisp/langs/icejam-lang-purescript.el
+++ b/lisp/langs/icejam-lang-purescript.el
@ -11,7 +11,7 @@
 ;;; Code:
 (use-package purescript-mode
  :requires (lsp-mode lsp-ui)
-  :straight t)
+  :ensure t)

 (defun icejam-activate-purescript-mode ()
  "All things Purescript."
--- a/lisp/langs/icejam-lang-ruby.el
+++ b/lisp/langs/icejam-lang-ruby.el
@ -4,9 +4,9 @@

 (require 'icejam-prog-mode)

-(use-package rspec-mode :straight t :defer t)
-(use-package ruby-end :straight t :defer t)
-(use-package rbs-mode :straight t :defer t)
+(use-package rspec-mode :ensure t :defer t)
+(use-package ruby-end :ensure t :defer t)
+(use-package rbs-mode :ensure t :defer t)

 (add-to-list 'auto-mode-alist '("\\.rb\\'" . ruby-ts-mode))

--- a/lisp/langs/icejam-lang-rust.el
+++ b/lisp/langs/icejam-lang-rust.el
@ -5,13 +5,13 @@
 (require 'icejam-prog-mode)

 (use-package rust-mode
-  :straight t
+  :ensure t
  :defer t
  :config
  (setq rust-mode-treesitter-derive t))

 (use-package flycheck-rust
-  :straight t
+  :ensure t
  :defer t
  :requires (rust-mode lsp))

--- a/lisp/langs/icejam-lang-sh.el
+++ b/lisp/langs/icejam-lang-sh.el
@ -2,7 +2,7 @@
 ;;; Commentary:
 ;;; Code:

-(use-package fish-mode :straight t :defer t)
+(use-package fish-mode :ensure t :defer t)

 (add-to-list 'auto-mode-alist '("\\.zsh\\'" . sh-mode))
 (add-to-list 'auto-mode-alist '("\\zshrc\\'" . sh-mode))
--- a/lisp/langs/icejam-lang-web.el
+++ b/lisp/langs/icejam-lang-web.el
@ -7,7 +7,7 @@

 (use-package web-mode
  :requires (lsp-mode flycheck)
-  :straight t)
+  :ensure t)

 ;; Eex Web mode
 (add-to-list 'auto-mode-alist '("\\.eex\\'" . web-mode))
--- a/lisp/langs/icejam-lang-ziglang.el
+++ b/lisp/langs/icejam-lang-ziglang.el
@ -11,7 +11,7 @@
 ;;; Code:
 (require 'icejam-prog-mode)

-(use-package zig-mode :straight t :defer t :requires (lsp))
+(use-package zig-mode :ensure t :defer t :requires (lsp))

 (defun icejam-activate-zig-mode ()
  "Goodies for editing zig files."
--- a/lisp/themes/icejam-base16-harmonic-light.el
+++ b/lisp/themes/icejam-base16-harmonic-light.el
@ -8,7 +8,6 @@
 ;;; Code:

 (declare-function base16-theme-define (theme-name colors))
-(use-package base16-theme :straight t :defer t)

 (defvar icejam-base16-harmonic-light-colors
  '(:base00 "#f7f9fb"
@ -33,7 +32,9 @@
 (deftheme icejam-base16-harmonic-light)

 ;; Add all the faces to the theme
-(base16-theme-define 'icejam-base16-harmonic-light icejam-base16-harmonic-light-colors)
+(with-eval-after-load 'base16-theme
+  (base16-theme-define
+   'icejam-base16-harmonic-light icejam-base16-harmonic-light-colors))

 ;; Mark the theme as provided
 (provide-theme 'icejam-base16-harmonic-light)
--- a/lisp/themes/icejam-base16-not-harmonic.el
+++ b/lisp/themes/icejam-base16-not-harmonic.el
@ -5,7 +5,7 @@
 ;; Based on harmonic-dark theme by Jannik Seibert (https://github.com/janniks)
 ;;; Code:

-(use-package base16-theme :straight t :defer t)
+(use-package base16-theme :ensure t :defer t)

 (defvar base16-not-harmonic-colors
  '(:base00 "#102941"
--- a/lisp/themes/icejam-base16-summerfruit-light.el
+++ b/lisp/themes/icejam-base16-summerfruit-light.el
@ -7,7 +7,7 @@

 ;;; Code:

-(use-package base16-theme :straight t :defer t)
+(use-package base16-theme :ensure t :defer t)

 (defvar base16-summerfruit-light-modified-colors
  '(:base00 "#fdfcfa"
--- a/lisp/themes/icejam-base16-zenburn.el
+++ b/lisp/themes/icejam-base16-zenburn.el
@ -16,7 +16,6 @@
 ;; 04 made darker by 5%   #808080 => #7a7a7a
 ;; 0B made lighter by 10% #5f7f5f => #799979

-(use-package base16-theme :straight t)
 (declare-function base16-theme-define "base16-theme" (theme-name theme-colors))

 (defvar icejam-base16-zenburn-colors
@ -42,7 +41,8 @@
 (deftheme icejam-base16-zenburn)

 ;; Add all the faces to the theme
-(base16-theme-define 'icejam-base16-zenburn icejam-base16-zenburn-colors)
+(with-eval-after-load 'base16-theme
+  (base16-theme-define 'icejam-base16-zenburn icejam-base16-zenburn-colors))

 ;; Mark the theme as provided
 (provide-theme 'icejam-base16-zenburn)