Modular GNU Emacs Configuration

#e.g., on Fedora:
sudo dnf install emacs

(message (emacs-version))

# e.g., on Fedora:
sudo dnf install rustup
rustup-init
rustup component add rust-analyzer

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
rustup component add rust-analyzer

;; this example declares the "just" crate needs to be installed.
;; (the actual install is deferred until later):
(my/cargo-dependency "just")

#e.g., Fedora:
sudo dnf install git

git clone https://github.com/EnigmaCurry/emacs.git \
    ~/git/vendor/enigmacurry/emacs

#on e.g., Fedora
sudo dnf install libtree-sitter

emacs --init-directory ~/git/vendor/enigmacurry/emacs

ln -s ~/git/vendor/enigmacurry/emacs ~/.emacs.d

;; core libraries
(require 'cl-lib)

;; Nice defaults
(setq-default confirm-kill-emacs #'yes-or-no-p)
(setq-default vc-follow-symlinks t)
(setq-default indicate-empty-lines t)
(setq-default indicate-buffer-boundaries 'left)
(setq-default sentence-end-double-space nil)
(setq-default indent-tabs-mode nil)
(setq-default tab-width 4)
(setq-default visible-bell t)
(setq-default dired-listing-switches "-al --group-directories-first")
(setq-default tramp-default-method "ssh")
(setq-default native-comp-deferred-compilation-deny-list nil)
(setq-default browse-url-browser-function 'browse-url-firefox)
(put 'narrow-to-region 'disabled nil)
(put 'downcase-region 'disabled nil)
(put 'upcase-region 'disabled nil)

;; Backups and auto-save
;; Reference: https://www.emacswiki.org/emacs/BackupDirectory
;; Reference: https://www.emacswiki.org/emacs/ForceBackups
(setq backup-by-copying t)
(setq backup-directory-alist
      `(("." . ,(expand-file-name "backup" user-emacs-directory))))
(setq delete-old-versions t)
(setq kept-new-versions 6)
(setq kept-old-versions 2)
(setq version-control t)
(setq vc-make-backup-files t)
(add-hook 'before-save-hook
          (lambda () (setq buffer-backed-up nil)))
;; autosaves go in a separate directory
(let ((auto-save-dir (expand-file-name "auto-save" user-emacs-directory)))
  (make-directory auto-save-dir t)
  (setq auto-save-file-name-transforms
        `((".*" ,auto-save-dir t))))

;; Store customizations in custom.el
(setq custom-file (locate-user-emacs-file "custom.el"))
(when (file-exists-p custom-file)
  (load custom-file))
;; Store all customizations under my/custom-settings group
(defgroup my/custom-settings nil
  "My custom Emacs settings"
  :group 'emacs)
;; Shortcut to open custom settings:
(defun my/custom-settings ()
  "Open the Emacs customization interface for my custom settings."
  (interactive)
  (customize-group 'my/custom-settings))
(defalias 'my/settings 'my/custom-settings)

;; Global minor modes
(column-number-mode)
(save-place-mode t)
(savehist-mode t)
(recentf-mode t)
(electric-pair-mode t)

;; Function to add a directory to PATH and exec-path
(defun my/add-exec-path (dir)
  "Add DIR to the environment PATH and exec-path if not already present."
  (unless (member dir exec-path)
    (setenv "PATH" (concat dir path-separator (getenv "PATH")))
    (add-to-list 'exec-path dir)))

;; Basic programming mode settings
(setq-default display-fill-column-indicator-column 80)
(add-hook 'prog-mode-hook (lambda ()
                            (setq show-trailing-whitespace t)
                            (display-fill-column-indicator-mode 1)
                            (display-line-numbers-mode 1)))

(defun my/shell-execute (command &optional interactive)
  "Run a given shell COMMAND in a new buffer and display its output."
  (interactive)
  (let* ((command-name (car (split-string command)))
         (buffer-name (generate-new-buffer-name (concat "*" command-name " Output*")))
         (buffer (get-buffer-create buffer-name)))
    (with-current-buffer buffer
      (erase-buffer)
      (insert "## Running shell process ...\n"))
    (start-process-shell-command
     command
     buffer
     command)
    (pop-to-buffer buffer)))

(my/add-exec-path "~/.cargo/bin")
(unless (executable-find "cargo")
  (message "cargo binary NOT found."))

 (require 'seq)
 (require 'comint)

 (defun my/cargo-package-installed-p (package)
   "Check if a given cargo PACKAGE is installed.
       PACKAGE can be either a string or a cons cell (CRATE . GIT-URL).
       In either case, this function uses the crate name for the check."
   (let ((pkg (if (consp package) (car package) package)))
     (with-temp-buffer
       (when (eq 0 (call-process "cargo" nil t nil "install" "--list"))
         (goto-char (point-min))
         (search-forward pkg nil t)))))
(defun my/cargo-install (programs)
   "Install a list of PROGRAMS via `cargo install`, skipping those already installed.
 PROGRAMS can be:
 - a single string (with space-separated program names),
 - a list of strings,
 - or a list where some elements are cons cells (CRATE . GIT-REPO).

 For cons cell entries, Cargo is invoked with the --git flag."
   (unless programs
     (user-error "No programs specified for cargo install"))
   ;; If PROGRAMS is a string, split it into a list.
   (setq programs (if (stringp programs)
                      (split-string programs)
                    programs))
   ;; Remove already installed programs.
   (setq programs (seq-remove #'my/cargo-package-installed-p programs))
   ;; Separate into two groups:
   ;;   - crates from crates.io (plain strings or cons cells treated as a name only)
   ;;   - git dependencies (explicit cons cells)
   (let ((crate-names (mapcar (lambda (dep)
                                (if (consp dep)
                                    (car dep)
                                  dep))
                              (seq-filter (lambda (dep)
                                            (not (consp dep)))
                                          programs)))
         (git-deps (seq-filter #'consp programs)))
     ;; Install crates from crates.io in one command, if any.
     (when crate-names
       (let ((command (concat "cargo install " (string-join crate-names " "))))
         (my/shell-execute command)))
     ;; Install each git dependency separately.
     (dolist (dep git-deps)
       (let* ((crate (car dep))
              (git-repo (cdr dep))
              (command (format "cargo install %s --git %s" crate git-repo)))
         (my/shell-execute command)))))
 (defvar my/cargo-dependencies nil
   "A list of Rust crate dependencies to be installed.
         Each dependency is either a crate name (a symbol or string) or a cons cell
         of the form (CRATE . GIT-REPO).")

 (defun my/cargo-dependency (crate &optional git-repo)
   "Add a Rust CRATE to the list of dependencies.
         If GIT-REPO is provided, the dependency is stored as (CRATE . GIT-REPO).
         Otherwise, only CRATE is stored.
         If the dependency (by crate name) already exists, do nothing."
   (unless (cl-find crate my/cargo-dependencies
                    :test (lambda (d c)
                            (if (consp d)
                                (equal (car d) c)
                              (equal d c))))
     (push (if git-repo (cons crate git-repo) crate)
           my/cargo-dependencies)))

;; depend on the just crate so its installed automatically
;; you must add "just" to the list of my/machine-labels for this to work:
(my/cargo-dependency "just")

set export
current_dir := `pwd`

# Print this help message for the Justfile targets
help:
    @just -l

# Clean pacage cache
clean:
    rm -rf straight eln-cache

(defun my/bootstrap-straight (&rest _)
  "Bootstrap straight.el only if it's not already installed."
  (unless (bound-and-true-p straight--build-dir)
    (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)
      (setq straight-use-package-by-default t)
      (straight-use-package 'use-package))))
;; Advise `use-package` to initialize straight.el when first called
(advice-add 'use-package :before #'my/bootstrap-straight)

(defvar my/use-package-tracked-list nil
  "A list to track the names of packages declared via `use-package`.")
(defun my/use-package-tracked-list ()
  "Display the tracked `use-package` packages in a new buffer, one per line.
If the buffer already exists, delete it and recreate it."
  (interactive)
  (let ((buffer-name "*Tracked Packages*"))
    (when (get-buffer buffer-name)
      (kill-buffer buffer-name))
    (let ((buffer (get-buffer-create buffer-name)))
      (with-current-buffer buffer
        (erase-buffer)
        (insert "# Packages tracked via use-package:\n")
        (if my/use-package-tracked-list
            (dolist (pkg (sort my/use-package-tracked-list #'string<))
              (insert (format "%s\n" pkg)))
          (insert "No packages tracked.\n"))
        (read-only-mode 1))
      (pop-to-buffer buffer))))
(defun my/use-package-advice (orig-fun &rest args)
  "Advice around `use-package' to track package names."
  (when (symbolp (car args))
    (push (symbol-name (car args)) my/use-package-tracked-list)
    (setq my/use-package-tracked-list (delete-dups my/use-package-tracked-list)))
  (apply orig-fun args))

(advice-add 'use-package :around #'my/use-package-advice)

(defgroup my/theme-settings nil
  "My custom theme settings"
  :group 'my/custom-settings)
(defcustom my/theme 'deeper-blue
  "Emacs Theme"
  :type 'symbol
  :group 'my/theme-settings)

(defun my/theme-update (theme-fn)
  "Update the `my/theme` variable with the new theme and call THEME-FN."
  (let ((current-theme (car custom-enabled-themes)))
    (funcall theme-fn)
    (customize-set-variable 'my/theme (car custom-enabled-themes))
    (customize-save-customized)
    (message "Theme changed to: %s" my/theme)))

;; Install themes directly from a git repository:
;;;NOTE: don't use deep-thought-theme it crashes Emacs 29.4!!
;;;Keeping this here as an example for loading a theme from git:
;; (use-package
;;   deep-thought-theme
;;   :straight
;;   (deep-thought-theme :type git :repo "https://github.com/emacsfodder/emacs-deep-thought-theme.git"))
(use-package solaire-mode :init (solaire-global-mode +1))
(use-package theme-looper
  :general
  ("C-<f11>" (lambda () (interactive) (my/theme-update 'theme-looper-enable-previous-theme)))
  ("C-<f12>"  (lambda () (interactive) (my/theme-update 'theme-looper-enable-next-theme))))

(load-theme my/theme t)

(use-package
  general
  :init
  ;; Switch between two most recent buffers:
  (fset 'quick-switch-buffer [?\C-x ?b return])
  :config
   ;;; Custom global bindings:
  (general-define-key
   "C-h B"     'general-describe-keybindings
   "s-b"       'quick-switch-buffer
   "s-B"       'buffer-menu-other-window
   "C-x B"     'buffer-menu-other-window
   "s-o"       'browse-url
   "C-;"       'comment-region ; C-u C-; to uncomment
   "s-<down-mouse-1>"       'mouse-drag-region-rectangle
   "C-x j"     'jump-to-register
   "C-c j"     'jump-to-register
   "C-<f1>"    'my/register-jump-f1
   "M-<f1>"    'my/register-save-f1
   "C-<f2>"    'my/register-jump-f2
   "M-<f2>"    'my/register-save-f2
   "C-<f3>"    'my/register-jump-f3
   "M-<f3>"    'my/register-save-f3
   "C-<f4>"    'my/register-jump-f4
   "M-<f4>"    'my/register-save-f4
   )
  ;;; Put the Emacs default keybindings you want included
  ;;;   in general-describe-keybindings here:
  ;;; Its useful to duplicate these simply as a way of documentation:
  (general-define-key
   "M-SPC"     'cycle-spacing ; If you document it, you will use it.
   "M-h"       'mark-paragraph ; C-h B is like your personal cheat sheet.
   "C-h b"     'describe-bindings ;; default binding for documentation purpose
   "C-x 4 c"   'clone-indirect-buffer-other-window ;; default binding
   )
  ;;; Define bindings for specific builtin (non use-package) modes:
  ;; Emacs Lisp mode bindings:
  (general-define-key
   :keymaps 'emacs-lisp-mode-map
   "s-e" 'eval-defun ;eval top-level form
   "M-;" 'paredit-comment-dwim)
  ;; Dired mode bindings:
  (general-define-key
   :keymaps 'dired-mode-map "C-c C-q" 'dired-toggle-read-only))

;; which-key (shows keyboard shortcut completions) :: https://github.com/justbur/emacs-which-key
(use-package which-key :config (which-key-mode))

;; hydra (rapid fire mnemonic keybindings) :: https://github.com/abo-abo/hydra
(use-package hydra)
(use-package org
  :after hydra
  :hook ((org-mode . flyspell-mode)
         (org-mode . unpackaged/org-export-html-with-useful-ids-mode))
  :custom
  (org-html-validation-link nil)
  (org-html-use-infojs nil)
  (org-html-postamble 'auto)
  (org-export-with-author t)
  (org-export-with-date t)
  (org-export-with-creator nil)
  (org-export-with-email nil)
  (org-export-timestamp-file t)
  (org-export-allow-bind-keywords t)
  (org-directory "~/Org")
  :general
  ("s-<up>" 'org-previous-visible-heading)
  ("s-<down>" 'org-next-visible-heading)
  ("C-c o k" 'org-babel-remove-result)
  :config
  (setq org-startup-folded t)
  (defun my-org-html--translate (original-function keyword info)
    "Custom advice to translate the keyword 'Created' to 'Last Modified'."
    (if (string-equal keyword "Created")
        "Last Modified"
      (funcall original-function keyword info)))
  (advice-add 'org-html--translate :around #'my-org-html--translate)
  (org-babel-do-load-languages
   'org-babel-load-languages
   '((python . t) (scheme . t) (shell . t) (ditaa . t)))
  :init
  (defcustom my/org-notes-directory "~/Org/notes" "My org notes directory")
  (defcustom my/org-notes-export-directory "~/Org/export/notes" "My org notes HTML export directory")
  ;; Hydra for commonly used org commands:
  (defhydra
    hydra-org
    (global-map "C-c o" :exit t color pink :hint nil)
    "Org commands:"
    ("o" my/org-open-file)
    ("l" org-store-link "store link")
    ("i" org-insert-link "insert link")
    ("a" org-agenda "agenda")
    ("c" org-capture "capture")
    ("m" org-info "read info manual")
    ("e" org-export-dispatch "export")
    ("p" org-preview-html-mode "toggle preview mode")
    ("s" org-insert-source-code-block "insert source code block"))
  )
(require 'org-tempo) ; required for Structure Templates
                                        ; See https://orgmode.org/manual/Structure-Templates.html
(use-package htmlize) ; required for colorized HTML code blocks
(use-package org-preview-html :after org)
(use-package ob-async)
(progn ; electic pairs for org-mode
  (modify-syntax-entry ?/ "\"" org-mode-syntax-table)
  (modify-syntax-entry ?* "\"" org-mode-syntax-table)
  (modify-syntax-entry ?= "\"" org-mode-syntax-table)
  (modify-syntax-entry ?+ "\"" org-mode-syntax-table)
  (modify-syntax-entry ?_ "\"" org-mode-syntax-table)
  (modify-syntax-entry ?~ "\"" org-mode-syntax-table))

((org-mode
  . ((org-confirm-babel-evaluate . nil)
     (eval .
           (add-hook 'after-save-hook
                     (lambda ()
                       (when (and buffer-file-name
                                  (string= "org" (file-name-extension buffer-file-name)))
                         (my/org-babel-tangle buffer-file-name)))
                     nil t))))))

  ;; Allow minibuffers to stack:
  (setq-default enable-recursive-minibuffers t)
  ;; Filter command completions to only include commands
  ;; applicable to the current major mode:
  (setq-default read-extended-command-predicate
                #'command-completion-default-include-p)
  ;; Add custom prompt when asking for multiple values as (comma) separated list:
  (advice-add #'completing-read-multiple :filter-args
              (lambda (args)
                (cons (format "[CRM%s] %s"
                              (replace-regexp-in-string
                               "\\`\\[.*?]\\*\\|\\[.*?]\\*\\'" ""
                               crm-separator)
                              (car args))
                      (cdr args))))
  ;; 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)
(use-package
  consult
  :general ("C-x b" 'consult-buffer)
    (setq consult-buffer-sources
      '(consult--source-buffers
        consult--source-recent-file
        consult--source-project-buffer)))

(use-package vertico
    :custom
    (vertico-scroll-margin 2)
    (vertico-count 10)
    (vertico-resize 'grow-only)
    (vertico-cycle nil)
    :init
    ;;(keymap-set vertico-map "?" #'minibuffer-completion-help)
    ;;(keymap-set vertico-map "M-TAB" #'vertico-insert)
    ;;(keymap-set vertico-map "TAB" #'minibuffer-complete)
    (vertico-mode))

  (use-package orderless
    :custom
    ;; Configure a custom style dispatcher (see the Consult wiki)
    ;; (orderless-style-dispatchers
    ;;   '(+orderless-consult-dispatch orderless-affix-dispatch))
    ;; (orderless-component-separator #'orderless-escapable-split-on-space)
    (completion-styles '(orderless basic))
    (completion-category-defaults nil)
    (completion-category-overrides '((file (styles partial-completion)))))

  (use-package marginalia
    :hook
    ((marginalia-mode . all-the-icons-completion-marginalia-setup))
    :bind (:map minibuffer-local-map
                ("M-A" . marginalia-cycle))
    :init
    (marginalia-mode))

  (use-package nerd-icons-completion
    :init
    (nerd-icons-completion-mode))

(use-package company)

;; vterm (terminal emulator) ::
;;  https://github.com/akermu/emacs-libvterm
;; Configure BASH to work with vterm:
;;  https://github.com/akermu/emacs-libvterm#vterm-clear-scrollback
(use-package
  vterm
  :custom (vterm-always-compile-module t)
  :general ("C-c t" 'my/vterm-toggle)
  :config (define-key vterm-mode-map (kbd "<f5>") nil)
  :hook ((vterm-mode . (lambda () (setq-local show-trailing-whitespace nil))))
  :init
  ;; shell-pop for vterm :: https://github.com/jixiuf/vterm-toggle
  (use-package vterm-toggle)
  (defun my/vterm-toggle (&optional args)
    "Customized vterm-toggle wrapper- this fixes the universal
    argument (C-u) to always create a new terminal"
    (interactive "P")
    (if (not
         (or (derived-mode-p 'vterm-mode)
             (and (vterm-toggle--get-window)
                  vterm-toggle-hide-method)))
        (if (equal current-prefix-arg '(4))
            (vterm-toggle--new args)
          (vterm-toggle args))
      (vterm-toggle args))))

(use-package markdown-mode)

;; Load SSH / GPG keys from keychain agent
(use-package
  keychain-environment
  :straight
  (keychain-environment
   :type git
   :files (:defaults "keychain-environment")
   :host github
   :repo "tarsius/keychain-environment")
  :init (keychain-refresh-environment))

;; Magit (git version control system) :: https://magit.vc/
(use-package
  magit
  :general ("C-c g" 'magit-status)
  :config
  ;; open magit in a full frame always:
  (setq magit-display-buffer-function
        #'magit-display-buffer-fullframe-status-v1))

(defun my/default-text-scale-reset nil
  (setq default-text-scale--complement 0)
  (set-face-attribute 'default
                      nil
                      :height my/default-text-height)
  (message "Text height reset: %d" my/default-text-height)
  )
;; Scale text sizes in all buffers :: https://github.com/purcell/default-text-scale
(use-package
  default-text-scale
  :general
  ("C-="
   'default-text-scale-increase
   "C--"
   (lambda ()
     "Reset text scale if C-u is used, otherwise decrease it."
     (interactive)
     (let ((prefix current-prefix-arg))
       ;; Intercept and clear the prefix argument before calling the function
       (setq current-prefix-arg nil)
       (if prefix
           (my/default-text-scale-reset)
         (default-text-scale-decrease)))))
  :init (setq default-text-scale-amount 5))

;; just-mode
(use-package just-mode)

(use-package
  latin-words
  :straight
  (latin-words :type git :host github :repo "enigmacurry/latin-words")
  :custom
  (latin-words-directory
   (expand-file-name "straight/repos/latin-words/data" user-emacs-directory)))

(use-package
  dashboard
  :init
  (defun my-dashboard-insert-vocabulary (list-size)
    (when (fboundp 'latin-word-of-the-day)
      (dashboard-insert-heading "Word of the day:" nil)
      (insert "\n")
      (let* ((char-limit 100000)
             (word (latin-word-of-the-day))
             (description (latin-word-get-description word)))
        (insert
         (substring description
                    0
                    (min char-limit (length description)))))))
  (dashboard-setup-startup-hook)
  :hook
  ((dashboard-mode . (lambda () (setq-local show-trailing-whitespace nil))))
  :custom
  (dashboard-center-content t)
  (dashboard-set-heading-icons nil)
  (dashboard-set-file-icons nil)
  (dashboard-icon-type nil)
  (dashboard-footer-messages (list "    "))
  (dashboard-items '((recents . 5) (bookmarks . 5) (vocabulary)))
  (dashboard-startup-banner (+ 1 (random 3)))
  (dashboard-item-generators
   '((vocabulary . my-dashboard-insert-vocabulary)
     (recents . dashboard-insert-recents)
     (bookmarks . dashboard-insert-bookmarks))))

(use-package
  gptel
  :general
  ("C-c C-g" 'gptel-menu)
  (:keymaps 'gptel-mode-map "C-c C-c" 'gptel-send)
  :config (add-hook 'gptel-post-response-functions 'gptel-end-of-response)
                                        ;(add-hook 'gptel-post-stream-hook 'gptel-auto-scroll)
  (setq gptel-org-branching-context t)
  :init
  ;; LM-studio offers an OpenAI compatible API
  (setq
   gptel-model 'test
   gptel-backend
   (gptel-make-openai
    "lm-studio"
    :stream t
    :protocol "http"
    :host "localhost:1234"
    :models '(test)))
  (defun my-gptel-deepseek-wrap-think-block (beg end)
    "Wrap '<think>' blocks in an Org-mode drawer if not already wrapped."
    (when (derived-mode-p 'org-mode)
      (save-excursion
        (goto-char beg)
        ;; Find all occurrences of <think> blocks
        (while (re-search-forward "^<think>" end t)
          (let ((start (line-beginning-position)))
            ;; Check if the block is already wrapped
            (unless (save-excursion
                      (forward-line -4)
                      (looking-at "^:THINKING:$"))
              ;; Insert Org-mode drawer start
              (goto-char start)
              (kill-region (point) (line-end-position))
              (insert-and-inherit ":THINKING:\n")
              (insert-and-inherit
               "#+attr_shortcode: :title Thinking ...\n")
              (insert-and-inherit "#+begin_expand\n")
              (insert-and-inherit "<pre>")
              (forward-line 4)
              ;; Find the closing tag again after insertion
              (when (re-search-forward "</think>" nil t)
                (end-of-line)
                (kill-region (line-beginning-position) (point))
                (insert-and-inherit "</pre>")
                (end-of-line)
                ;; Ensure we don't add duplicate :END:
                (unless (looking-at "\n#+end_expand")
                  (insert-and-inherit "\n#+end_expand\n")
                  (insert-and-inherit ":END:\n"))
                ;; Move back to the start of the drawer for org-cycle
                (goto-char start)
                (org-cycle)))))))
    (message "Think blocks wrapped and folded."))

  (add-hook
   'gptel-post-response-functions
   #'my-gptel-deepseek-wrap-think-block))

;; LSP mode :: https://emacs-lsp.github.io/lsp-mode/
(use-package
  lsp-mode
  :init
  ;; set prefix for lsp-command-keymap (few alternatives - "C-l", "C-c l")
  (setq lsp-keymap-prefix "C-c l")
  (setq lsp-modeline-diagnostics-scope :workspace)
 ;;; extra verbose logging of lsp json messages:
  ;;(setq lsp-log-io t)
  :hook
  ((web-mode . lsp)
   ;(lsp-mode . lsp-enable-which-key-integration)
   (python-mode . lsp-deferred))
  :commands lsp
  :config)
(use-package lsp-ui :commands lsp-ui-mode)
(use-package lsp-ivy :commands lsp-ivy-workspace-symbol)
(use-package lsp-treemacs :commands lsp-treemacs-errors-list)
(use-package flycheck)

;; LSP debuggers
(use-package dap-mode)
;; (use-package dap-LANGUAGE) to load the dap adapter for your language

;; Avy (like ace-jump) :: https://github.com/abo-abo/avy
(use-package
 avy
 :general
 ;;; These are if you want to use avy by itself,
 ;;; Otherwise these keys will be defined by treesit-jump instead.
 ("s-s" 'avy-goto-word-1)
 ("C-c s" 'avy-goto-char)
 ("C-c S" 'avy-goto-word-1))

(use-package treesit-auto
  :custom
  (treesit-auto-langs '(awk bash bibtex blueprint c c-sharp
                            clojure cmake commonlisp cpp css dart dockerfile elixir glsl go
                            gomod heex html janet java javascript json julia kotlin latex
                            lua magik make markdown nix nu org perl proto python r ruby
                            scala sql surface toml tsx typescript typst verilog vhdl vue
                            wast wat wgsl yaml))
  (treesit-auto-install 'prompt)
  :config
  (treesit-auto-add-to-auto-mode-alist 'all)
  (global-treesit-auto-mode))

(use-package treesit-jump
  :straight (:host github :repo "dmille56/treesit-jump" :files ("*.el" "treesit-queries"))
  :config
  ;; Optional: add some queries to filter out of results (since they can be too cluttered sometimes)
  ;;(setq treesit-jump-queries-filter-list '("inner" "test" "param"))

(use-package
  s3-publish
  :straight
  (s3-publish
   :type
   git
   :repo
   "https://github.com/EnigmaCurry/s3-publish.el.git")
  :general
  ("C-c p" 's3-publish))

(my/add-exec-path "~/.local/bin")
(defun my/python-install-uv-package-manager ()
  "Install uv package manager via cargo"
  (my/cargo-install '(("uv" . "https://github.com/astral-sh/uv"))))
(defun my/python-uv-execute (command)
  (my/python-install-uv-package-manager)
  (my/shell-execute command))
(defun my/python-install-ruff ()
  (unless (executable-find "ruff")
    (my/python-uv-execute "uv tool install ruff@latest")))
(use-package
  python-mode
  :general ("s-a" 'lsp-execute-code-action)
  :init (my/python-install-ruff)
  :hook
  (python-mode . pyvenv-mode)
  (python-mode . flycheck-mode)
  (python-mode . company-mode)
  (python-mode . python-black-on-save-mode)
  :custom (python-shell-interpreter "python3")
  :config
  ;; Activate python virtualenv BEFORE opening a python buffer and/or starting pyright server:
  ;; M-x pyvenv-activate     (~/.virtualenvs/XXX)
  (use-package
    pyvenv
    :init (setenv "WORKON_HOME" "~/.virtualenvs/")
    :config
    ;; (pyvenv-mode t)
    ;; Set correct Python interpreter
    (setq pyvenv-post-activate-hooks
          (list
           (lambda ()
             (setq python-shell-interpreter
                   (concat pyvenv-virtual-env "bin/python")))))
    (setq pyvenv-post-deactivate-hooks
          (list (lambda () (setq python-shell-interpreter "python3")))))
  ;; Black (Python code formatter) :: https://github.com/wbolster/emacs-python-black
  ;; Note: this depends on black being installed in the project virtualenv as a dev dependency
  (use-package python-black :demand t :after python)
  ;; Python dev dependencies need to be installed in your project's virtualenv:
  ;; ruff
  ;; ruff-lsp
  ;; black
 ;;; Add the following to a .dir-locals.el to activate virtualenv automatically:
  ;; ((python-mode . ((eval . (let ((project-root (locate-dominating-file
  ;;                              (or (buffer-file-name) default-directory)
  ;;                                ".dir-locals.el")))
  ;;               (pyvenv-activate (expand-file-name "virtualenv" project-root)))))))
  )

;; Rust
;; must manually install cargo-watch, wasm-pack, wasm-bindgen, cargo-generate
(my/cargo-dependency "cargo-watch")
(my/cargo-dependency "wasm-pack")
(my/cargo-dependency "wasm-bindgen")
(my/cargo-dependency "cargo-generate")
(use-package
  rustic
  :mode ("\\.rs\\'" . rustic-mode)
  ;; :hook (rustic-mode . yas-minor-mode)
  :init
  (setq rustic-format-on-save t)
  (setq rustic-rustfmt-args "--edition 2021")
  (add-to-list 'exec-path "~/.cargo/bin")
  (defalias 'org-babel-execute:rust 'org-babel-execute:rustic)
  (describe-function 'org-babel-execute:rust)
  (add-hook
   'rustic-mode-hook
   (lambda ()
     (define-key
      rustic-mode-map
      (kbd "C-c M-.")
      'lsp-rust-analyzer-open-external-docs))))

(defvar my/modules-dir (expand-file-name "modules/" user-emacs-directory))
(defvar my/module-priority-list '("general" "fonts")
  "List of prioritized modules to install first.")
(defun my/load-modules (requested-modules)
  "Load user-requested modules in a priority order.
  REQUESTED-MODULES is a list of module names to load."
  ;; Find and load all single file modules and load them regardless of any config
  ;; (these onesshouldn't have any extra dependencies)
  (when (file-directory-p my/modules-dir)
    (let ((files (directory-files my/modules-dir t "\\.el\\'")))
      (dolist (file (sort files #'string<))
        (message "Loading module: %s" file)
        (condition-case err
            (load file nil 'nomessage)
          (error (message "Error loading %s: %s" file err))))))
  ;; Prioritize and install the requested third party / optional modules:
  (let ((prioritized-modules
         (seq-filter (lambda (mod) (member mod my/module-priority-list))
                     requested-modules))
        (remaining-modules
         (seq-remove (lambda (mod) (member mod my/module-priority-list))
                     requested-modules)))
    ;; Sort prioritized modules based on `my/module-priority-list`
    (setq prioritized-modules
          (sort prioritized-modules
                (lambda (a b)
                  (< (or (cl-position a my/module-priority-list)
                         most-positive-fixnum)
                     (or (cl-position b my/module-priority-list)
                         most-positive-fixnum)))))
    ;; Combine prioritized and remaining modules
    (let ((ordered-modules (append prioritized-modules
                                   remaining-modules)))
      (dolist (mod ordered-modules)
        (let ((mod-path (expand-file-name mod my/modules-dir)))
          (if (file-directory-p mod-path)
              (progn
                (message "Loading module: %s" mod)
                (let ((files (directory-files mod-path t "\\.el\\'")))
                  (dolist (file (sort files #'string<))
                    (condition-case err
                        (load file nil 'nomessage)
                      (error (message "Error loading %s: %s" file err))))))
            (message "Skipping module: %s (not found)" mod)))))))

;; load the modules configured for this macchine
(my/load-modules my/machine-labels)

;; Install rust dependencies that were declared by modules
(when my/cargo-dependencies
  (my/cargo-install my/cargo-dependencies))