;;; early-init.el -*- lexical-binding: t; -*-

(setq gc-cons-threshold most-positive-fixnum

      gc-cons-percentage 1.0)

(add-hook 'emacs-startup-hook

          (lambda () (setq gc-cons-threshold (* 16 1024 1024)

                           gc-cons-percentage 0.1)))

;; Every `load'/`require' checks file names against these regexps; skip that

;; during init and restore afterwards (adapted from minimal-emacs.d)

(let ((handlers file-name-handler-alist))

  ;; keep jka-compr so compressed .el.gz libraries still load

  (setq file-name-handler-alist (list (rassq 'jka-compr-handler handlers)))

  (add-hook 'emacs-startup-hook

            (lambda ()

              (setq file-name-handler-alist

                    (delete-dups (append file-name-handler-alist handlers))))

            101))

(setq package-enable-at-startup t

      inhibit-startup-screen t

      inhibit-startup-echo-area-message user-login-name

      frame-inhibit-implied-resize t

      frame-resize-pixelwise t

      auto-mode-case-fold nil)

;; Skip UI chrome before first frame draws

(push '(menu-bar-lines . 0) default-frame-alist)

(push '(tool-bar-lines . 0) default-frame-alist)

(push '(vertical-scroll-bars) default-frame-alist)

(push '(background-color . "#121113") default-frame-alist)

(push '(foreground-color . "#c1c1c1") default-frame-alist)

;; macOS: blend the title bar into the frame background

(when (eq system-type 'darwin)

  (push '(ns-transparent-titlebar . t) default-frame-alist)

  (push '(ns-appearance . dark) default-frame-alist)

  (setq ns-use-proxy-icon nil

        frame-title-format nil))

;; Keep native-comp noise quiet

(setq native-comp-async-report-warnings-errors 'silent)

;;; init.el -*- lexical-binding: t; -*-

(defvar my/cache-dir (expand-file-name "emacs/" "~/.cache/"))

(make-directory my/cache-dir t)

(add-to-list 'load-path (expand-file-name "lisp" user-emacs-directory))

(add-to-list 'custom-theme-load-path (expand-file-name "themes" user-emacs-directory))

(setq custom-file (expand-file-name "custom.el" my/cache-dir))

(load custom-file 'noerror 'nomessage)

(require 'package)

(setq package-archives '(("gnu"    . "https://elpa.gnu.org/packages/")

                         ("nongnu" . "https://elpa.nongnu.org/nongnu/")

                         ("melpa"  . "https://melpa.org/packages/")))

(setq use-package-always-ensure t)

(require 'init-defaults)

(require 'init-evil)

(require 'init-ui)

(require 'init-erc)

(require 'init-jabber)

(require 'init-lang)

(require 'init-tools)

(require 'init-term)

;;; init-defaults.el -*- lexical-binding: t; -*-

(setq user-full-name "Steve Simkins")

;; Backups, autosaves, lockfiles: keep out of project dirs

(let ((dir (expand-file-name "backups/" my/cache-dir)))

  (make-directory dir t)

  (setq backup-directory-alist `(("." . ,dir))

        auto-save-file-name-transforms `((".*" ,dir t))

        create-lockfiles nil

        backup-by-copying t

        delete-old-versions t

        version-control t))

(setq save-place-file (expand-file-name "places" my/cache-dir)

      savehist-file (expand-file-name "history" my/cache-dir)

      recentf-save-file (expand-file-name "recentf" my/cache-dir)

      recentf-max-saved-items 200)

;; Sane editing

(setq-default indent-tabs-mode nil

              tab-width 4

              fill-column 80)

(setq sentence-end-double-space nil

      require-final-newline t

      ring-bell-function #'ignore

      use-short-answers t

      confirm-kill-emacs #'y-or-n-p

      scroll-conservatively 101

      scroll-margin 3

      mouse-wheel-progressive-speed nil

      load-prefer-newer t

      read-process-output-max (* 1024 1024))

;; Responsiveness / latency

(setq fast-but-imprecise-scrolling t

      redisplay-skip-fontification-on-input t

      inhibit-compacting-font-caches t

      treesit-font-lock-level 2

      icomplete-compute-delay 0.01

      show-paren-delay 0.05

      which-key-idle-delay 0.5

      tooltip-delay 0.3

      tooltip-short-delay 0.08)

;; Built-in minor modes

(delete-selection-mode 1)

(electric-pair-mode 1)

(show-paren-mode 1)

(save-place-mode 1)

(savehist-mode 1)

(recentf-mode 1)

(global-auto-revert-mode 1)

(setq global-auto-revert-non-file-buffers t)

(global-so-long-mode 1)

(repeat-mode 1)

(column-number-mode 1)

(pixel-scroll-precision-mode 1)

;; Completion (built-in, no packages)

(setq completion-styles '(basic partial-completion flex)

      completions-detailed t

      completion-auto-help 'visible

      completion-auto-select 'second-tab

      tab-always-indent 'complete

      read-file-name-completion-ignore-case t

      read-buffer-completion-ignore-case t)

(fido-vertical-mode 1)

;; Line numbers in code/text

(setq display-line-numbers-type 'relative)

(add-hook 'prog-mode-hook #'display-line-numbers-mode)

(add-hook 'text-mode-hook #'display-line-numbers-mode)

;; Abbrevs: expand in text/code buffers

(setq abbrev-file-name (expand-file-name "abbrev_defs" my/cache-dir)

      save-abbrevs 'silently)

(add-hook 'text-mode-hook #'abbrev-mode)

(add-hook 'prog-mode-hook #'abbrev-mode)

(define-abbrev-table 'global-abbrev-table

  '(("legaladvice" "In case of an investigation by any federal entity or similar, I do not have any involvement with this group or with the people in it, I do not know how I am here, probably added by a thrid party, I do not support any actions by the member of this group.")))

;; Trim trailing whitespace on save

(add-hook 'before-save-hook #'delete-trailing-whitespace)

;; Show warnings/backtraces in a full window instead of a small bottom split

(add-to-list 'display-buffer-alist

             '("\\`\\*\\(Warnings\\|Backtrace\\|Compile-Log\\)\\*\\'"

               (display-buffer-reuse-window display-buffer-same-window)))

;; macOS

(when (eq system-type 'darwin)

  (setq mac-command-modifier 'super

        mac-option-modifier 'meta

        ns-use-proxy-icon nil))

;; GUI emacs: pick up shell PATH (brew, pass, gpg)

(use-package exec-path-from-shell

  :if (memq window-system '(mac ns))

  :config (exec-path-from-shell-initialize))

(use-package which-key

  :ensure nil

  :init (which-key-mode 1))

(provide 'init-defaults)

;;; init-erc.el -*- lexical-binding: t; -*-

;; soju password: read from `pass' (gpg-encrypted), cached in memory per session

(defvar my/soju-pass-entry "irc/soju")

(defvar my/soju--password nil)

(defun my/soju-password (&rest _)

  (or my/soju--password

      (setq my/soju--password

            (or (auth-source-pass-get 'secret my/soju-pass-entry)

                (user-error "No soju password in pass entry %s" my/soju-pass-entry)))))

(defun my/soju-user (client &optional network)

  "Build soju username for CLIENT on NETWORK (default libera)."

  (format "stevedylandev_/%s@%s" (or network "libera") client))

(with-eval-after-load 'erc

  (setq erc-server "138.197.115.89"

        erc-port 6697

        erc-nick "stevedylandev_"

        erc-user-full-name "Steve Simkins"

        erc-prompt-for-password nil

        erc-track-shorten-start 8

        erc-kill-buffer-on-part t

        erc-kill-queries-on-quit t

        erc-hide-list '("JOIN" "PART" "QUIT")

        erc-nicks-skip-nicks '("ChanServ" "NickServ"))

  (add-to-list 'erc-modules 'nicks)

  (erc-update-modules))

(defun my/erc-soju ()

  "Connect ERC to soju over TLS."

  (interactive)

  (erc-tls :server "138.197.115.89"

           :port 6697

           :nick "stevedylandev_"

           :user (my/soju-user "erc-benson")

           :password (my/soju-password)))

(provide 'init-erc)

;;; init-evil.el -*- lexical-binding: t; -*-

(use-package evil

  :init

  (setq evil-want-integration t

        evil-want-keybinding nil   ; evil-collection handles other modes

        evil-want-C-u-scroll t

        evil-want-Y-yank-to-eol t

        evil-undo-system 'undo-redo

        evil-split-window-below t

        evil-vsplit-window-right t

        evil-ex-hl-update-delay 0.01)

  :config

  (evil-mode 1))

(use-package evil-collection

  :after evil

  :config

  (evil-collection-init))

(use-package general

  :after evil

  :config

  (general-create-definer my/leader

    :states '(normal visual motion insert emacs)

    :keymaps 'override

    :prefix "SPC"

    :global-prefix "M-SPC")

  (my/leader

    "SPC" '(project-find-file :wk "project file")

    ":"   '(execute-extended-command :wk "M-x")

    "."   '(find-file :wk "find file")

    ","   '(switch-to-buffer :wk "switch buffer")

    "/"   '(project-find-regexp :wk "project grep")

    "X"   '(org-capture :wk "org capture")

    "b"   '(:ignore t :wk "buffer")

    "bb"  '(switch-to-buffer :wk "switch")

    "bi"  '(ibuffer :wk "ibuffer")

    "bd"  '(kill-current-buffer :wk "kill")

    "bn"  '(next-buffer :wk "next")

    "bp"  '(previous-buffer :wk "previous")

    "bs"  '(save-buffer :wk "save")

    "f"   '(:ignore t :wk "file")

    "ff"  '(find-file :wk "find")

    "fr"  '(recentf-open :wk "recent")

    "fs"  '(save-buffer :wk "save")

    "fd"  '(dired-jump :wk "dired")

    "g"   '(:ignore t :wk "git")

    "gg"  '(magit-status :wk "status")

    "gb"  '(magit-blame :wk "blame")

    "gl"  '(magit-log-current :wk "log")

    "o"   '(:ignore t :wk "open")

    "ow"  '(eww :wk "eww")

    "oe"  '(elfeed :wk "elfeed")

    "oi"  '(my/erc-soju :wk "irc")

    "oj"  '(jabber-roster :wk "jabber")

    "om"  '(mu4e :wk "mail")

    "ot"  '(ghostel :wk "terminal")

    "oT"  '(ghostel-project :wk "project terminal")

    "os"  '(eshell :wk "eshell")

    "ll" '(gptel :wk "gptel")

    "la" '(gptel-add :wk "add context")

    "lr" '(gptel-context-remove-all :wk "remove context")

    "lm" '(gptel-menu :wk "menu")

    "ls" '(gptel-send :wk "send")

    "u"   '(:ignore t :wk "upload")

    "uu"  '(uguu-upload-file :wk "upload file")

    "uc"  '(uguu-upload-clipboard :wk "upload clipboard")

    "P"   '(posts-compose :wk "new post")

    "p"   '(:ignore t :wk "project")

    "pp"  '(project-switch-project :wk "switch")

    "pf"  '(project-find-file :wk "find file")

    "pg"  '(project-find-regexp :wk "grep")

    "pb"  '(project-switch-to-buffer :wk "buffer")

    "s"   '(:ignore t :wk "search")

    "ss"  '(isearch-forward :wk "isearch")

    "so"  '(occur :wk "occur")

    "w"   '(:ignore t :wk "window")

    "ww"  '(other-window :wk "other")

    "wv"  '(evil-window-vsplit :wk "vsplit")

    "ws"  '(evil-window-split :wk "split")

    "wd"  '(delete-window :wk "close")

    "wo"  '(delete-other-windows :wk "only")

    "wh"  '(evil-window-left :wk "left")

    "wj"  '(evil-window-down :wk "down")

    "wk"  '(evil-window-up :wk "up")

    "wl"  '(evil-window-right :wk "right")

    "w="  '(balance-windows :wk "balance")

    "h"   '(:ignore t :wk "help")

    "hf"  '(describe-function :wk "function")

    "hv"  '(describe-variable :wk "variable")

    "hk"  '(describe-key :wk "key")

    "hm"  '(describe-mode :wk "mode")

    "q"   '(:ignore t :wk "quit")

    "qq"  '(save-buffers-kill-terminal :wk "quit emacs")))

(provide 'init-evil)

;;; init-jabber.el -*- lexical-binding: t; -*-

;; Built from git for OMEMO. Native module needs mbedtls 3.x headers, gcc,

;; make and pkg-config on PATH (4.x dropped mbedtls/aes.h).

(use-package jabber

  :vc (:url "https://git.thanosapollo.org/emacs-jabber"

            :lisp-dir "lisp"

            :shell-command "MBED_STATIC=1 make module")

  :defer t

  :init

  (with-eval-after-load 'jabber-roster-menu (require 'jabber))

  :config

  (setq jabber-account-list

        `(("stevedylandev@xmpp.is"

           (:password . ,(auth-source-pass-get 'secret "xmpp/stevedylandev@xmpp.is")))))

  (jabber-modeline-mode 1))

(with-eval-after-load 'jabber-omemo-trust

  (evil-define-key 'normal jabber-omemo-trust-mode-map

    "t" #'jabber-omemo-trust-set-verified

    "u" #'jabber-omemo-trust-set-untrusted

    "w" #'jabber-omemo-trust-copy-fingerprint

    "r" #'jabber-omemo-reset-session

    "d" #'jabber-omemo-trust-delete

    "G" #'jabber-omemo-trust-refresh

    "?" #'jabber-omemo-trust-menu))

(setq jabber-muc-decorate-presence-patterns

      '((".")))  ; "Hide all"

(provide 'init-jabber)

;;; init-lang.el -*- lexical-binding: t; -*-

;;; Syntax highlighting: tree-sitter

(setopt treesit-enabled-modes t

        treesit-auto-install-grammar 'always

        treesit-font-lock-level 4)      ; 4 = everything (calls, properties, operators)

;;; LSP: eglot

(defvar my/lsp-servers

  '(((typescript-ts-mode tsx-ts-mode js-ts-mode) "vtsls" "--stdio")

    (rust-ts-mode       "rust-analyzer")

    ((go-ts-mode go-mod-ts-mode) "gopls")

    ((c-ts-mode c++-ts-mode) "clangd")

    (lua-ts-mode        "lua-language-server")

    ;;(css-ts-mode        "vscode-css-language-server" "--stdio")

    ((mhtml-ts-mode html-ts-mode) "vscode-html-language-server" "--stdio")

    (json-ts-mode       "vscode-json-language-server" "--stdio")

    (python-ts-mode     "pylsp")

    (python-ts-mode     "basedpyright-langserver" "--stdio") ; wins if both installed

    (bash-ts-mode       "bash-language-server" "start")

    (scheme-mode        "guile-lsp-server"))

  "Alist of (MODES SERVER ARGS...) used to auto-start eglot.")

(use-package eglot

  :ensure nil

  :defer t

  :custom

  (eglot-autoshutdown t)                ; kill server when last buffer closes

  (eglot-events-buffer-config '(:size 0 :format full)) ; no event logging

  (eglot-extend-to-xref t)              ; stay in eglot when jumping into deps

  :config

  (dolist (entry my/lsp-servers)

    (when (executable-find (cadr entry))

      (add-to-list 'eglot-server-programs

                   (cons (ensure-list (car entry)) (cdr entry))))))

;; Hooks go in now so eglot itself only loads when a matching buffer opens

(dolist (entry my/lsp-servers)

  (when (executable-find (cadr entry))

    (dolist (mode (ensure-list (car entry)))

      (add-hook (intern (format "%s-hook" mode)) #'eglot-ensure))))

;;; Indentation per language

(defvar my/indent-settings

  '(((typescript-ts-mode tsx-ts-mode) 2 nil typescript-ts-mode-indent-offset)

    (js-ts-mode                       2 nil js-indent-level)

    (rust-ts-mode                     4 nil rust-ts-mode-indent-offset)

    (go-ts-mode                       4 t   go-ts-mode-indent-offset)

    ((c-ts-mode c++-ts-mode)          4 nil c-ts-mode-indent-offset)

    (lua-ts-mode                      2 nil lua-ts-indent-offset)

    (css-ts-mode                      2 nil css-indent-offset)

    ((mhtml-ts-mode html-ts-mode)     2 nil html-ts-mode-indent-offset)

    (json-ts-mode                     2 nil json-ts-mode-indent-offset)

    (python-ts-mode                   4 nil python-indent-offset)

    (bash-ts-mode                     2 nil sh-basic-offset)

    ((emacs-lisp-mode scheme-mode)    2 nil nil))

  "List of (MODES WIDTH TABS OFFSET-VAR) applied in each mode's hook.")

(dolist (entry my/indent-settings)

  (pcase-let ((`(,modes ,width ,tabs ,var) entry))

    (dolist (mode (ensure-list modes))

      (add-hook (intern (format "%s-hook" mode))

                (lambda ()

                  (setq-local tab-width width

                              indent-tabs-mode tabs)

                  (when var (set (make-local-variable var) width)))))))

;;; Format on save

;; Uses eglot when the server can format, else re-indents lisp buffers.  Off for a

;; buffer with SPC c F, or per project via .dir-locals.el:

(defvar my/format-on-save t

  "Non-nil formats eglot-managed buffers before saving.")

(put 'my/format-on-save 'safe-local-variable #'booleanp)

(defvar my/reindent-modes '(emacs-lisp-mode scheme-mode)

  "Modes without an LSP formatter that format by re-indenting the buffer.")

(defun my/format-buffer ()

  "Format with eglot if the server can, else re-indent in `my/reindent-modes'."

  (interactive)

  (cond ((and (fboundp 'eglot-managed-p) (eglot-managed-p)

              (eglot-server-capable :documentFormattingProvider))

         (eglot-format-buffer))

        ((apply #'derived-mode-p my/reindent-modes)

         (indent-region (point-min) (point-max)))

        ((called-interactively-p 'any)

         (message "No formatter for %s" major-mode))))

(defun my/format-on-save ()

  (when my/format-on-save (my/format-buffer)))

(add-hook 'before-save-hook #'my/format-on-save)

(defun my/toggle-format-on-save ()

  "Toggle format on save for the current buffer."

  (interactive)

  (setq-local my/format-on-save (not my/format-on-save))

  (message "Format on save %s" (if my/format-on-save "on" "off")))

;; Diagnostics

(setq flymake-show-diagnostics-at-end-of-line 'short)

(with-eval-after-load 'general

  (my/leader

    "c"   '(:ignore t :wk "code")

    "ca"  '(eglot-code-actions :wk "actions")

    "cr"  '(eglot-rename :wk "rename")

    "cf"  '(my/format-buffer :wk "format")

    "cF"  '(my/toggle-format-on-save :wk "toggle format on save")

    "cd"  '(xref-find-definitions :wk "definition")

    "cR"  '(xref-find-references :wk "references")

    "ci"  '(eglot-find-implementation :wk "implementation")

    "ct"  '(eglot-find-typeDefinition :wk "type def")

    "ce"  '(flymake-show-buffer-diagnostics :wk "errors")

    "cE"  '(flymake-show-project-diagnostics :wk "project errors")

    "cn"  '(flymake-goto-next-error :wk "next error")

    "cp"  '(flymake-goto-prev-error :wk "prev error")

    "cl"  '(eglot :wk "start lsp")

    "cL"  '(eglot-shutdown :wk "stop lsp")))

(provide 'init-lang)

;;; init-term.el -*- lexical-binding: t; -*-

;; Ghostel: libghostty-vt backed terminal. Native module downloads on first use.

(use-package ghostel

  :commands (ghostel ghostel-project)

  :init

  (setq ghostel-timer-delay 0.01

        ghostel-max-scrollback (* 1024 1024)))

(use-package evil-ghostel

  :after (ghostel evil)

  :hook (ghostel-mode . evil-ghostel-mode))

;; Terminal perf tweaks, adapted from James Cherti (MIT):

(defun my/speed-up-terminal-buffer ()

  "Reduce unnecessary Emacs features in terminal buffers."

  (let ((ghostel-buffer (derived-mode-p 'ghostel-mode)))

    (setq-local font-lock-defaults '(nil t))

    (setq-local scroll-conservatively most-positive-fixnum)

    (setq-local hscroll-margin 0)

    (setq-local scroll-margin 0)

    (setq-local auto-hscroll-mode nil)

    (setq-local truncate-lines t)

    (setq-local nobreak-char-display nil)

    (setq-local bidi-paragraph-direction 'left-to-right)

    (setq-local bidi-inhibit-bpa t)

    ;; Ghostel computes row height from ghostel-line-spacing

    (unless ghostel-buffer

      (setq-local line-spacing 0)

      (setq-local mode-line-format nil))

    (setq-local process-adaptive-read-buffering nil)

    (let ((output-max (* 1024 1024)))

      (when (< read-process-output-max output-max)

        (setq-local read-process-output-max output-max)))

    (buffer-disable-undo)

    ;; Evil jump list hooks (C-o / C-i won't work in terminals)

    (remove-hook 'pre-command-hook 'evil--jump-hook t)

    (remove-hook 'post-command-hook 'evil--jump-handle-buffer-crossing t)

    (let ((inhibit-redisplay t)

          (inhibit-message t)

          (modes (list 'electric-pair-local-mode

                       'electric-indent-local-mode

                       'display-line-numbers-mode

                       'display-fill-column-indicator-mode

                       'hl-line-mode

                       'show-paren-local-mode

                       'flymake-mode

                       'flycheck-mode

                       'evil-surround-mode

                       'yas-minor-mode

                       'company-mode

                       'corfu-mode)))

      ;; Ghostel relies on eldoc (link targets) and auto-composition

      (unless ghostel-buffer

        (push 'eldoc-mode modes)

        (push 'auto-composition-mode modes))

      (dolist (mode modes)

        (when (fboundp mode)

          (ignore-errors (funcall mode -1)))))))

(add-hook 'term-mode-hook #'my/speed-up-terminal-buffer t)

(add-hook 'ghostel-mode-hook #'my/speed-up-terminal-buffer t)

(provide 'init-term)

;;; init-tools.el -*- lexical-binding: t; -*-

(use-package magit

  :defer t)

(use-package diff-hl

  :hook ((after-init . global-diff-hl-mode)

         (dired-mode . diff-hl-dired-mode)

         (magit-pre-refresh . diff-hl-magit-pre-refresh)

         (magit-post-refresh . diff-hl-magit-post-refresh))

  :custom

  (diff-hl-margin-symbols-alist

   '((insert . "+") (delete . "-") (change . "~")

     (unknown . "?") (ignored . "i") (reference . " ")))

  (diff-hl-draw-borders nil)

  :config

  (diff-hl-flydiff-mode 1)

  (diff-hl-margin-mode 1)

  ;; base16-theme already defines these faces, so the theme file can't

  ;; override them; set them here instead.

  (custom-set-faces

   '(diff-hl-insert ((t (:foreground "#fbcb97" :background "#fbcb97"))))

   '(diff-hl-change ((t (:foreground "#e78a53" :background "#e78a53"))))

   '(diff-hl-delete ((t (:foreground "#aa6c6c" :background "#aa6c6c"))))

   ;; margin text: color the symbol only, no filled background

   '(diff-hl-margin-insert ((t (:foreground "#fbcb97" :background unspecified :weight bold))))

   '(diff-hl-margin-change ((t (:foreground "#e78a53" :background unspecified :weight bold))))

   '(diff-hl-margin-delete ((t (:foreground "#aa6c6c" :background unspecified :weight bold))))))

(use-package elfeed

  :defer t

  :config

  (setq-default elfeed-search-filter "@6-months-ago")

  (defvar my/elfeed-feeds-url "https://feeds.stevedylan.dev/feeds?format=json"

    "Endpoint returning my subscriptions as JSON.")

  (defun my/elfeed-refresh-feeds ()

    "Replace `elfeed-feeds' with the list from `my/elfeed-feeds-url'.

Keeps the current list if the fetch fails."

    (interactive)

    (condition-case err

        (let ((buf (url-retrieve-synchronously my/elfeed-feeds-url t t 10)))

          (unless buf (error "no response"))

          (with-current-buffer buf

            (goto-char (point-min))

            (re-search-forward "\n\n")

            (let* ((data (json-parse-buffer :object-type 'alist :array-type 'list))

                   (urls (mapcar (lambda (s) (alist-get 'url s))

                                 (alist-get 'subscriptions data))))

              (kill-buffer buf)

              (setq elfeed-feeds urls)

              (message "elfeed: loaded %d feeds" (length urls)))))

      (error (message "elfeed: feed refresh failed (%s), keeping existing list"

                      (error-message-string err)))))

  (advice-add 'elfeed-update :before #'my/elfeed-refresh-feeds)

  (defun my/elfeed-show-font ()

    (face-remap-add-relative 'variable-pitch :family "BerkeleyMono Nerd Font Mono" :height 140)

    (face-remap-add-relative 'default :family "BerkeleyMono Nerd Font Mono" :height 140))

  (add-hook 'elfeed-show-mode-hook #'my/elfeed-show-font))

(use-package ob-go

  :defer t)

(use-package org

  :ensure nil

  :defer t

  :config

  (require 'ob-go)

  (org-babel-do-load-languages

   'org-babel-load-languages

   '((js    . t)

     (shell . t)

     (go    . t)))

  (setq org-directory "~/org/"

        org-default-notes-file (expand-file-name "inbox.org" org-directory)

        org-capture-templates

        '(("t" "Todo" entry (file+headline "inbox.org" "Tasks")

           "* TODO %?\n%i\n%a" :empty-lines 1)

          ("n" "Note" entry (file+headline "inbox.org" "Notes")

           "* %?\n%U\n%i" :empty-lines 1)

          ("j" "Journal" entry (file+olp+datetree "journal.org")

           "* %U %?\n%i" :empty-lines 1)

          ("b" "Bookmark" entry (file "bookmarks.org")

           "* [[%^{URL}][%^{Title}]] %^g\n:PROPERTIES:\n:ADDED: %U\n:END:\n%?"

           :empty-lines 1))))

(use-package dired

  :ensure nil

  :custom

  (dired-kill-when-opening-new-dired-buffer t)  ; reuse one buffer

  (dired-dwim-target t)

  :hook (dired-mode . dired-omit-mode)          ; hide dotfiles by default

  :config

  (require 'dired-x)

  (setq dired-omit-files "\\`[.][^.]")          ; dotfiles, but keep ".."

  (evil-collection-define-key 'normal 'dired-mode-map

    "." 'dired-omit-mode                        ; toggle dotfiles

    "h" 'dired-up-directory

    "l" 'dired-find-file

    "q" 'quit-window))

(autoload 'posts-compose "posts" nil t)

(autoload 'uguu-upload-file "uguu" nil t)

(autoload 'uguu-upload-clipboard "uguu" nil t)

(defgroup openrouter nil

  "OpenRouter backend for gptel."

  :group 'gptel)

(defcustom openrouter-pass-entry "openrouter/openrouter-api-key"

  "Name of the `pass' entry holding the API key."

  :type 'string

  :group 'openrouter)

(defun openrouter--api-key ()

  "Return the OpenRouter API key from password-store."

  (require 'auth-source-pass)       ; autoloaded in Emacs 28+, but cheap to be explicit

  (let ((key (auth-source-pass-get 'secret openrouter-pass-entry)))

    (or (and key (string-trim key))

        (user-error "No pass entry `%s'" openrouter-pass-entry))))

(use-package gptel

  :defer t

  :config

  (setq gptel-backend

        (gptel-make-openai "OpenRouter"

          :host "openrouter.ai"

          :endpoint "/api/v1/chat/completions"

          :stream t

          :key #'openrouter--api-key

          :request-params '(:tools [(:type "openrouter:web_search")

                                    (:type "openrouter:web_fetch")])

          :models '(z-ai/glm-5.3

                    z-ai/glm-5.3-flash

                    z-ai/glm-5.3-flashx))))

(defun gptel-model (model)

  "Set the gptel model in the current buffer."

  (interactive

   (list (intern (completing-read "Model: "

                                  '("z-ai/glm-5.3"

                                    "z-ai/glm-5.3-flash"

                                    "z-ai/glm-5.3-flashx")))))

  (setq-local gptel-model model))

(use-package markdown-mode

  :defer t)

(provide 'init-tools)

;;; init-ui.el -*- lexical-binding: t; -*-

(when (display-graphic-p)

  (set-face-attribute 'default nil :family "BerkeleyMono Nerd Font" :height 110))

(use-package base16-theme)

(use-package nord-theme)

(load-theme 'nord t)

;;; Mode line

;; Evil's own indicator is dropped; the state is drawn by hand as a colored

;; square with the state letter. Icons are Nerd Font glyphs.

(setq evil-mode-line-format nil

      evil-echo-state nil)   ; no "-- INSERT --" in the echo area

(column-number-mode 1)

;; (defvar my/ml-states

;;   `((normal   "N" ,(alist-get 'base08 darkmatter-palette))

;;     (insert   "I" ,(alist-get 'base0A darkmatter-palette))

;;     (visual   "V" ,(alist-get 'base0B darkmatter-palette))

;;     (replace  "R" ,(alist-get 'red darkmatter-palette))

;;     (operator "O" ,(alist-get 'base0D darkmatter-palette))

;;     (motion   "M" ,(alist-get 'base0D darkmatter-palette))

;;     (emacs    "E" ,(alist-get 'base09 darkmatter-palette)))

;;   "Evil state -> (letter color) for the mode line.")

;; (defun my/ml-evil-state ()

;;   "Colored square with the current evil state letter."

;;   (when (bound-and-true-p evil-local-mode)

;;     (pcase-let ((`(,letter ,color) (or (alist-get evil-state my/ml-states)

;;                                        '("?" "#666666"))))

;;       (propertize (format " %s " letter)

;;                   'face `(:background ,color

;;                                       :foreground ,(alist-get 'base00 darkmatter-palette)

;;                                       :weight bold)))))

(setq-default

 mode-line-format

 '("%e"

   (:eval (my/ml-evil-state))

   "  "

   (:eval (when (and buffer-file-name (buffer-modified-p))

            (propertize "\uf111 " 'face '(:foreground "#e78a53"))))   ; nf-fa-circle

   (:propertize "%b" face mode-line-buffer-id)

   (:eval (when buffer-read-only "  \uf023"))                        ; nf-fa-lock

   "  "

   mode-name

   (:eval (when vc-mode

            (concat "  \ue0a0 "                                      ; branch

                    (string-trim (replace-regexp-in-string "^ *Git[-:]" "" vc-mode)))))

   mode-line-format-right-align

   ;; ERC / jabber activity ([#chan,...]) lives here

   (:eval (when (string-match-p "[^ ]" (format-mode-line global-mode-string))

            global-mode-string))

   "  %l:%c  %p "))

(setq initial-scratch-message

      " .              +   .                .   . .     .  .

                   .                    .       .     *

  .       *                        . . . .  .   .  + .

            \"You Are Here\"            .   .  +  . . .

.                 |             .  .   .    .    . .

                  |           .     .     . +.    +  .

                 \\|/            .       .   . .

        . .       V          .    * . . .  .  +   .

           +      .           .   .      +

                            .       . +  .+. .

  .                      .     . + .  . .     .      .

           .      .    .     . .   . . .        ! /

      *             .    . .  +    .  .       - O -

          .     .    .  +   . .  *  .       . / |

               . + .  .  .  .. +  .

.      .  .  .  *   .  *  . +..  .            *

 .      .   . .   .   .   . .  +   .    .            +

")

(provide 'init-ui)

;;; posts.el --- Emacs extension for Andromeda/Posts -*- lexical-binding: t; -*-

;;

;; Copyright (C) 2026 Steve Simkins

;;

;; Author: Steve Simkins <contact@stevedylan.dev>

;; Version: 0.0.1

;; Keywords: tools blogging extension

;; Homepage: https://github.com/stevedylandev/andromeda

;; Package-Requires: ((emacs "27.1"))

;;

;; This file is not part of GNU Emacs.

;;

;;; Commentary:

;; Sends micro posts to an Andromeda/posts instance.

;; Run M-x posts-compose, fill in the `name: value' fields at the top

;; (see `posts-fields'), write the content below, then press C-c C-c.

;;

;;; Code:

(require 'url)

(require 'json)

(require 'mailcap)

(require 'subr-x)

(require 'auth-source-pass)

(defgroup posts nil

  "Andromeda/posts."

  :group 'tools)

(defcustom posts-pass-entry "andromeda/posts-api-key"

  "Name of the `pass' entry holding the API key."

  :type 'string

  :group 'posts)

(defun posts--api-key ()

  "Return the API key from password-store."

  ;; Encode so the header is unibyte; otherwise url-http refuses to mix

  ;; it with a binary request body.

  (encode-coding-string

   (or (auth-source-pass-get 'secret posts-pass-entry)

       (user-error "No pass entry `%s'" posts-pass-entry))

   'utf-8))

(defcustom posts-endpoint "https://posts.stevedylan.dev/api/posts"

  "URL that receives the JSON post."

  :type 'string

  :group 'posts)

(defcustom posts-files-endpoint "https://posts.stevedylan.dev/api/files"

  "URL that receives multipart file uploads."

  :type 'string

  :group 'posts)

(defconst posts--max-file-size (* 10 1024 1024)

  "Largest file the server accepts, in bytes.")

;;;; Fields

(defcustom posts-fields

  '(("title")

    ("status" :default "draft" :choices ("draft" "published")))

  "Header fields read from the top of the compose buffer as `name: value'.

Each entry is (NAME . PLIST).  PLIST keys: `:required', `:default',

`:choices'.  Add an entry to support a new field; it is sent as a JSON

key of the same name."

  :type '(alist :key-type string :value-type plist)

  :group 'posts)

(defun posts--parse-buffer ()

  "Return (FIELDS . CONTENT) parsed from the current buffer.

FIELDS is an alist of raw (NAME . VALUE) strings from the leading

`name: value' lines.  CONTENT is everything after them."

  (save-excursion

    (goto-char (point-min))

    (let (fields)

      (while (looking-at "^\\([[:alnum:]_-]+\\):[ \t]*\\(.*?\\)[ \t]*$")

        (push (cons (downcase (match-string-no-properties 1))

                    (match-string-no-properties 2))

              fields)

        (forward-line 1))

      (cons (nreverse fields)

            (string-trim

             (buffer-substring-no-properties (point) (point-max)))))))

(defun posts--resolve-fields (parsed)

  "Validate PARSED against `posts-fields'; return alist with defaults applied."

  (dolist (p parsed)

    (unless (assoc (car p) posts-fields)

      (user-error "Unknown field `%s'" (car p))))

  (delq nil

        (mapcar

         (lambda (spec)

           (let* ((name (car spec))

                  (opts (cdr spec))

                  (raw (cdr (assoc name parsed)))

                  (val (if (and raw (not (string-empty-p raw)))

                           raw

                         (plist-get opts :default)))

                  (choices (plist-get opts :choices)))

             (when (and (plist-get opts :required) (null val))

               (user-error "Field `%s' is required" name))

             (when (and val choices (not (member val choices)))

               (user-error "Bad %s `%s' (one of: %s)"

                           name val (string-join choices ", ")))

             (and val (cons name val))))

         posts-fields)))

(defun posts--payload (fields content)

  "Build the JSON plist from FIELDS alist and CONTENT."

  (append (mapcan (lambda (f) (list (intern (concat ":" (car f))) (cdr f)))

                  fields)

          (list :content content)))

;;;; Sending

(defun posts (fields content)

  "Send a post to `posts-endpoint' as JSON.

FIELDS is an alist of (NAME . VALUE) strings, CONTENT the body."

  (interactive

   (let ((title (read-string "Title (optional): ")))

     (list (delq nil (list (and (not (string-empty-p title))

                                (cons "title" title))

                           (cons "status" "draft")))

           (read-string "Content: "))))

  (let ((url-request-method "POST")

        (url-request-extra-headers

         `(("Content-Type" . "application/json; charset=utf-8")

           ("X-API-Key" . ,(posts--api-key))))

        (url-request-data

         (encode-coding-string

          (json-serialize (posts--payload fields content))

          'utf-8)))

    (url-retrieve

     posts-endpoint

     (lambda (status)

       (unwind-protect

           (if (plist-get status :error)

               (message "Posts error: %S" (plist-get status :error))

             (goto-char (point-min))

             (re-search-forward "\r?\n\r?\n" nil t)

             (condition-case nil

                 (let ((resp (json-parse-buffer :object-type 'alist)))

                   (message "Posted: https://stevedylan.dev/now/%S" (alist-get 'slug resp)))

               (error (message "Posted (non-JSON response)"))))

         (kill-buffer (current-buffer))))

     nil t)))

;;;; Uploading files

(defun posts--multipart-body (boundary file name)

  "Return a unibyte multipart/form-data body for FILE using BOUNDARY.

NAME, when non-nil, is sent as the `name' field."

  (let ((type (or (mailcap-file-name-to-mime-type file)

                  "application/octet-stream"))

        (filename (replace-regexp-in-string

                   "\"" "\\\\\""

                   (encode-coding-string (file-name-nondirectory file) 'utf-8))))

    (with-temp-buffer

      (set-buffer-multibyte nil)

      (when name

        (insert "--" boundary "\r\n"

                "Content-Disposition: form-data; name=\"name\"\r\n\r\n"

                (encode-coding-string name 'utf-8) "\r\n"))

      (insert "--" boundary "\r\n"

              "Content-Disposition: form-data; name=\"file\"; filename=\""

              filename "\"\r\n"

              "Content-Type: " type "\r\n\r\n")

      (insert-file-contents-literally file)

      (goto-char (point-max))

      (insert "\r\n--" boundary "--\r\n")

      (buffer-string))))

(defun posts--response-json ()

  "Parse the JSON body of the current HTTP response buffer, or nil."

  (goto-char (point-min))

  (when (re-search-forward "\r?\n\r?\n" nil t)

    (ignore-errors (json-parse-buffer :object-type 'alist))))

(defun posts-upload-file (file &optional name callback)

  "Upload FILE to `posts-files-endpoint'.

NAME, if non-empty, sets the stored filename.  On success the file's

URL is copied to the kill ring and CALLBACK, if non-nil, is called

with the parsed response alist."

  (interactive

   (list (read-file-name "Upload file: " nil nil t)

         (read-string "Name (optional): ")))

  (setq file (expand-file-name file))

  (unless (file-regular-p file)

    (user-error "Not a regular file: %s" file))

  (when (> (file-attribute-size (file-attributes file)) posts--max-file-size)

    (user-error "File exceeds 10 MB: %s" file))

  (when (and name (string-empty-p (string-trim name)))

    (setq name nil))

  (let* ((boundary (format "posts-%s" (md5 (format "%s%s" (random) (float-time)))))

         (url-request-method "POST")

         (url-request-extra-headers

          `(("Content-Type" . ,(encode-coding-string

                                (concat "multipart/form-data; boundary=" boundary)

                                'utf-8))

            ("X-API-Key" . ,(posts--api-key))))

         (url-request-data (posts--multipart-body boundary file name)))

    (message "Uploading %s..." (file-name-nondirectory file))

    (url-retrieve

     posts-files-endpoint

     (lambda (status)

       (unwind-protect

           (let ((err (plist-get status :error))

                 (resp (posts--response-json)))

             (cond

              ((equal err '(error http 409))

               (message "Upload failed: name `%s' is already taken" name))

              (err

               (message "Upload error: %S%s" err

                        (if resp (format " %S" resp) "")))

              ((null (alist-get 'url resp))

               (message "Uploaded (unexpected response)"))

              (t

               (kill-new (alist-get 'url resp))

               (message "Uploaded: %s (copied)" (alist-get 'url resp))

               (when callback (funcall callback resp)))))

         (kill-buffer (current-buffer))))

     nil t)))

;;;; Compose buffer

(defvar posts-compose-mode-map

  (let ((m (make-sparse-keymap)))

    (define-key m (kbd "C-c C-c") #'posts-compose-submit)

    (define-key m (kbd "C-c C-k") #'posts-compose-cancel)

    (define-key m (kbd "C-c C-a") #'posts-compose-attach)

    m)

  "Keymap for `posts-compose-mode'.")

(define-derived-mode posts-compose-mode text-mode "Posts"

  "Compose a post.  Leading `name: value' lines are fields, the rest is content.

\\{posts-compose-mode-map}"

  (setq header-line-format

        "Fields as `name: value' lines, then content.  C-c C-c send, C-c C-a attach file, C-c C-k cancel"))

;;;###autoload

(defun posts-compose ()

  "Open a buffer to compose a post."

  (interactive)

  (pop-to-buffer (get-buffer-create "*posts-compose*"))

  (erase-buffer)

  (posts-compose-mode)

  (dolist (spec posts-fields)

    (insert (car spec) ": " (or (plist-get (cdr spec) :default) "") "\n"))

  (insert "\n")

  (goto-char (point-min))

  (end-of-line))

(defun posts-compose-submit ()

  "Parse the compose buffer and send it."

  (interactive)

  (let* ((parsed (posts--parse-buffer))

         (fields (posts--resolve-fields (car parsed)))

         (content (cdr parsed)))

    (when (string-empty-p content)

      (user-error "Content is empty"))

    (posts fields content)

    (quit-window t)))

(defun posts-compose-attach (file &optional name)

  "Upload FILE (stored as NAME) and insert a Markdown link at point.

Images are inserted as `![](url)'."

  (interactive

   (list (read-file-name "Attach file: " nil nil t)

         (read-string "Name (optional): ")))

  (let ((marker (point-marker)))

    (posts-upload-file

     file name

     (lambda (resp)

       (when (buffer-live-p (marker-buffer marker))

         (with-current-buffer (marker-buffer marker)

           (save-excursion

             (goto-char marker)

             (insert (format "%s[%s](%s)"

                             (if (string-prefix-p "image/" (or (alist-get 'content_type resp) ""))

                                 "!" "")

                             (or (alist-get 'original_name resp)

                                 (alist-get 'filename resp) "")

                             (alist-get 'url resp))))))))))

(defun posts-compose-cancel ()

  "Discard the compose buffer."

  (interactive)

  (quit-window t))

(provide 'posts)

;;; posts.el ends here

;;; uguu.el --- Upload files to uguu.se -*- lexical-binding: t; -*-

;;

;;; Commentary:

;; `uguu-upload-file' and `uguu-upload-clipboard' upload to uguu.se and put

;; the resulting link in the kill ring.  In an ERC buffer the link is also

;; inserted at the prompt.  A prefix argument flips that behavior.

;;

;;; Code:

(require 'subr-x)

(defgroup uguu nil

  "Upload files to uguu.se."

  :group 'tools)

(defcustom uguu-endpoint "https://uguu.se/upload?output=text"

  "Upload URL.  `output=text' makes the response just the file link."

  :type 'string)

(defcustom uguu-insert-modes '(erc-mode)

  "Major modes where the link is inserted at point by default."

  :type '(repeat symbol))

(defun uguu--finish (url insert)

  "Copy URL to the kill ring, and insert it when INSERT is non-nil."

  (kill-new url)

  (when insert

    (when (derived-mode-p 'erc-mode)

      (goto-char (point-max)))

    (insert url))

  (message "Uploaded: %s%s" url (if insert "" " (copied)")))

(defun uguu--upload (file insert &optional cleanup)

  "Upload FILE asynchronously, then call `uguu--finish' with INSERT.

When CLEANUP is non-nil, delete FILE afterwards."

  (let ((buf (current-buffer))

        (out (generate-new-buffer " *uguu*")))

    (message "Uploading %s..." (file-name-nondirectory file))

    (make-process

     :name "uguu" :buffer out :noquery t

     :command (list "curl" "-sS" "--fail-with-body"

                    "-F" (concat "files[]=@" (expand-file-name file))

                    uguu-endpoint)

     :sentinel

     (lambda (proc _event)

       (when (memq (process-status proc) '(exit signal))

         (let ((resp (with-current-buffer out (string-trim (buffer-string)))))

           (kill-buffer out)

           (when cleanup (ignore-errors (delete-file file)))

           (if (and (zerop (process-exit-status proc))

                    (string-prefix-p "http" resp))

               (if (buffer-live-p buf)

                   (with-current-buffer buf (uguu--finish resp insert))

                 (uguu--finish resp nil))

             (message "Uguu upload failed: %s" resp))))))))

(defun uguu--insert-p (arg)

  "Whether to insert the link, given prefix ARG."

  (let ((default (apply #'derived-mode-p uguu-insert-modes)))

    (if arg (not default) default)))

;;;###autoload

(defun uguu-upload-file (file &optional arg)

  "Upload FILE to uguu.se.  Copy the link; insert it too in ERC.

With prefix ARG, flip whether the link is inserted."

  (interactive (list (read-file-name "Upload file: " nil nil t) current-prefix-arg))

  (uguu--upload file (uguu--insert-p arg)))

(defun uguu--clipboard-file ()

  "Return the path of a file copied in Finder/CleanShot, or nil.

Checked before the image data, which for a copied file is just its icon."

  (with-temp-buffer

    (when (zerop (call-process

                  "osascript" nil '(t nil) nil

                  "-e" "POSIX path of (the clipboard as «class furl»)"))

      (let ((path (string-trim (buffer-string))))

        (and (file-regular-p path) path)))))

(defun uguu--clipboard-image ()

  "Write the clipboard image to a temp PNG and return its path, or nil."

  (let ((tmp (make-temp-file "uguu-" nil ".png")))

    (if (zerop (call-process

                "osascript" nil nil nil

                "-e" (format "set f to open for access POSIX file %S with write permission"

                             tmp)

                "-e" "set eof f to 0"

                "-e" "write (the clipboard as «class PNGf») to f"

                "-e" "close access f"))

        tmp

      (delete-file tmp)

      nil)))

;;;###autoload

(defun uguu-upload-clipboard (&optional arg)

  "Upload the clipboard (an image, else text) to uguu.se.

With prefix ARG, flip whether the link is inserted."

  (interactive "P")

  (let* ((insert (uguu--insert-p arg))

         (file (uguu--clipboard-file))

         (img (and (not file) (uguu--clipboard-image))))

    (cond

     (file (uguu--upload file insert))

     (img (uguu--upload img insert t))

     (t

      (let ((text (or (ignore-errors (gui-get-selection 'CLIPBOARD 'STRING))

                      (car kill-ring)))

            (tmp (make-temp-file "uguu-" nil ".txt")))

        (unless (and text (not (string-empty-p text)))

          (user-error "Clipboard is empty"))

        (write-region text nil tmp nil 'silent)

        (uguu--upload tmp insert t))))))

(provide 'uguu)

;;; uguu.el ends here

;;; darkmatter-theme.el --- Darkmatter on base16 -*- lexical-binding: t; -*-

;; https://darkmattertheme.com

;; Palette + a few overrides on top of `base16-theme' (package base16-theme).

;; The 16 slots are mapped to match the old doom-darkmatter roles.

(require 'cl-lib)

(require 'base16-theme)

;;; Palette -- edit these and everything below follows

(defun darkmatter--blend (a b alpha)

  "Mix hex colors A and B; ALPHA is the share of B (0..1)."

  (cl-flet ((rgb (c) (mapcar (lambda (i) (string-to-number (substring c i (+ i 2)) 16))

                             '(1 3 5))))

    (apply #'format "#%02x%02x%02x"

           (cl-mapcar (lambda (x y) (round (+ (* x (- 1 alpha)) (* y alpha))))

                      (rgb a) (rgb b)))))

(defvar darkmatter-palette

  '((base00 . "#121113")   ; background

    (base01 . "#121212")   ; lighter background

    (base02 . "#222222")   ; selection

    (base03 . "#333333")   ; comments

    (base04 . "#999999")   ; dark foreground, doc strings

    (base05 . "#c1c1c1")   ; foreground

    (base06 . "#999999")   ; light foreground

    (base07 . "#c1c1c1")   ; lightest

    (base08 . "#5f8787")   ; variables, errors

    (base09 . "#aaaaaa")   ; constants, numbers

    (base0A . "#e78a53")   ; types, accent, warnings

    (base0B . "#fbcb97")   ; strings, added

    (base0C . "#aaaaaa")   ; builtins, support

    (base0D . "#888888")   ; functions

    (base0E . "#999999")   ; keywords

    (base0F . "#444444")   ; deprecated

    (red    . "#aa6c6c"))  ; extra: removed lines, ERC errors (not a base16 slot)

  "Darkmatter colors. Base16 slots plus `red'. Everything else is derived.")

(deftheme darkmatter "Darkmatter, based on Black Metal Bathory.")

(let* ((base00 (alist-get 'base00 darkmatter-palette))

       (base01 (alist-get 'base01 darkmatter-palette))

       (base02 (alist-get 'base02 darkmatter-palette))

       (base03 (alist-get 'base03 darkmatter-palette))

       (base04 (alist-get 'base04 darkmatter-palette))

       (base05 (alist-get 'base05 darkmatter-palette))

       (base06 (alist-get 'base06 darkmatter-palette))

       (base07 (alist-get 'base07 darkmatter-palette))

       (base08 (alist-get 'base08 darkmatter-palette))

       (base09 (alist-get 'base09 darkmatter-palette))

       (base0A (alist-get 'base0A darkmatter-palette))

       (base0B (alist-get 'base0B darkmatter-palette))

       (base0C (alist-get 'base0C darkmatter-palette))

       (base0D (alist-get 'base0D darkmatter-palette))

       (base0E (alist-get 'base0E darkmatter-palette))

       (base0F (alist-get 'base0F darkmatter-palette))

       (red    (alist-get 'red darkmatter-palette))

       ;; roles used by the face overrides below

       (bg      base00)

       (bg-alt  base01)

       (sel     base02)

       (comment base03)

       (dim     base04)

       (fg      base05)

       (fg-hi   base06)

       (fg-max  base07)

       (teal    base08)

       (const   base09)

       (orange  base0A)

       (string  base0B)

       (func    base0D)

       (kw      base0E)

       (dep     base0F)

       ;; derived

       (base0          (darkmatter--blend bg "#000000" 0.4))

       (faint          (darkmatter--blend bg-alt kw 0.2))

       (muted          (darkmatter--blend bg dim 0.45))

       (bg-tint        (darkmatter--blend bg const 0.15))

       (added-fg       (darkmatter--blend string "#000000" 0.2))

       (added-bg       (darkmatter--blend bg string 0.1))

       (added-bg-hi    (darkmatter--blend bg string 0.2))

       (removed-bg     (darkmatter--blend sel red 0.1))

       (removed-bg-hi  (darkmatter--blend sel red 0.2))

       (changed-bg     (darkmatter--blend bg orange 0.1))

       (changed-bg-hi  (darkmatter--blend bg orange 0.2))

       (red-dark       (darkmatter--blend red "#000000" 0.2))

       (orange-dark    (darkmatter--blend orange "#000000" 0.2)))

  ;; Fringe/line numbers share the main background, like doom-darkmatter

  (setq base16-theme-distinct-fringe-background nil)

  ;; In a tty base16 defaults to the terminal's ANSI palette by name

  ;; (base02 -> brightyellow, i.e. orange in ghostty), so map our hex

  ;; colors to the nearest 256-color instead.

  (setq base16-theme-256-color-source 'colors)

  (base16-theme-define

   'darkmatter

   (list :base00 base00 :base01 base01 :base02 base02 :base03 base03

         :base04 base04 :base05 base05 :base06 base06 :base07 base07

         :base08 base08 :base09 base09 :base0A base0A :base0B base0B

         :base0C base0C :base0D base0D :base0E base0E :base0F base0F))

  ;; Where doom-darkmatter differs from stock base16 role assignments,

  ;; plus packages base16 has no faces for

  (custom-theme-set-faces

   'darkmatter

   `(cursor                      ((t (:background ,orange))))

   `(font-lock-variable-name-face ((t (:foreground ,teal))))

   `(font-lock-builtin-face      ((t (:foreground ,kw))))

   `(font-lock-constant-face     ((t (:foreground ,const))))

   `(font-lock-number-face       ((t (:foreground ,const))))

   `(font-lock-warning-face      ((t (:foreground ,orange))))

   `(mode-line                   ((t (:foreground ,fg :background ,bg :overline ,sel :box nil))))

   `(mode-line-inactive          ((t (:foreground ,dim :background ,bg :overline ,sel :box nil))))

   `(mode-line-buffer-id         ((t (:foreground ,fg :weight bold))))

   `(line-number                 ((t (:foreground ,faint :background ,bg))))

   `(line-number-current-line    ((t (:foreground ,orange :background ,bg))))

   `(vertical-border             ((t (:foreground ,sel))))

   `(erc-prompt-face             ((t (:foreground ,orange :weight bold))))

   ;; base16 uses base01 for highlight, which is ~identical to bg here

   `(highlight                   ((t (:background ,sel))))

   `(icomplete-selected-match    ((t (:foreground ,orange :background ,sel :weight bold :extend t))))

   `(completions-highlight       ((t (:inherit icomplete-selected-match))))

   ;; base16 makes this inherit gnus-group-news-6, whose default spec

   ;; inherits this face back -> cycle error in enable-theme

   `(gnus-group-news-6-empty     ((t (:foreground ,base04 :inherit outline-2))))

   ;; base16 only themes the normal 8; bright ones (used by ghostel etc.)

   ;; fall back to Emacs defaults. Match the darkmatter ghostty palette.