# Licensed fonts: kept locally, not committed

fonts/

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

;; Faster startup: defer GC, restore after init

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

(add-hook 'emacs-startup-hook

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

;; Skip UI chrome before first frame draws

(setq package-enable-at-startup t

      inhibit-startup-screen t

      frame-inhibit-implied-resize t)

(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/")

  "Where state, backups and custom settings live (outside the dotfiles repo).")

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

;;; Packages

(require 'package)

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

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

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

(unless package-archive-contents (package-refresh-contents))

(setq use-package-always-ensure t)

(require 'init-defaults)

(require 'init-evil)

(require 'init-ui)

(require 'init-erc)

(require 'init-jabber)

(require 'init-mail)

(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 worth having

(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, relative like Doom config

(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; -*-

(require 'auth-source-pass)

;; 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")

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

    "m"   '(:ignore t :wk "mail")

    "mc"  '(mu4e-compose-new :wk "compose")

    "ms"  '(mml-secure-message-sign-pgpmime :wk "sign")

    "me"  '(mml-secure-message-encrypt-pgpmime :wk "sign+encrypt")

    "mE"  '((lambda () (interactive) (mml-secure-message-encrypt-pgpmime t))

            :wk "encrypt only")

    "md"  '(my/mail-decrypt-bridge :wk "decrypt (bridge)")

    "mn"  '(mml-unsecure-message :wk "remove sign/encrypt")

    "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; -*-

(require 'auth-source-pass)

;; 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

  ;; `jabber-roster' autoloads from jabber-roster-menu, which never loads

  ;; jabber.el, so :config (account list) would never run. Pull it in.

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

(provide 'init-jabber)

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

;;; Syntax highlighting: tree-sitter (built-in)

;; Every built-in *-ts-mode replaces its classic mode, and the grammar is

;; compiled into ~/.config/emacs/tree-sitter the first time it's needed.

;; Needs a C compiler (xcode-select --install).

(setopt treesit-enabled-modes t

        treesit-auto-install-grammar 'always

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

;;; LSP: eglot (built-in)

;; Add a language: one line here.  MODES is a ts-mode (or list of them),

;; SERVER is the command eglot runs.  Entries whose server binary isn't on

;; PATH are skipped, so it's fine to list servers you haven't installed.

;; A mode not built into Emacs needs its package first, e.g.

;;   (use-package zig-mode)  then  (zig-mode "zls")

(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     "basedpyright-langserver" "--stdio")

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

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

(use-package eglot

  :ensure nil

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

    (let ((modes (ensure-list (car entry)))

          (cmd (cdr entry)))

      (when (executable-find (car cmd))

        (add-to-list 'eglot-server-programs (cons modes cmd))

        (dolist (mode modes)

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

;; 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"  '(eglot-format-buffer :wk "format")

    "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-mail.el -*- lexical-binding: t; -*-

;; mu4e ships with Guix's `mu' package (on EMACSLOADPATH via the profile), not ELPA.

(use-package mu4e

  :ensure nil

  :commands (mu4e mu4e-compose-new)

  :config

  (setq user-mail-address "contact@stevedylan.dev"

        ;; Fetching

        mu4e-get-mail-command "mbsync -a"

        mu4e-update-interval 300

        mu4e-change-filenames-when-moving t   ; required with mbsync

        ;; Folders (adjust to match `mbsync -l local`)

        mu4e-sent-folder   "/local/Sent"

        mu4e-drafts-folder "/local/Drafts"

        mu4e-trash-folder  "/local/Trash"

        mu4e-refile-folder "/local/Archive"

        ;; Sending via msmtp

        sendmail-program (executable-find "msmtp")

        send-mail-function #'sendmail-send-it

        message-send-mail-function #'message-send-mail-with-sendmail

        message-sendmail-envelope-from 'header

        message-kill-buffer-on-exit t

        ;; GPG

        mml-secure-openpgp-sign-with-sender t   ; pick key by From address

        mml-secure-openpgp-encrypt-to-self t    ; keep Sent copies readable

        mm-verify-option 'always                ; verify signatures on view

        mm-decrypt-option 'always               ; auto-decrypt on view

        mu4e-maildir-shortcuts

        '((:maildir "/local/Inbox"   :key ?i)

          (:maildir "/local/Sent"    :key ?s)

          (:maildir "/local/Drafts"  :key ?d)

          (:maildir "/local/Archive" :key ?a)

          (:maildir "/local/Trash"   :key ?t))))

;; Proton Bridge rewrites PGP/MIME into multipart/mixed with the armored

;; block as an attachment, so Emacs won't auto-decrypt. Pull the block out

;; of the raw message and decrypt it by hand.

(require 'mm-decode)

(require 'epg)

(require 'cl-lib)

(defun my/mail--pgp-blocks (path)

  "Return armored PGP message strings found in the parts of PATH."

  (with-temp-buffer

    (insert-file-contents-literally path)

    (let (blocks)

      (cl-labels ((walk (h)

                    (cond ((and (consp h) (stringp (car h)))

                           (mapc #'walk (cdr h)))

                          ((and (consp h) (bufferp (car h)))

                           (let ((s (mm-get-part h)))

                             (when (string-match "-----BEGIN PGP MESSAGE-----" s)

                               (push (substring s (match-beginning 0)) blocks)))))))

        (walk (mm-dissect-buffer t t)))

      (nreverse blocks))))

(defun my/mail-decrypt-bridge ()

  "Decrypt the PGP block of the mu4e message at point into a buffer."

  (interactive)

  (let* ((msg (mu4e-message-at-point))

         (blocks (or (my/mail--pgp-blocks (mu4e-message-field msg :path))

                     (user-error "No PGP block in message")))

         (ctx (epg-make-context 'OpenPGP))

         (buf (get-buffer-create "*mail-decrypted*")))

    (with-current-buffer buf

      (let ((inhibit-read-only t))

        (erase-buffer)

        (dolist (b blocks)

          (insert (decode-coding-string

                   (epg-decrypt-string ctx b) 'utf-8)

                  "\n"))

        (goto-char (point-min))

        (special-mode)))

    (pop-to-buffer buf)))

(provide 'init-mail)

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

;; https://www.jamescherti.com/emacs-terminal-performance-vterm-eat-ansi-term-ghostel/

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

(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

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

  ;; Fresh list before every update (`G' / `elfeed-update')

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

;; ob-go isn't bundled with org; must load before org-babel-do-load-languages

(use-package ob-go)

(use-package org

  :ensure nil

  :config

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

;; HTML export: darkmatter CSS from org.css, inlined so exports are self-contained

(use-package ox-html

  :ensure nil

  :after org

  :config

  (defun my/org-html-head ()

    "Return `org-html-head' contents with org.css inlined."

    (let ((css (expand-file-name "org.css" user-emacs-directory)))

      (concat "<meta name=\"theme-color\" content=\"#121113\" />\n"

              "<style>\n"

              (with-temp-buffer

                (insert-file-contents css)

                (buffer-string))

              "</style>")))

  (setq org-html-head-include-default-style nil

        org-html-head-include-scripts nil

        org-html-validation-link nil

        org-html-postamble nil

        org-html-htmlize-output-type 'css

        org-html-head (my/org-html-head))

  ;; Re-read org.css on each export so edits apply without restarting

  (advice-add 'org-html-export-as-html :before

              (lambda (&rest _) (setq org-html-head (my/org-html-head))))

  (advice-add 'org-html-export-to-html :before

              (lambda (&rest _) (setq org-html-head (my/org-html-head)))))

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

(require 'posts)

(require 'uguu)

(provide 'init-tools)

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

(when (display-graphic-p)

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

(use-package base16-theme)

(load-theme 'darkmatter 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 '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."

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

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

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

  "URL that receives the JSON post."

  :type 'string

  :group 'posts)

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

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

    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 to send, C-c C-k to 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-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 for org HTML export (inlined by init-tools.el) */

@font-face {

  font-family: "Commit Mono";

  src: local("Commit Mono"), local("CommitMono-400-Regular");

  font-weight: 400;

  font-style: normal;

}

@font-face {

  font-family: "Commit Mono";

  src: local("Commit Mono Bold"), local("CommitMono-700-Regular");

  font-weight: 700;

  font-style: normal;

}

* {

  padding: 0;

  margin: 0;

  box-sizing: border-box;

  font-family: "Commit Mono", monospace, sans-serif;

  scrollbar-width: none;

  -ms-overflow-style: none;

}

html {

  background: #121113;

  color: #ffffff;

  font-size: 14px;

  line-height: 1.6;

}

html::-webkit-scrollbar {

  display: none;

}

body {

  max-width: 700px;

  margin: auto;

  padding: 0 1rem 4rem;

}

@media (max-width: 480px) {

  body {

    padding: 1rem;

  }

}

a {

  color: #ffffff;

  text-decoration: none;

}

a:hover {

  opacity: 0.7;

}

#content {

  display: flex;

  flex-direction: column;

  gap: 1rem;

}

/* Title */

.title {

  margin-top: 2rem;

  padding-bottom: 1rem;

  border-bottom: 1px solid #333;

  font-size: 28px;

  font-weight: 700;

  text-transform: uppercase;

  text-align: left;

}

.subtitle {

  font-size: 12px;

  opacity: 0.5;

}

/* Headings */

h1, h2, h3, h4, h5, h6 {

  font-weight: 700;

}

h1 { font-size: 18px; }

h2 { font-size: 16px; margin-top: 1rem; }

h3 { font-size: 15px; }

h4, h5, h6 { font-size: 14px; }

.section-number-2,

.section-number-3,

.section-number-4 {

  opacity: 0.5;

}

.outline-2, .outline-3, .outline-4, .outline-text-2, .outline-text-3, .outline-text-4 {

  display: flex;

  flex-direction: column;

  gap: 0.75rem;

}

/* Text */

p, li {

  font-size: 14px;

}

ul, ol {

  padding-left: 1.5rem;

}

li + li {

  margin-top: 0.25rem;

}

b, strong { font-weight: 700; }

i, em { font-style: italic; }

del { opacity: 0.5; }

.timestamp, .timestamp-kwd, .timestamp-wrapper {

  font-size: 12px;

  opacity: 0.5;

}

.tag {

  font-size: 12px;

  opacity: 0.5;

  float: right;

}

.tag span {

  background: none;

  font-weight: 400;

}

/* TODO keywords: no color, weight/opacity only */

.todo, .done {

  font-size: 12px;

  font-weight: 700;

  text-transform: uppercase;

}

.done {

  opacity: 0.5;

}

/* Code */

code {

  background: #1e1c1f;

  padding: 0.1rem 0.3rem;

  font-size: 13px;

}

pre {

  background: #1e1c1f;

  color: #ffffff;

  border: none;

  border-radius: 0;

  box-shadow: none;

  padding: 0.75rem 1rem;

  font-size: 13px;

  overflow-x: auto;

  white-space: pre;

}

pre code {

  background: none;

  padding: 0;

}

pre.src:before {

  display: none;

}

/* htmlize classes (needs org-html-htmlize-output-type 'css) */

pre span[class^="org-"] {

  color: #ffffff;

  background: none;

  font-weight: 400;

  font-style: normal;

}

pre span.org-comment,

pre span.org-comment-delimiter,

pre span.org-doc {

  opacity: 0.5;

  font-style: italic;

}

pre span.org-keyword,

pre span.org-function-name,

pre span.org-type {

  font-weight: 700;

}

pre span.org-string {

  opacity: 0.7;

}

/* Blockquote */

blockquote {

  border-left: 2px solid #555;

  padding-left: 0.75rem;

  opacity: 0.7;

}

blockquote p {

  margin: 0;

}

/* Tables */

table {

  border-collapse: collapse;

  width: 100%;

  border: none;

}

table caption {

  font-size: 12px;

  opacity: 0.5;

  text-align: left;

  margin-bottom: 0.25rem;

}

th, td {

  padding: 0.4rem 0.75rem 0.4rem 0;

  border: none;

  border-bottom: 1px solid #333;

  text-align: left;

}

th {

  opacity: 0.5;

  font-weight: 400;

  font-size: 12px;

  text-transform: uppercase;

}

/* Misc */