Since everybody seems to be writing literate Emacs configs these days, I wanted to give it a spin as well.
I’m not really very proficient on elisp, so this config is mostly a collection of code I’ve stolen from others.
Since this document literally is my Emacs configuration, at times it may contain code that is a
work in progress, silly comments, TODO and FIXMEs and so on.
References
As many others I’ve been using tecosaurs Emacs config as my base configuration. It’s one of the most
elaborated literate configs I’ve seen, with a lot of nice little tweaks. My configuration broadly follows his,
but it’s slowly morphing into my own :)
So a big thanks to tecosaur for making my onboarding to Doom Emacs a smooth experience!
Emacs can be installed in many ways. I’m usually on a Mac, so I just use Homebrew.
There’s a couple of Emacs packages in Homebrew, but the most popular seems to be emacs-plus and emacs-mac.
I have been using emacs-mac for some time now, but was previously running emacs-plus.
Fix annoying max open files for Emacs
When using LSP servers with Emacs, it’s easy to hit the “max open files” error. Emacs doesn’t seem to use
operating system ulimit, but uses pselect which is limited to FD_SETSIZE file descriptors, usually 1024.
This means that changing ulimit will not change the value of FD_SETSIZE compiled into Emacs and macOS
libraries. To overcome this limitation we’ve to set the FD_SETSIZE CFLAG when compiling Emacs.
To add Emacs to /Applications enter the following commands in a terminal (it’s also printed to the screen after installing emacs-plus).
$ osascript -e 'tell application "Finder" to make alias file to posix file "/usr/local/opt/emacs-plus@30/Emacs.app" at POSIX file "/Applications" with properties {name:"Emacs.app"}'$ sudo codesign --force --deep --sign - /usr/local/opt/emacs-plus@30/Emacs.app
Unless I signed the binaries, Finder refuses to open them. See this Github issue.
Getting started
Describe steps required to do in order to get this up and running on a new machine.
Install nerd-fonts
Doom modeline required nerd-fonts now. run M-x nerd-icons-install-fonts.
Configuration
Remember to run doom sync after editing this file.
See the Common config anti-patterns thread to avoid common pitfalls.
;;; config.el -*- lexical-binding: t; -*-
Personal preferences - The random config dumping ground
Some functionality uses this to identify you, e.g. GPG configuration, email
clients, file templates and snippets.
(defconst user-home-directory (expand-file-name (file-name-as-directory"~"))
"A constant that holds the current users home directory.")
Better defaults
General settings that makes life a bit easier.
(setq auto-save-default t; I don't want to lose work. auto-revert-use-notify t; Use file notifications for instant updates auto-revert-interval 1; Fallback poll interval (seconds) auto-revert-avoid-polling t; Prefer notifications over polling revert-without-query '(".*") ; Never prompt, revert all files silently delete-by-moving-to-trash t; Delete files to trash. confirm-kill-emacs nil; Don't ask if I really want to quit! diff-hl-flydiff-delay 2; Controls how often `diff-hl' updates in seconds. display-time-24hr-format t; I dont know the difference between AM and PM. evil-want-fine-undo t; More granular undos in evil insert mode. evil-ex-substitute-global t; More often than not, I want /s on ex commands. evil-kill-on-visual-paste nil; Don't add overwritten text in visual mode to the kill ring. fill-column 120; We have lot's of screen estate. history-length 1000; Remember more history. warning-minimum-level :error ; The minimum severity level before displaying the warning buffer. mouse-wheel-tilt-scroll t; Scroll horizontally using the mouse. mouse-wheel-flip-direction t; Scrolling for oldies. pixel-scroll-precision-mode t; Enable pixel scroll precision mode (requires Emacs 29). scroll-margin 10; Keep a little scroll margin. sh-shell "sh"; The shell to use when spawning external commands. undo-limit 16000000; Increase undo limit to 16Mb. vc-follow-symlinks nil; Don't follow symlinks, edit them directly. which-key-idle-delay 0.2; Makes which-key feels more responsive. window-combination-resize t; Take new window space from all other windows (not just the current). window-divider-default-right-width 3; Thicker window dividers. x-stretch-cursor t; Stretch cursor to the glyph width. )
Here are some modes I always want active.
(diff-hl-flydiff-mode 1) ; This makes `diff-hl' updated asynchronous(display-time-mode 1) ; I want to know what time it is(global-auto-revert-mode 1) ; Auto-revert buffers when files change on disk(drag-stuff-global-mode 1) ; Drag text around(global-treesit-fold-mode 1) ; Enable tree-sitter based code folding(global-treesit-fold-indicators-mode 1) ; Show fold indicators in the fringe(global-goto-address-mode 1) ; A minor mode to render urls and like as links(global-subword-mode 1) ; Iterate through CamelCase words - Not sure how I like this(smartparens-global-mode 1) ; Always enable smartparens(ws-butler-global-mode 1) ; Unobtrusive way to trim spaces on end of lines(window-divider-mode 1) ; Show window dividers;; Enable visual-line-mode in certain modes (so I don't have to scroll horizontally).(dolist (hook '(text-mode-hook
comint-mode-hook))
(add-hook hook #'visual-line-mode))
Sometimes I’m getting the dreaded “Too many open files” error in Emacs, which doesn’t seem to take into
account ulimit, nor sysctl kern.maxfiles / sysctl kern.maxfilesperproc.
If you know a workaround for this, please let me know!
Meanwhile, let’s define a function that clears the existing file notification watches from Emacs as a workaround.
(require 'filenotify)
(defun file-notify-rm-all-watches (&optional silent)
"Remove all existing file notification watches from Emacs.
When `silent' is non-nil, don't activate the progress-reporter." (interactive)
(if silent (maphash (lambda (key _value) (file-notify-rm-watch key)) file-notify-descriptors)
(let ((progress-reporter
(make-progress-reporter
(format"Clearing all existing file notification watches... "))))
(maphash (lambda (key _value) (file-notify-rm-watch key)) file-notify-descriptors)
(progress-reporter-done progress-reporter))))
So, whenever we’re getting the “Too many open files” error in Emacs, just M-x file-notify-rm-all-watches,
and we should be good to go again.
Since this seems to be happening quite frequently, I’ll just put it on a timer for now.
;; Run every 5 minutes(run-with-timer 0 (*560) 'file-notify-rm-all-watchest)
GPG, SSH and encryption
For GPG I want to use ~/.authinfo.gpg since I usually keep this file in my dotfiles repository. It’s easy to
just copy it in place whenever I’m on a new computer.
(after! epa
(setq auth-source-cache-expiry nil; Don't expire cached auth sources. epa-file-select-keys nil; If non-nil, always asks user to select recipients. epa-file-cache-passphrase-for-symmetric-encryption t; Cache passphrase for symmetrical encryptions. epg-pinentry-mode 'loopback; Use Emacs pinentry for passphrase prompts. epg-gpg-program (cond ((eq system-type 'darwin) "/opt/homebrew/bin/gpg")
((eq system-type 'gnu/linux) "/usr/bin/gpg")
((eq system-type 'windows-nt) "C:/Program Files (x86)/GNU/GnuPG/gpg2")))
(pinentry-start)
;; (load-file (expand-file-name "secrets.el.gpg" doom-private-dir)) ; This cause weird errors )
I’m using gpg-agent instead of ssh-agent so we need to connect here.
Update the TTY at startup and before GPG operations to avoid pinentry issues.
Even though Doom Emacs makes a lot of stuff easy, I always needs to look up how to bind keymaps.
Window navigation
Select windows using M-[1..9].
(map! "M-0"#'treemacs-select-window ;; make treemacs accessible as Window #0"M-1"#'winum-select-window-1
"M-2"#'winum-select-window-2
"M-3"#'winum-select-window-3
"M-4"#'winum-select-window-4
"M-5"#'winum-select-window-5
"M-6"#'winum-select-window-6
"M-7"#'winum-select-window-7
"M-8"#'winum-select-window-8
"M-9"#'winum-select-window-9)
Close temporary windows in the current frame.
(defun cust/close-temporary-window ()
"Close all temporary windows in the current frame.
Returns t if any windows were closed." (interactive)
(save-selected-window
(let (result)
(dolist (window (window-list))
(select-window window)
(cond ((or (eq major-mode #'help-mode)
(eq major-mode #'compilation-mode)
(eq major-mode #'completion-list-mode)
(eq major-mode #'grep-mode)
(eq major-mode #'apropos-mode))
(quit-window)
(setf result t))
((eq major-mode #'magit-popup-mode)
(magit-popup-quit)
(setf result t))))
result)))
;; Bind the function to ESC(let ((key
(if window-system (kbd "<escape>") "\M-q")))
(global-set-key key #'cust/close-temporary-window))
When creating a new window, try to use the same window if possible or create a new below selected window.
Some of the default Doom workspace navigation keybindings seems a bit counter intuitive for
my workflow, so I rebind some of them.
When connecting via emacsclient, resume the last active workspace instead of creating a new empty one.
Doom’s default persp-emacsclient-init-frame-behaviour-override runs +workspaces-associate-frame-fn which
creates a fresh workspace per connection. Setting it to t instead uses set-default-persp which, combined
with persp-set-last-persp-for-new-frames, resumes the last active workspace.
Important: persp-init-frame-behaviour must stay t (Doom’s default). It is checked inside persp-activate
on every workspace switch - setting it to nil prevents persp-restore-window-conf from running, so the
last buffer is never shown when switching workspaces.
(after! persp-mode
(setq persp-emacsclient-init-frame-behaviour-override t persp-init-frame-behaviour t))
(map! :leader
(:when (modulep! :ui workspaces)
(:prefix-map ("l"."workspace") ; Rebind workspaces to SCP-l :desc "Delete this workspace""d"#'+workspace/kill
"."nil :desc "Switch to workspace""l"#'+workspace/switch-to
:desc "Load workspace from file""L"#'+workspace/load
"]"nil :desc "Next workspace""k"#'+workspace/switch-right
"["nil :desc "Previous workspace""j"#'+workspace/switch-left
"`"nil :desc "Cycle last workspace""TAB"#'+workspace/other)))
Buffer navigation
I like cycling between the two last buffers using SPC-Tab.
(map! :leader :desc "Cycle last buffer""TAB"#'evil-switch-to-windows-last-buffer) ; Use SPC-Tab to cycle between two last buffers
Move around buffers using SPC-b [1..9].
The following functions are ported directly from Spacemacs and relies only at winum.
(after! winum
(defun move-buffer-to-window (windownum follow-focus-p)
"Moves a buffer to a window, using the window numbering. follow-focus-p controls
whether focus moves to new window (with buffer), or stays on current." (interactive)
(if (> windownum (length (window-list-1nilnilt)))
(message"No window numbered %s" windownum)
(let ((b (current-buffer))
(w1 (selected-window))
(w2 (winum-get-window-by-number windownum)))
(unless (eq w1 w2)
(set-window-buffer w2 b)
(switch-to-prev-buffer)
(unrecord-window-buffer w1 b))
(when follow-focus-p
(select-window (winum-get-window-by-number windownum))))))
(defun swap-buffers-to-window (windownum follow-focus-p)
"Swaps visible buffers between active window and selected window. follow-focus-p
controls whether focus moves to new window (with buffer), or stays on current." (interactive)
(if (> windownum (length (window-list-1nilnilt)))
(message"No window numbered %s" windownum)
(let* ((b1 (current-buffer))
(w1 (selected-window))
(w2 (winum-get-window-by-number windownum))
(b2 (window-buffer w2)))
(unless (eq w1 w2)
(set-window-buffer w1 b2)
(set-window-buffer w2 b1)
(unrecord-window-buffer w1 b1)
(unrecord-window-buffer w2 b2)))
(when follow-focus-p (winum-select-window-by-number windownum))))
;; define and evaluate three numbered functions;; - buffer-to-window-1 to 9;; - move-buffer-to-window-no-follow-1 to 9;; - swap-buffer-to-window-no-follow-1 to 9 (dotimes (i 9)
(let ((n (+ i 1)))
(eval`(defun ,(intern (format"buffer-to-window-%s" n)) (&optional arg)
,(format"Move buffer to window number %i." n)
(interactive "P")
(if arg
(swap-buffers-to-window ,n t)
(move-buffer-to-window ,n t))))
(eval`(defun ,(intern (format"move-buffer-to-window-no-follow-%s" n)) ()
(interactive)
(move-buffer-to-window ,n nil)))
(eval`(defun ,(intern (format"swap-buffer-window-no-follow-%s" n)) ()
(interactive)
(swap-buffers-to-window ,n nil))))))
Map the newly defined function to SPC-b [1..9] for easy access.
(map! :leader
(:prefix-map ("b"."buffer")
:desc "Move buffer to window 1""1"#'buffer-to-window-1
:desc "Move buffer to window 2""2"#'buffer-to-window-2
:desc "Move buffer to window 3""3"#'buffer-to-window-3
:desc "Move buffer to window 4""4"#'buffer-to-window-4
:desc "Move buffer to window 5""5"#'buffer-to-window-5
:desc "Move buffer to window 6""6"#'buffer-to-window-6
:desc "Move buffer to window 7""7"#'buffer-to-window-7
:desc "Move buffer to window 8""8"#'buffer-to-window-8
:desc "Move buffer to window 9""9"#'buffer-to-window-9))
Copy the file path of the current buffer to clipboard with SPC-b Y.
(defun copy-buffer-filepath-to-clipboard ()
"Copy the filepath of the current buffer to the clipboard." (interactive)
(if-let ((filepath (buffer-file-name)))
(progn
(kill-new filepath)
(message"Copied: %s" filepath))
(message"Buffer is not visiting a file")))
(map! :leader
(:prefix-map ("b"."buffer")
:desc "Copy filepath with line""Y"#'copy-buffer-filepath-point-to-clipboard))
Replace buffer with content from clipboard with SPC-b P.
(defun replace-buffer-from-clipboard ()
"Replace the buffer with content from clipboard." (interactive)
(delete-region (point-min) (point-max))
(clipboard-yank)
(deactivate-mark))
(map! :leader
(:prefix-map ("b"."buffer")
:desc "Paste clipboard to buffer""P"#'replace-buffer-from-clipboard))
Jumping around with Avy
Doom Emacs comes pre-configures with avy and it is pretty reasonable configured out of the box.
However, I never remember how to use it, so I’ll jot down some notes here. Here’s a quick
YouTube video covering some basic usage.
The basics
g s - Opens the prefix menu for doing jump navigation
g s - Jump using evil-avy-goto-char-2 requiring 2 characters before triggering
g s SPC - Jump in closure using evil-avy-goto-char-timer requiring 1 character before triggering
When on macOS, remember to disable the Mission Control shortcut keys as they override the inputs!
Always use C-<left> and C-<right> to move one word left or right.
In this section we generate the init.el and early-init.el files.
Early Init
Emacs 27+ introduces early-init.el, which is run before init.el, before package and UI initialization happens, and before site files are loaded. This is perfect for startup performance optimizations.
;;; early-init.el -*- lexical-binding: t; -*-;; Emacs 27+ introduces early-init.el, which is run before init.el,;; before package and UI initialization happens, and before site files are loaded.;; Defer garbage collection further back in the startup process(setq gc-cons-threshold most-positive-fixnum
gc-cons-percentage 0.6)
;; Temporarily disable file-name-handler-alist for startup performance(defvar doom--initial-file-name-handler-alist file-name-handler-alist)
(setq file-name-handler-alist nil)
;; Prevent the glimpse of un-styled Emacs by disabling these UI elements early(push '(menu-bar-lines .0) default-frame-alist)
(push '(tool-bar-lines .0) default-frame-alist)
(push '(vertical-scroll-bars) default-frame-alist)
;; Resizing the Emacs frame can be a terribly expensive part of changing the;; font. By inhibiting this, we easily halve startup times with fonts that are;; larger than the system default(setq frame-inhibit-implied-resize t)
;; Disable native-comp warnings popup(setq native-comp-async-report-warnings-errors nil)
;; Prevent native-comp from JIT compiling during startup(setq native-comp-deferred-compilation nil native-comp-jit-compilation nil)
;; Re-enable JIT after startup(add-hook 'emacs-startup-hook (lambda ()
(setq native-comp-deferred-compilation t native-comp-jit-compilation t)))
;; Ignore X resources; its settings would be redundant with the other settings;; in this file and can conflict with later config (particularly where the;; cursor color is concerned)(advice-add #'x-apply-session-resources :override #'ignore)
;; Prevent stray instances of package.el from polluting our startup(setq package-enable-at-startup nil)
;; Faster to disable these here (before they've been initialized)(setq tool-bar-mode nil menu-bar-mode nil scroll-bar-mode nil)
;; Increase the amount of data Emacs reads from processes(setq read-process-output-max (*310241024)) ;; 3mb;; Optimize for modern machines with more memory(setq large-file-warning-threshold 100000000) ;; 100MB;; Don't compact font caches during GC(setq inhibit-compacting-font-caches t)
;; Suppress warnings during native compilation(when (boundp'native-comp-eln-load-path)
(setq native-comp-async-report-warnings-errors 'silent))
;; Disable site-start.el from loading(setq site-run-file nil)
;; No need for titlebar on macOS(when (eq system-type 'darwin)
(push '(ns-transparent-titlebar .t) default-frame-alist))
Init File Header
;;; init.el -*- lexical-binding: t; -*-
Sneaky garbage collection
The initial GC threshold is set in early-init.el. Here we configure the garbage collection mode hook (gcmh) to adopt a sneaky garbage collection strategy of waiting until idle time to collect, staving off the collector while working.
Sometimes it’s necessary to fix a bug, or otherwise change stuff in installed local packages.
Always load the newest version of a file.
(setq load-prefer-newer t)
Native Compilation
Configure native compilation for better performance with Emacs 28+.
;; Native compilation settings for performance(when (and (fboundp'native-comp-available-p)
(native-comp-available-p))
;; Compile packages asynchronously after installation (setq package-native-compile t)
;; Silence native-comp warnings (setq native-comp-async-report-warnings-errors 'silent)
;; Set native compilation speed (0-3, higher is faster but uses more resources) (setq native-comp-speed 2)
;; Compile ahead of time for better startup performance (setq native-comp-deferred-compilation t native-comp-jit-compilation t))
File Loading Optimizations
Optimize file loading performance by deferring fontification, reducing syntax highlighting overhead, and lazy-loading modeline updates.
;; Defer jit-lock fontification for smoother file opening(setq jit-lock-defer-time 0.05)
;; Reduce font-lock decoration level (2 = medium, t = maximum)(setq font-lock-maximum-decoration '((t.2)))
;; Disable global emojify-mode (significant CPU overhead during fontification)(after! emojify
(global-emojify-mode -1))
;; Defer modeline updates to idle time instead of immediate on file open(defvar cust/pending-modeline-update nil)
(defun cust/deferred-modeline-update ()
"Run modeline updates after idle time." (when cust/pending-modeline-update
(setq cust/pending-modeline-update nil)
(when (fboundp'doom-modeline-update-buffer-file-name)
(doom-modeline-update-buffer-file-name))
(when (fboundp'doom-modeline-update-buffer-file-icon)
(doom-modeline-update-buffer-file-icon))
(when (fboundp'doom-modeline-update-vcs)
(doom-modeline-update-vcs))))
(defun cust/schedule-modeline-update ()
"Schedule modeline update for idle time." (setq cust/pending-modeline-update t)
(run-with-idle-timer 0.5nil#'cust/deferred-modeline-update))
;; Replace immediate modeline hooks with deferred version(after! doom-modeline
(remove-hook 'find-file-hook#'doom-modeline-update-buffer-file-name)
(remove-hook 'find-file-hook#'doom-modeline-update-buffer-file-icon)
(remove-hook 'find-file-hook#'doom-modeline-update-vcs)
(add-hook 'find-file-hook#'cust/schedule-modeline-update))
Defer undo-fu-session recovery to idle time. The package saves and restores undo history across sessions,
but it loads synchronously on find-file-hook, reading from disk and computing a SHA1 checksum of the buffer.
This is expensive for large files and adds noticeable delay.
(after! undo-fu-session
;; Remove the synchronous hook (remove-hook 'find-file-hook#'undo-fu-session--recover-safe)
(defun +undo-fu-session--recover-in-buffer (buf)
"Recover undo-fu-session in BUF if it's still live." (when (buffer-live-p buf)
(with-current-buffer buf
(undo-fu-session--recover-safe))))
;; Add a deferred version that runs when Emacs is idle (defun +undo-fu-session--recover-deferred ()
"Defer undo-fu-session recovery to idle time for faster file loading." (run-with-idle-timer 0.5nil#'+undo-fu-session--recover-in-buffer (current-buffer)))
(add-hook 'find-file-hook#'+undo-fu-session--recover-deferred))
Doom Env
Add some environmental variables to the doom-env-allow list.
This is required since I like to use gpg-agent over ssh-agent for key management, authentication and signing operations.
In some cases we want to install the latest and greatest version of a package.
Doom allows us to unpin packages using the unpin macro.
(unpin! (:tools lsp magit forge transient))
Structure
literate
(default +bindings +smartparens)
Interface
;;company ; the ultimate code completion backend(corfu ; complete with cap(f), cape and a flying feather! +icons
+dabbrev
+orderless)
;;helm ; the *other* search engine for love and life;;ido ; the other *other* search engine...;;ivy ; a search engine for love and life (vertico ; the search engine of the future +icons)
;;deft ; notational velocity for Emacsdoom ; what makes DOOM look the way it doesdoom-dashboard ; a nifty splash screen for Emacs;;doom-quit ; DOOM quit-message prompts when you quit Emacs(emoji +unicode) ; 🙂hl-todo ; highlight TODO/FIXME/NOTE/DEPRECATED/HACK/REVIEWindent-guides ; highlighted indent columns(ligatures +extra) ; ligatures and symbols to make your code pretty again;;minimap ; show a map of the code on the sidemodeline ; snazzy, Atom-inspired modeline, plus APInav-flash ; blink cursor line after big motions;;neotree ; a project drawer, like NERDTree for vimophints ; highlight the region an operation acts on(popup
+all +defaults) ; tame sudden yet inevitable temporary windows;;smooth-scroll ; smooth scrolling;;tabs ; a tab bar for Emacs(treemacs +lsp) ; a project drawer, like neotree but cooler;;unicode ; extended unicode support for various languages(vc-gutter +pretty) ; vcs diff in the fringevi-tilde-fringe ; fringe tildes to mark beyond EOB(window-select
+numbers) ; visually switch windowsworkspaces ; tab emulation, persistence & separate workspaceszen ; distraction-free coding or writing
(evil +everywhere) ; come to the dark side, we have cookiesfile-templates ; auto-snippets for empty filesfold ; (nigh) universal code folding(format +onsave) ; automated prettiness;;god ; run Emacs commands without modifier keys;;lispy ; vim for lisp, for people who don't like vimmultiple-cursors ; editing in many places at once;;objed ; text object editing for the innocent;;parinfer ; turn lisp into python, sort of;;rotate-text ; cycle region at point between text candidatessnippets ; my elves. They type so I don't have toword-wrap ; soft wrapping with language-aware indent
(dired ; making dired pretty [functional] +icons)
electric ; smarter, keyword-based electric-indenteww ; the internet is gross(ibuffer +icons) ; interactive buffer managementundo ; persistent, smarter undo for your inevitable mistakesvc ; version-control and Emacs, sitting in a tree
;;eshell ; the elisp shell that works everywhere;;shell ; simple shell REPL for Emacs;;term ; basic terminal emulator for Emacsvterm ; the best terminal emulation in Emacs
syntax ; tasing you for every semicolon you forget(spell
+aspell +flyspell) ; tasing you for misspelling mispellinggrammar ; tasing grammar mistake every you make
;;ansible;;biblio ; Writes a PhD for you (citation needed)debugger
direnv
docker
editorconfig ; let someone else argue about tabs vs spaces;;ein ; tame Jupyter notebooks with emacs(eval +overlay) ; run code, run (also, repls);;gist ; interacting with github gistsllm ; language model support(lookup
+dictionary
+docsets) ; navigate your code and its documentation(lsp +peek) ; M-x vscode(magit
+forge) ; a git porcelain for Emacsmake ; run make tasks from Emacs;;pass ; password manager for nerdspdf ; pdf enhancements;;terraform ; infrastructure as codetmux ; an API for interacting with tmuxtree-sitter ; syntax and parsing, sitting in a tree...;;upload ; map local to remote projects via ssh/ftp
(:if (featurep :system 'macos) macos) ; improve compatibility with macOStty ; improve the terminal Emacs experience
Languages
Languages are (usually) not loaded until a file associated with it is opened.
Thus we can be pretty liberal with what we enable because there won’t be much overhead.
;;agda ; types of types of types of types...;;beancount ; mind the GAAP;;(cc +lsp) ; C > C++ == 1;;clojure ; java with a lisp;;common-lisp ; if you've seen one lisp, you've seen them all;;coq ; proofs-as-programs;;crystal ; ruby at the speed of c(csharp
+dotnet
+lsp) ; unity, .NET, and mono shenanigansdata ; config/data formats;;(dart +flutter) ; paint ui and not much else;;dhall(elixir
+lsp
+tree-sitter) ; erlang done right;;elm ; care for a cup of TEA?emacs-lisp ; drown in parentheses(erlang +lsp) ; an elegant language for a more civilized age;;ess ; emacs speaks statistics;;factor;;faust ; dsp, but you get to keep your soul;;fortran ; in FORTRAN, GOD is REAL (unless declared INTEGER);;fsharp ; ML stands for Microsoft's Language;;fstar ; (dependent) types and (monadic) effects and Z3;;gdscript ; the language you waited for(go
+lsp) ; the hipster dialect;;(haskell +lsp) ; a language that's lazier than I am;;hy ; readability of scheme w/ speed of python;;idris ; a language you can depend onjson ; At least it ain't XML;;(java +lsp) ; the poster child for carpal tunnel syndrome(javascript
+lsp) ; all(hope(abandon(ye(who(enter(here))))));;julia ; a better, faster MATLAB;;kotlin ; a better, slicker Java(Script);;latex ; writing papers in Emacs has never been so fun;;lean ; for folks with too much to prove;;ledger ; be audit you can belua ; one-based indices? one-based indices(markdown
+grip) ; writing docs for people to ignore;;nim ; python + lisp at the speed of c;;nix ; I hereby declare "nix geht mehr!";;ocaml ; an objective camel(org ; organize your plain life in plain text +pretty ; yessss my pretties! (nice unicode symbols) +dragndrop ; drag & drop files/images into org buffers +hugo ; use Emacs for hugo blogging +noter ; enhanced PDF notetaking;; +jupyter ; ipython/jupyter support for babel +pandoc ; export-with-pandoc support +gnuplot ; who doesn't like pretty pictures;;+pomodoro ; be fruitful with the tomato technique +present ; using org-mode for presentations +roam) ; wander around notes;;php ; perl's insecure younger brother;;plantuml ; diagrams for confusing people more;;purescript ; javascript, but functional(python ; beautiful is better than ugly +lsp
+cython
+poetry
+pyright)
;;qt ; the 'cutest' gui framework ever;;racket ; a DSL for DSLs;;raku ; the artist formerly known as perl6;;rest ; Emacs as a REST client;;rst ; ReST in peace;;(ruby +rails) ; 1.step {|i| p "Ruby is #{i.even? ? 'love' : 'life'}"}(rust
+lsp) ; Fe2O3.unwrap().unwrap().unwrap().unwrap();;scala ; java, but good;;(scheme +guile) ; a fully conniving family of lisps(sh
+powershell
+lsp) ; she sells {ba,z,fi}sh shells on the C xor;;sml;;solidity ; do you need a blockchain? No.;;swift ; who asked for emoji variables?;;terra ; Earth and Moon in alignment for performance.(web
+lsp) ; the tubes(yaml ; JSON, but readable +lsp-)
;;zig ; C, but simpler
;;calendar;;emms;;everywhere ; *leave* Emacs!? You must be joking;;irc ; how neckbeards socialize;;(rss +org) ; emacs as an RSS reader;;twitter ; twitter client https://twitter.com/vnought
Visual settings
Font Faces
Cursor seems to not always load the correct color. Explicitly set it to whatever themes “blue” color is.
To make Emacs look a bit more modern (at least on macOS) we can enable a “natural title bar”, which makes
the color of the title bar match the color of the buffer.
For this to work, Emacs must be compiled using the --with-natural-title-bar flag.
Configuring transparent titlebar is supposed to be working by the following code,
however I’m unable to make it work by only configuring Emacs.
(when (eq system-type 'darwin)
(add-to-list 'default-frame-alist'(ns-transparent-titlebar .t))
(add-to-list 'default-frame-alist'(ns-appearance . light)) ;; or dark (setq ns-use-proxy-icon nil frame-title-format nil))
So by setting some defaults in macOS, we achieve the desired result.
$ defaults write org.gnu.Emacs HideDocumentIcon YES
$ defaults write org.gnu.Emacs TransparentTitleBar LIGHT # or DARK; doesn't really matter when used with "frame-title-format nil"
Terminal settings
Disable the menu bar when running in terminal mode. The default-frame-alist setting of menu-bar-lines . 0
only applies to GUI frames, so we need an explicit hook for terminal frames.
In terminal frames, ligature.el (used by Doom’s (ligatures +extra) module) has no effect because it relies on HarfBuzz font shaping, which only runs in GUI frames. As a fallback, prettify-symbols-mode substitutes common programming sequences with standard Unicode characters, which any terminal font can render.
(defvar +my/terminal-ligatures
'(;; Arrows ("->".?→)
("->>".?↠)
("=>".?⇒)
("=>>".?⇉)
("<-".?←)
("<->".?↔)
("<=>".?⟺)
;; Pipe ("|>".?▷)
("<|".?◁)
;; Comparison ("!=".?≠)
("!==".?≢)
("==".?≡)
("===".?≣)
(">=".?≥)
;; Logic / math ("&&".?∧)
("||".?∨)
("::".?∷)
("...".?…)
("..".?‥)
;; Functional ("lambda".?λ))
"Prettify-symbols substitutions using standard Unicode for terminal frames.")
;; Only apply prettify-symbols-mode ligatures in terminal frames.;; In GUI frames, ligature.el handles this via HarfBuzz font shaping.(add-hook 'after-make-frame-functions (lambda (frame)
(unless (display-graphic-p frame)
(with-selected-frame frame
(setq-default prettify-symbols-alist
(append +my/terminal-ligatures (default-value'prettify-symbols-alist)))))))
;; Apply for initial frame if it's a terminal(unless (display-graphic-p)
(setq-default prettify-symbols-alist
(append +my/terminal-ligatures (default-value'prettify-symbols-alist))))
Theme and modeline
(package! ef-themes)
I currently use two themes - a light theme for usual work, and a dark theme for late night hacking sessions.
These days I’m using the doom-tomorrow-day light theme, and doom-nord-aurora dark theme. To easily cycle
between them, I keep my favorite themes in a doom-cycle-themes list, and have a small function that just applies
the next theme in the list.
We’ll use the first theme in the list as our default theme.
(defun cust/get-theme-name (theme)
"Returns the name of `theme'.
If `theme' is a list, return the first item in list." (if (listp theme) (car theme) theme))
(setq doom-theme (cust/get-theme-name doom-cycle-themes))
Add some functions to easily cycle through doom-cycle-themes list.
(defun cust/cycle-theme (&optional backward)
"Cycle through themes defined in `doom-cycle-themes'.
When `backward' is non-nil, cycle the list backwards." (interactive "P")
(let* ((theme-names (mapcar#'cust/get-theme-name doom-cycle-themes))
(themes (if backward (reverse theme-names) theme-names))
(next-theme (car (or (cdr (memq doom-theme themes))
;; if current theme isn't in cycleable themes,;; start over themes))))
(when doom-theme
(disable-theme doom-theme))
(let ((progress-reporter
(make-progress-reporter
(format"Loading theme %s... " next-theme))))
(load-theme next-theme tnil)
(progress-reporter-done progress-reporter))))
(defun cust/cycle-theme-backward ()
"Cycle through themes defined in `doom-cycle-themes' backwards." (interactive)
(cust/cycle-theme t))
And finally add some keybindings to easily toggle them.
Add some extra bells and whistles to the Doom modeline.
(setq doom-modeline-icon (display-graphic-p)
doom-modeline-env-version nil;; too noisy doom-modeline-major-mode-icon t doom-modeline-major-mode-color-icon t doom-modeline-buffer-state-icon t)
Also, in Emacs 29.1 we got support for transparent backgrounds. This can be enabled by the following
command if desired.
(set-frame-parameter nil'alpha-background70)
Fonts
I’ll just keep the default config description around for now.
;; Doom exposes five (optional) variables for controlling fonts in Doom:;;;; - `doom-font' -- the primary font to use;; - `doom-variable-pitch-font' -- a non-monospace font (where applicable);; - `doom-big-font' -- used for `doom-big-font-mode'; use this for;; presentations or streaming.;; - `doom-unicode-font' -- for unicode glyphs;; - `doom-serif-font' -- for the `fixed-pitch-serif' face;;;; See 'C-h v doom-font' for documentation and more examples of what they;; accept. For example:;;;;(setq doom-font (font-spec :family "Fira Code" :size 12 :weight 'semi-light);; doom-variable-pitch-font (font-spec :family "Fira Sans" :size 13));;;; If you or Emacs can't find your font, use 'M-x describe-font' to look them;; up, `M-x eval-region' to execute elisp code, and 'M-x doom/reload-font' to;; refresh your font settings. If Emacs still can't find your font, it likely;; wasn't installed correctly. Font issues are rarely Doom issues!
“In addition to these fonts, Merriweather is used with nov.el, and Alegreya as a serifed proportional font used by mixed-pitch-mode for writeroom-mode with Org files.
Because we care about how things look let’s add a check to make sure we’re told if the system doesn’t have any of those fonts.”
Set default line number mode to 'relative, and disable it for certain modes.
(setq display-line-numbers-type 'relative)
Mixed pitch
From the :ui zen module.
We’d like to use mixed pitch in certain modes. If we simply add a hook, when directly opening a file with (a new) Emacs mixed-pitch-mode runs
before UI initialisation, which is problematic. To resolve this, we create a hook that runs after UI initialization and both:
conditionally enables mixed-pitch-mode
sets up the mixed pitch hooks
(defvar mixed-pitch-modes '(org-mode LaTeX-mode markdown-mode gfm-mode Info-mode)
"Modes that `mixed-pitch-mode' should be enabled in, but only after UI initialisation.")
(defun init-mixed-pitch-h ()
"Hook `mixed-pitch-mode' into each mode in `mixed-pitch-modes'.
Also immediately enables `mixed-pitch-modes' if currently in one of the modes." (when (memq major-mode mixed-pitch-modes)
(mixed-pitch-mode 1))
(dolist (hook mixed-pitch-modes)
(add-hook (intern (concat (symbol-name hook) "-hook")) #'mixed-pitch-mode)))
(add-hook 'doom-init-ui-hook#'init-mixed-pitch-h)
As mixed pitch uses the variable mixed-pitch-face, we can create a new function to apply mixed pitch with a serif face instead of the default.
This was created for writeroom mode.
(autoload#'mixed-pitch-serif-mode "mixed-pitch""Change the default face of the current buffer to a serifed variable pitch, while keeping some faces fixed pitch."t)
(after! mixed-pitch
(defface variable-pitch-serif
'((t (:family "serif")))
"A variable-pitch face with serifs." :group 'basic-faces)
(setq mixed-pitch-set-height t)
(setq variable-pitch-serif-font (font-spec :family "Alegreya" :size 18))
(set-face-attribute 'variable-pitch-serifnil :font variable-pitch-serif-font)
(defun mixed-pitch-serif-mode (&optional arg)
"Change the default face of the current buffer to a serifed variable pitch, while keeping some faces fixed pitch." (interactive)
(let ((mixed-pitch-face 'variable-pitch-serif))
(mixed-pitch-mode (or arg 'toggle)))))
Now, as Harfbuzz is currently used in Emacs, we’ll be missing out on the following Alegreya ligatures:
ff ff ffi ffi ffj ffj ffl ffl
fft fft fi fi fj fj ft ft
Th Th
Thankfully, it isn’t to hard to add these to the composition-function-table.
Next up, we want to keep a balanced layout of split windows based on the golden ratio.
Zoom does a pretty good job.
NOTE: I have issues with this package. It screws up the which-key buffer and some others.
The default-text-scale package works by adjusting the size of the default face,
so that it affects all buffers at once.
(package! default-text-scale)
Enable default-text-scale-mode global minor mode and add some extra keybindings for macOS. I think
it’s easier to just use CMD-+/-/0 to increase, decrease and reset.
These little guys are helpful to remove duplicates in a region or buffer.
(defun uniquify-region-lines (beg end)
"Remove duplicate adjacent lines in region." (interactive "*r")
(save-excursion
(goto-char beg)
(while (re-search-forward"^\\(.*\n\\)\\1+" end t)
(replace-match"\\1"))))
(defun uniquify-buffer-lines ()
"Remove duplicate adjacent lines in the current buffer." (interactive)
(uniquify-region-lines (point-min) (point-max)))
Other things
Splash screen
This beauty is also shamelessly ripped off from tecosaur’s Emacs config!
Make it theme-appropriate, and resize with the frame.
(defvar fancy-splash-image-template
(expand-file-name"misc/splash-images/emacs-e-template.svg" doom-private-dir)
"Default template svg used for the splash image, with substitutions from ")
(defvar fancy-splash-sizes
`((:height 300 :min-height 50 :padding (0.2))
(:height 250 :min-height 42 :padding (2.4))
(:height 200 :min-height 35 :padding (3.3))
(:height 150 :min-height 28 :padding (3.3))
(:height 100 :min-height 20 :padding (2.2))
(:height 75 :min-height 15 :padding (2.1))
(:height 50 :min-height 10 :padding (1.0))
(:height 1 :min-height 0 :padding (0.0)))
"list of plists with the following properties
:height the height of the image
:min-height minimum `frame-height' for image
:padding `+doom-dashboard-banner-padding' (top . bottom) to apply
:template non-default template file
:file file to use instead of template")
(defvar fancy-splash-template-colours
'(("$colour1". keywords) ("$colour2". type) ("$colour3". base5) ("$colour4". base8))
"list of colour-replacement alists of the form (\"$placeholder\" . 'theme-colour) which applied the template")
(unless (file-exists-p (expand-file-name"theme-splashes" doom-cache-dir))
(make-directory (expand-file-name"theme-splashes" doom-cache-dir) t))
(defun fancy-splash-filename (theme-name height)
(expand-file-name (concat (file-name-as-directory"theme-splashes")
theme-name
"-" (number-to-string height) ".svg")
doom-cache-dir))
(defun fancy-splash-clear-cache ()
"Delete all cached fancy splash images" (interactive)
(delete-directory (expand-file-name"theme-splashes" doom-cache-dir) t)
(message"Cache cleared!"))
(defun fancy-splash-generate-image (template height)
"Read TEMPLATE and create an image if HEIGHT with colour substitutions as
described by `fancy-splash-template-colours' for the current theme" (with-temp-buffer
(insert-file-contents template)
(re-search-forward"$height"nilt)
(replace-match (number-to-string height) nilnil)
(dolist (substitution fancy-splash-template-colours)
(goto-char (point-min))
(while (re-search-forward (car substitution) nilt)
(replace-match (doom-color (cdr substitution)) nilnil)))
(write-regionnilnil (fancy-splash-filename (symbol-name doom-theme) height) nilnil)))
(defun fancy-splash-generate-images ()
"Perform `fancy-splash-generate-image' in bulk" (dolist (size fancy-splash-sizes)
(unless (plist-get size :file)
(fancy-splash-generate-image (or (plist-get size :template)
fancy-splash-image-template)
(plist-get size :height)))))
(defun ensure-theme-splash-images-exist (&optional height)
(unless (file-exists-p (fancy-splash-filename
(symbol-name doom-theme)
(or height
(plist-get (car fancy-splash-sizes) :height))))
(fancy-splash-generate-images)))
(defun get-appropriate-splash ()
(let ((height (frame-height)))
(cl-some (lambda (size) (when (>= height (plist-get size :min-height)) size))
fancy-splash-sizes)))
(setq fancy-splash-last-size nil)
(setq fancy-splash-last-theme nil)
(defun set-appropriate-splash (&rest _)
(let ((appropriate-image (get-appropriate-splash)))
(unless (and (equal appropriate-image fancy-splash-last-size)
(equal doom-theme fancy-splash-last-theme)))
(unless (plist-get appropriate-image :file)
(ensure-theme-splash-images-exist (plist-get appropriate-image :height)))
(setq fancy-splash-image
(or (plist-get appropriate-image :file)
(fancy-splash-filename (symbol-name doom-theme) (plist-get appropriate-image :height))))
(setq +doom-dashboard-banner-padding (plist-get appropriate-image :padding))
(setq fancy-splash-last-size appropriate-image)
(setq fancy-splash-last-theme doom-theme)
(+doom-dashboard-reload)))
(add-hook 'window-size-change-functions#'set-appropriate-splash)
(add-hook 'doom-load-theme-hook#'set-appropriate-splash)
Now the only thing missing is a an extra interesting line, whether that be some
corporate BS, an developer excuse, or a fun (useless) fact.
The following is rather long, but it essentially
fetches a phrase from an API
inserts it into the dashboard (asynchronously)
moves point to the phrase
re-uses the last phrase for requests within a few seconds of it being fetched
(defvar splash-phrase-source-folder
(expand-file-name"misc/splash-phrases" doom-private-dir)
"A folder of text files with a fun phrase on each line.")
(defvar splash-phrase-sources
(let* ((files (directory-files splash-phrase-source-folder nil"\\.txt\\'"))
(sets (delete-dups (mapcar (lambda (file)
(replace-regexp-in-string "\\(?:-[0-9]+-\\w+\\)?\\.txt""" file))
files))))
(mapcar (lambda (sset)
(cons sset
(delqnil (mapcar (lambda (file)
(when (string-match-p (regexp-quote sset) file)
file))
files))))
sets))
"A list of cons giving the phrase set name, and a list of files which contain phrase components.")
(defvar splash-phrase-set
(nth (random (length splash-phrase-sources)) (mapcar#'car splash-phrase-sources))
"The default phrase set. See `splash-phrase-sources'.")
(defun splash-phrase-set-random-set ()
"Set a new random splash phrase set." (interactive)
(setq splash-phrase-set
(nth (random (1- (length splash-phrase-sources)))
(cl-set-difference (mapcar#'car splash-phrase-sources) (list splash-phrase-set))))
(+doom-dashboard-reload t))
(defvar splash-phrase--cache nil)
(defun splash-phrase-get-from-file (file)
"Fetch a random line from FILE." (let ((lines (or (cdr (assoc file splash-phrase--cache))
(cdar (push (cons file
(with-temp-buffer
(insert-file-contents (expand-file-name file splash-phrase-source-folder))
(split-string (string-trim (buffer-string)) "\n")))
splash-phrase--cache)))))
(nth (random (length lines)) lines)))
(defun splash-phrase (&optionalset)
"Construct a splash phrase from SET. See `splash-phrase-sources'." (mapconcat#'splash-phrase-get-from-file
(cdr (assoc (or set splash-phrase-set) splash-phrase-sources))
" "))
(defun doom-dashboard-phrase ()
"Get a splash phrase, flow it over multiple lines as needed, and make fontify it." (mapconcat (lambda (line)
(+doom-dashboard--center
+doom-dashboard--width
(with-temp-buffer
(insert-text-button
line
'action (lambda (_) (+doom-dashboard-reload t))
'face'doom-dashboard-menu-title'mouse-face'doom-dashboard-menu-title'help-echo"Random phrase"'follow-linkt)
(buffer-string))))
(split-string
(with-temp-buffer
(insert (splash-phrase))
(setq fill-column (min70 (/ (*2 (window-width)) 3)))
(fill-region (point-min) (point-max))
(buffer-string))
"\n")
"\n"))
(defadvice! doom-dashboard-widget-loaded-with-phrase ()
:override #'doom-dashboard-widget-loaded
(setq line-spacing 0.2)
(insert"\n\n" (propertize (+doom-dashboard--center
+doom-dashboard--width
(doom-display-benchmark-h 'return))
'face'doom-dashboard-loaded)
"\n" (doom-dashboard-phrase)
"\n"))
Lastly, the doom dashboard “useful commands” are no longer useful to me.
So, we’ll disable them and then for a particularly clean look disable
the modeline and hl-line-mode, then also hide the cursor.
At the end, we have a minimal but rather nice splash screen.
I haven’t forgotten about the ASCII banner though! Once again we’re going for
something simple.
(defun doom-dashboard-draw-ascii-emacs-banner-fn ()
(let* ((banner
'(",---.,-.-.,---.,---.,---.""|---'| | |,---|| `---.""`---'` ' '`---^`---'`---'"))
(longest-line (apply#'max (mapcar#'length banner))))
(put-text-property (point)
(dolist (line banner (point))
(insert (+doom-dashboard--center
+doom-dashboard--width
(concat line (make-string (max0 (- longest-line (length line)))
32)))
"\n"))
'face'doom-dashboard-banner)))
(unless (display-graphic-p) ; for some reason this messes up the graphical splash screen atm (setq +doom-dashboard-ascii-banner-fn #'doom-dashboard-draw-ascii-emacs-banner-fn))
Utility functions
Here are just a collection of utility functions I use.
add-list-to-list
Sometimes it’s handy to merge a list into another.
(defun add-list-to-list (list-var elements &optionalappend compare-fn)
"Add ELEMENTS to the value of LIST-VAR in order
Behaves like `add-to-list', but accepts a list of new ELEMENTS to add." (interactive)
(setq elements (if append elements (reverse elements)))
(let* ((val (symbol-value list-var))
(lst (if append (reverse val) val)))
(dolist (elt elements)
(cl-pushnew elt lst :test compare-fn))
(set list-var (if append (nreverse lst) lst)))
(symbol-value list-var))
align-whitespace
This little gem can align a block of text by whitespace columns, which makes it easy to align text so it
looks a bit prettier.
(defun align-whitespace (start end)
"Align columns by whitespace" (interactive "r")
(align-regexp start end
"\\(\\s-*\\)\\s-"10t))
copy-buffer-filepath-point-to-clipboard
This is a small function to copy the current buffer and point location to the clipboard.
Supports visual selection ranges in the format: filepath:line or filepath:startLine-endLine
(defun copy-buffer-filepath-point-to-clipboard ()
"Copy the current buffer's filepath with line or line range to clipboard.
Format: filepath:line or filepath:startLine-endLine (if region is active)" (interactive)
(if-let ((filepath (buffer-file-name)))
(let* ((start-line (line-number-at-pos (if (region-active-p)
(region-beginning)
(point))))
(end-line (line-number-at-pos (if (region-active-p)
(region-end)
(point))))
(filepath-with-point (if (= start-line end-line)
(format"%s:%d" filepath start-line)
(format"%s:%d-%d" filepath start-line end-line))))
(kill-new filepath-with-point)
(message"Copied: %s" filepath-with-point))
(message"Buffer is not visiting a file")))
reload-buffer
By default, auto-revert-mode will not reload a file if you have unsaved changes in the buffer. To override this (for example discard unsaved changes
and reload the file from disk), we can use revert-buffer interactively.
(defun reload-buffer-no-confirm ()
"Revert buffer without confirmation." (interactive)
(revert-buffer :ignore-auto :noconfirm))
;; Bind the above function to a key, e.g., F5(global-set-key (kbd "<f5>") #'reload-buffer-no-confirm)
sort-words
alphabetically handy It’s sometimes sort to words.
(defun sort-words (reverse start end)
"Sort words in region alphabetically, in REVERSE if negative.
Prefixed with negative \\[universal-argument], sorts in reverse.
The variable `sort-fold-case' determines whether alphabetic case
affects the sort order.
See `sort-regexp-fields'.
https://www.emacswiki.org/emacs/SortWords" (interactive "*P\nr")
(sort-regexp-fields reverse"\\w+""\\&" start end))
sort-symbols
(as be deserved sorted symbols to well)
(defun sort-symbols (reverse start end)
"Sort symbols in region alphabetically, in REVERSE if negative.
See `sort-words'." (interactive "*P\nr")
(sort-regexp-fields reverse"\\(\\sw\\|\\s_\\)+""\\&" start end))
delete-carrage-returns
Some files (looking at you, dotnet generated projects) create files using DOS-style end of line characters (CRLF).
I always want to use unix-style end of line characters (LF).
This is where to install packages.
By declaring packages using the package! macro in packages.el, then running doom refresh from the command line
(or M-x doom/refresh).
It is also possible to install packages from any git repository. If we for example want to install a package from a gist,
we could do it by specifying the receipe like this.
If we have local packages in the .elisp/packages/ folder in our doom-private-dir, we can install them like this:
;; To install a local package, use the :local-repo property.;; The path is relative to doom-private-dir (i.e., ~/.doom.d/);;;; Example for a package in elisp/packages/my-package/:;; (package! my-package :recipe (:local-repo "elisp/packages/my-package"));;;; For packages with multiple files or specific file patterns:;; (package! my-package :recipe (:local-repo "elisp/packages/my-package" :files ("*.el")));;;; For packages that also have build steps or additional files:;; (package! my-package :recipe (:local-repo "elisp/packages/my-package" :files ("*.el" "resources/*")))
As an example, if you have a package called my-cool-package with its files in
~/.doom.d/elisp/packages/my-cool-package/my-cool-package.el, you would declare it as:
In order to disable a built-in package (for whatever reason), we can use the :disable property.
(package! built-in-package-name :disable t)
We can also override built-in packages without having to specify all :recipe properties. These will
inherit the rest from Doom or MELPA/ELPA/emacsmirror.
(use-package! claude-code-ide
:defer t :commands (claude-code-ide-menu claude-code-ide-emacs-tools-setup)
:init
(map! :leader
:desc "+Claude Code""C"#'claude-code-ide-menu)
:config
(claude-code-ide-emacs-tools-setup)
(setq claude-code-ide-terminal-backend 'vterm claude-code-ide-vterm-render-delay 0.001 claude-code-ide-enable-mcp-server t claude-code-ide-no-flicker t claude-code-ide-vterm-anti-flicker t claude-code-ide-enable-mcp-server nil))
Minuet - AI Code Completion
Minuet provides inline code completions using any LLM backend (similar to GitHub Copilot).
It syncs its provider configuration from gptel to avoid duplicate API key management.
'claude-api-key - Anthropic API key (console.anthropic.com)
;; Choose which gptel backend to use(defvar cust/gptel-backend-type 'copilot"Which gptel backend to use.
Set to `copilot' for GitHub Copilot.
Set to `claude-foundry' for Azure Foundry API (work).
Set to `claude-api-key' for Anthropic API key (console.anthropic.com).")
;; Azure Foundry configuration;; Add to ~/.authinfo.gpg:;; machine dadp-openai-us2-resource.openai.azure.com login apikey password YOUR_API_KEY(defvar cust/claude-foundry-host "dadp-openai-us2-resource.openai.azure.com")
(defun cust/claude-foundry-api-key ()
"Retrieve Claude API key from auth-source for Azure Foundry." (auth-source-pick-first-password :host cust/claude-foundry-host :user "apikey"))
;; Anthropic API key configuration (console.anthropic.com);; Add to ~/.authinfo.gpg:;; machine api.anthropic.com login apikey password YOUR_API_KEY(defvar cust/claude-api-host "api.anthropic.com")
(defun cust/claude-api-key ()
"Retrieve Claude API key from auth-source for Anthropic API." (auth-source-pick-first-password :host cust/claude-api-host :user "apikey"))
;; Configure gptel backend based on cust/gptel-backend-type(pcase cust/gptel-backend-type
('copilot;; GitHub Copilot - requires M-x copilot-login first (setq gptel-backend (gptel-make-gh-copilot "Copilot")
gptel-model 'claude-sonnet-4.5))
('claude-foundry;; Azure Foundry uses the Anthropic Messages API format;; Requires x-api-key header and anthropic-version header (setq gptel-backend (gptel-make-anthropic "Azure-Claude" :host (concat cust/claude-foundry-host "/anthropic")
:endpoint "/v1/messages" :stream t :key #'cust/claude-foundry-api-key
:header (lambda ()
(list (cons"x-api-key" (cust/claude-foundry-api-key))
(cons"anthropic-version""2023-06-01")))
:models '(claude-sonnet-4-5 claude-opus-4-5 claude-haiku-4-5))
gptel-model 'claude-sonnet-4-5))
('claude-api-key;; Standard Anthropic API (console.anthropic.com) (setq gptel-backend (gptel-make-anthropic "Claude" :stream t :key #'cust/claude-api-key
:models '(claude-sonnet-4-5 claude-opus-4-5 claude-haiku-4-5))
gptel-model 'claude-sonnet-4-5)))
Cancel any pending gptel commit message generation when navigating commit history with M-p / M-n.
(defvar cust/gptel-commit-cancelled nil"Non-nil when gptel commit generation was cancelled.")
(defvar cust/gptel-magit-saved-callback nil"Stored callback for gptel-magit cancellation handling.")
(defun cust/gptel-abort-before-commit-nav (&rest _)
"Abort any pending gptel request before navigating commit history." (setq cust/gptel-commit-cancelled t)
(when (fboundp'gptel-abort)
(ignore-errors (gptel-abort))))
(defun cust/gptel-magit-callback-wrapper (message)
"Callback wrapper that checks cancellation flag." (if cust/gptel-commit-cancelled
(message"gptel commit message cancelled")
(when cust/gptel-magit-saved-callback
(funcall cust/gptel-magit-saved-callback message))))
(defun cust/gptel-magit-generate-wrapper (orig-fn cb)
"Wrap gptel-magit--generate to check cancellation flag.";; Clear cancelled flag when starting new request (setq cust/gptel-commit-cancelled nil)
(setq cust/gptel-magit-saved-callback cb)
(funcall orig-fn #'cust/gptel-magit-callback-wrapper))
(after! git-commit
(advice-add 'git-commit-prev-message :before #'cust/gptel-abort-before-commit-nav)
(advice-add 'git-commit-next-message :before #'cust/gptel-abort-before-commit-nav))
(after! gptel-magit
(advice-add 'gptel-magit--generate :around #'cust/gptel-magit-generate-wrapper)
;; Customize the commit prompt to prevent markdown formatting (setq gptel-magit-commit-prompt
(string-join
(list gptel-magit-prompt-conventional-commits
"""IMPORTANT:""- Commit message MUST follow Conventional Commits specification, with release-please compatible conventions for releases.""- Return ONLY the raw commit message text""- The summary should never exceed 80 characters, unless absolutely necessary for clarity""- If including a body, ALWAYS separate it from the summary with a blank line""- Do NOT wrap the output in markdown code blocks, backticks, or any other formatting""- NEVER add triple backticks (```) before or after the commit message!")
"\n")))
Agent Shell
Agent Shell provides a native Emacs user interface for interacting with AI agents over Agent Client Protocol (ACP).
Custom keybindings for agent-shell buffers. We override some default behaviors
to better integrate with Evil mode and general Emacs workflows.
;; Multi-line input: M-<return> inserts a newline instead of submitting(map! :map shell-maker-mode-map
:i "M-<return>"#'newline
:n "M-<return>"#'newline)
(map! :map agent-shell-mode-map
;; C-<tab> cycles session mode (plan/code/etc) - overrides aya-expand :i "C-<tab>"#'agent-shell-cycle-session-mode
:n "C-<tab>"#'agent-shell-cycle-session-mode
;; C-g interrupts without confirmation prompt :i "C-g" (cmd! (agent-shell-interrupt t))
:n "C-g" (cmd! (agent-shell-interrupt t))
;; Disable arrow keys for history (use M-p/M-n instead) :i "<up>"nil :i "<down>"nil;; TAB activates/toggles expandable items (like RET does) :n "TAB"#'cust/agent-shell--activate-item-at-point
:n "<tab>"#'cust/agent-shell--activate-item-at-point
;; C-c C-v pastes image from clipboard (requires pngpaste) :i "C-c C-v"#'cust/agent-shell--send-clipboard-image
:n "C-c C-v"#'cust/agent-shell--send-clipboard-image
;; C-n/C-p navigates between items in normal mode :n "C-n"#'agent-shell-next-item
:n "C-p"#'agent-shell-previous-item)
Custom commands
Helper functions for features not provided by agent-shell out of the box.
TAB to activate items
agent-shell makes certain items (expandable sections, buttons) interactive via
text properties. This function finds and invokes the RET binding at point,
allowing TAB to toggle/expand items just like pressing RET.
(defun cust/agent-shell--activate-item-at-point ()
"Activate the item at point by invoking its RET binding." (interactive)
(let ((fn nil)
(pos (point)))
;; Check point and a few chars ahead (for icons like ▶/▼) (while (and (not fn) (<= pos (+ (point) 3)))
(when-let ((km (get-text-property pos 'keymap)))
(setq fn (lookup-key km (kbd "RET"))))
(setq pos (1+ pos)))
(when fn (funcall fn))))
Paste image from clipboard
Insert an image from the system clipboard into the prompt. The image is saved
to .agent-shell/screenshots/ in the project root, and the file path is
inserted at point. Requires pngpaste (install via brew install pngpaste).
(defun cust/agent-shell--send-clipboard-image ()
"Paste image from clipboard and insert it into `agent-shell'." (interactive)
(let* ((project-root (or (projectile-project-root) default-directory))
(screenshots-dir (expand-file-name".agent-shell/screenshots" project-root))
(timestamp (format-time-string"%Y%m%d_%H%M%S"))
(filename (expand-file-name (format"clipboard_%s.png" timestamp) screenshots-dir)))
(make-directory screenshots-dir t)
(if (zerop (call-process"pngpaste"nilnilnil filename))
(progn
(goto-char (point-max))
(insert filename)
(message"Inserted clipboard image: %s" filename))
(user-error"No image in clipboard (or pngpaste not installed)"))))
Navigation behavior fix
I use C-n=/=C-p in Evil normal mode to navigate between items. This advice
ensures navigation always works, even when the cursor is at the prompt.
Claude Code supports different “thinking” levels that allocate more tokens for
complex reasoning. These keywords are highlighted with rainbow colors to make
them visually distinct when typing prompts.
ultrathink (~32k tokens): “ultrathink”, “think harder”, “think intensely”, etc.
megathink (~10k tokens): “megathink”, “think deeply”, “think hard”, etc.
Improvements to @ file references and / slash command completion:
/ commands only trigger at the start of the prompt (they’re commands, not mid-sentence)
@ file references can appear anywhere (for referencing files mid-sentence)
Pre-populate common slash commands so they work before the agent handshake completes
;; Pre-populate core Claude Code slash commands for immediate completion(defvar cust/agent-shell--default-commands-claude
'[((name ."compact") (description ."Clear conversation history but keep a summary in context"))
((name ."init") (description ."Initialize a new CLAUDE.md file with codebase documentation"))
((name ."resume") (description ."Resume a previous conversation"))
((name ."review") (description ."Review a pull request"))
((name ."pr-comments") (description ."Get comments from a GitHub pull request"))
((name ."security-review") (description ."Complete a security review of pending changes"))]
"Core Claude Code slash commands for immediate completion.")
(defun cust/agent-shell--prepopulate-commands-advice (result)
"Pre-populate slash commands for Claude Code sessions." (when (and (eq'claude-code (map-elt (map-elt result :agent-config) :identifier))
(null (map-elt result :available-commands)))
(map-put! result :available-commands cust/agent-shell--default-commands-claude))
result)
(advice-add 'agent-shell--make-state :filter-return #'cust/agent-shell--prepopulate-commands-advice)
(defun cust/agent-shell--at-input-start-p (trigger-pos)
"Return non-nil if TRIGGER-POS is at the start of user input." (let ((input-start (comint-line-beginning-position)))
(save-excursion
(goto-char trigger-pos)
(skip-chars-backward" \t")
(<= (point) input-start))))
(defun cust/agent-shell--file-completion-at-point-advice (orig-fn)
"Allow @ file completion anywhere in the prompt." (when-let* ((at-pos (save-excursion
(skip-chars-backward"[:alnum:]/_.-")
(when (eq (char-before) ?@)
(1- (point)))))
(start (1+ at-pos))
(end (point))
(files (agent-shell--project-files)))
(list start end files
:exclusive 'no :exit-function (lambda (_string _status) (insert" ")))))
(defun cust/agent-shell--command-completion-at-point-advice (orig-fn)
"Only complete / commands at prompt start." (when-let* ((slash-pos (save-excursion
(skip-chars-backward"[:alnum:]_-")
(when (eq (char-before) ?/)
(1- (point)))))
(at-start (cust/agent-shell--at-input-start-p slash-pos))
(start (1+ slash-pos))
(end (point))
(cmds (map-elt agent-shell--state :available-commands))
(cmd-names (mapcar (lambda (cmd) (map-elt cmd 'name)) cmds)))
(list start end cmd-names
:exclusive t :exit-function (lambda (_string _status) (insert" ")))))
(advice-add 'agent-shell--file-completion-at-point :around
#'cust/agent-shell--file-completion-at-point-advice)
(advice-add 'agent-shell--command-completion-at-point :around
#'cust/agent-shell--command-completion-at-point-advice)
Resume previous conversations
The /resume slash command allows resuming previous Claude Code conversations.
Conversations are stored in ~/.claude/projects/<encoded-project-path>/ as JSONL
files. Each file contains summary entries with conversation titles.
This implementation provides:
Resume conversations from the current project (default)
Resume conversations from all projects (press A in the selection buffer)
Show conversation summaries with timestamps for easy identification
(defvar cust/agent-shell-claude-projects-dir
(expand-file-name"projects" (expand-file-name".claude""~"))
"Directory where Claude Code stores conversation files.")
(defun cust/agent-shell--encode-project-path (path)
"Encode PATH to Claude's project directory format.
Claude encodes paths by replacing both / and . with -.
Trailing slashes are removed first to match Claude Code's behavior." (let ((clean-path (directory-file-name path))) ; Remove trailing slash (replace-regexp-in-string "[/.]""-" clean-path)))
(defun cust/agent-shell--get-project-dir-for-path (path)
"Find the Claude project directory that matches PATH.
Returns the directory name or nil if not found." (let ((encoded (cust/agent-shell--encode-project-path path))
(dirs (directory-files cust/agent-shell-claude-projects-dir nil"^-")))
;; Try exact match first (or (cl-find encoded dirs :test #'string=)
;; Fallback: find a dir that could match (handle trailing slash variations) (cl-find-if (lambda (dir)
(or (string= dir encoded)
(string= dir (concat encoded "-"))
(string-prefix-p (concat encoded "-") dir)))
dirs))))
(defun cust/agent-shell--extract-project-name (dir-name)
"Extract a human-readable project name from DIR-NAME.
Attempts to show a meaningful directory name by looking for patterns
like 'workspace-X' or dotfiles like '--dirname'." (cond
;; Pattern: -Users-xxx-workspace-projectname -> projectname ((string-match"-workspace-\\(.+\\)$" dir-name)
(match-string 1 dir-name))
;; Pattern: -Users-xxx--dotdir (dotfiles like .doom.d) -> .dotdir ((string-match"--\\([^-]+\\)\\(-[^-]+\\)?$" dir-name)
(concat"." (match-string 1 dir-name)
(when (match-string 2 dir-name)
(match-string 2 dir-name))))
;; Fallback: use last segment ((string-match"-\\([^-]+\\)$" dir-name)
(match-string 1 dir-name))
(t dir-name)))
(defun cust/agent-shell--parse-conversation-file (file)
"Parse a conversation JSONL FILE and return conversation metadata.
Returns a plist with :id, :summary, :timestamp, :message-count, :first-message, :git-branch, :cwd, and :file." (let ((summaries nil)
(latest-timestamp nil)
(message-count 0)
(first-user-message nil)
(git-branch nil)
(cwd nil)
(session-id (file-name-sans-extension (file-name-nondirectory file))))
(with-temp-buffer
(insert-file-contents file)
(goto-char (point-min))
(while (not (eobp))
(let* ((line (buffer-substring-no-properties (line-beginning-position) (line-end-position)))
(json (ignore-errors (json-parse-string line :object-type 'alist))))
(when json
(let ((type (alist-get 'type json))
(message (alist-get 'message json)))
;; Extract cwd from first entry that has it (unless cwd
(when-let ((dir (alist-get 'cwd json)))
(setq cwd dir)))
;; Extract git branch from first entry that has it (unless git-branch
(when-let ((branch (alist-get 'gitBranch json)))
(setq git-branch branch)))
(cond
;; Collect summaries ((string= type "summary")
(push (alist-get 'summary json) summaries))
;; Count and capture first user message (skip meta/system messages) ((and message (string= (alist-get 'rolemessage) "user")
(not (eq (alist-get 'isMeta json) t)))
(cl-incf message-count)
(unless first-user-message
(let* ((content (alist-get 'contentmessage))
(text (cond
((stringp content) content)
((vectorp content)
(cl-loop for item across content
when (and (listp item)
(string= (alist-get 'type item) "text"))
return (alist-get 'text item)))
(tnil))))
;; Skip system-like messages (when (and text
(not (string-prefix-p "Unknown skill:" text))
(not (string-prefix-p "<local-command" text))
(not (string-match-p "^/[a-z]" text)))
(setq first-user-message text)))))
;; Count assistant messages ((and message (string= (alist-get 'rolemessage) "assistant"))
(cl-incf message-count)))
;; Track latest timestamp (when-let ((ts (alist-get 'timestamp json)))
(when (or (null latest-timestamp)
(string> ts latest-timestamp))
(setq latest-timestamp ts))))))
(forward-line1)))
;; Return metadata even without summaries (when (or summaries (> message-count 0))
(list :id session-id
:summary (car (last summaries))
:summaries (nreverse summaries)
:timestamp latest-timestamp
:message-count message-count
:first-message first-user-message
:git-branch git-branch
:cwd cwd
:file file))))
(defun cust/agent-shell--extract-conversation-messages (file)
"Extract user/assistant messages from conversation JSONL FILE.
Returns a list of message plists with :role and :content.
Messages are returned in chronological order, suitable for replay." (let ((messages nil))
(with-temp-buffer
(insert-file-contents file)
(goto-char (point-min))
(while (not (eobp))
(let* ((line (buffer-substring-no-properties (line-beginning-position) (line-end-position)))
(json (ignore-errors (json-parse-string line :object-type 'alist))))
(when json
(let ((type (alist-get 'type json))
(message (alist-get 'message json))
(is-meta (alist-get 'isMeta json))
(is-sidechain (alist-get 'isSidechain json)))
;; Only process user/assistant messages, skip meta and sidechain;; Note: JSON false becomes :false symbol (truthy!), true becomes t (when (and message (not (eq is-meta t))
(not (eq is-sidechain t))
(member type '("user""assistant")))
(let* ((role (alist-get 'rolemessage))
(content (alist-get 'contentmessage))
;; Extract text from content array (text (cond
((stringp content) content)
((vectorp content)
(mapconcat (lambda (item)
(when (and (listp item)
(string= (alist-get 'type item) "text"))
(alist-get 'text item)))
content ""))
(tnil))))
;; Skip empty messages and tool results (when (and text (not (string-empty-p text)))
(push (list :role role :content text) messages)))))))
(forward-line1)))
;; Return in chronological order (nreverse messages)))
(defun cust/agent-shell--format-history-for-context (messages &optional max-messages)
"Format MESSAGES list into a context string for Claude.
MAX-MESSAGES limits how many recent messages to include (default 20)." (let* ((max-msgs (or max-messages 20))
(recent-msgs (seq-take (reverse messages) max-msgs))
(msgs-to-format (reverse recent-msgs)))
(mapconcat (lambda (msg)
(let ((role (plist-get msg :role))
(content (plist-get msg :content)))
(format"[%s]: %s" (if (string= role "user") "User""Assistant")
;; Truncate very long messages (if (> (length content) 500)
(concat (substring content 0497) "...")
content))))
msgs-to-format
"\n\n")))
(defun cust/agent-shell--get-session-file (session-id)
"Get the JSONL file path for SESSION-ID in the current project." (let* ((project-dir (cust/agent-shell--get-project-dir-for-path
(directory-file-name (or (projectile-project-root)
default-directory))))
(session-file (when project-dir
(expand-file-name (concat session-id ".jsonl")
(expand-file-name project-dir
cust/agent-shell-claude-projects-dir)))))
(when (and session-file (file-exists-p session-file))
session-file)))
(defun cust/agent-shell--list-conversations (&optional project-path)
"List all conversations, optionally filtered to PROJECT-PATH.
Returns a list of conversation metadata plists sorted by timestamp (newest first)." (let ((conversations nil)
(target-dir (when project-path
(cust/agent-shell--get-project-dir-for-path
(directory-file-name project-path))))
(all-dirs (directory-files cust/agent-shell-claude-projects-dir nil"^-")))
;; Determine which directories to scan (let ((dirs (if target-dir
(list target-dir)
all-dirs)))
(dolist (dir-name dirs)
(let ((dir (expand-file-name dir-name cust/agent-shell-claude-projects-dir)))
(when (file-directory-p dir)
(dolist (file (directory-files dir t"\\.jsonl$"))
(when-let ((meta (cust/agent-shell--parse-conversation-file file)))
;; Add project info - use directory name for display (setq meta (plist-put meta :project-dir dir-name))
(setq meta (plist-put meta :project-name
(cust/agent-shell--extract-project-name dir-name)))
(push meta conversations)))))))
;; Sort by timestamp, newest first (sort conversations
(lambda (a b)
(let ((ts-a (or (plist-get a :timestamp) ""))
(ts-b (or (plist-get b :timestamp) "")))
(string> ts-a ts-b))))))
(defun cust/agent-shell--format-timestamp (iso-timestamp &optional include-date)
"Format ISO-TIMESTAMP to a human-readable string.
If INCLUDE-DATE is non-nil, include the date alongside relative time." (if (null iso-timestamp)
"unknown" (let* ((time (date-to-time (replace-regexp-in-string "T"" " (replace-regexp-in-string "\\.[0-9]+Z$""" iso-timestamp))))
(diff (float-time (time-subtract (current-time) time)))
(date-str (format-time-string"%Y-%m-%d %H:%M" time))
(relative (cond
((< diff 60) "just now")
((< diff 3600) (format"%d min ago" (/ diff 60)))
((< diff 86400) (format"%d hours ago" (/ diff 3600)))
((< diff 604800) (format"%d days ago" (/ diff 86400)))
(tnil))))
(if include-date
(if relative
(format"%s (%s)" date-str relative)
date-str)
(or relative date-str)))))
(defun cust/agent-shell--resume-conversation (session-id &optional cwd session-file)
"Resume a Claude Code conversation with SESSION-ID.
CWD is the working directory for the session.
SESSION-FILE is the path to the conversation JSONL file.";; Start a new agent-shell with the resume session ID (cust/agent-shell-with-resume session-id cwd session-file))
(defun cust/acp-make-session-resume-request (session-id cwd mcp-servers)
"Create an ACP session/resume request to resume an existing session.
SESSION-ID is the ID of the session to resume.
CWD is the working directory.
MCP-SERVERS is a list of MCP server configurations.
Note: session/resume is an unstable ACP method that continues a conversation
without replaying history. Claude Code advertises 'resume' capability, not 'load'." (list (cons'method"session/resume")
(cons'params (list (cons'sessionId session-id)
(cons'cwd cwd)
(cons'mcpServers (or mcp-servers []))))))
(defun cust/agent-shell--send-history-context (session-file buffer)
"Load conversation history from SESSION-FILE and send as context prompt.
BUFFER is the agent-shell buffer to send the prompt in." (when (and session-file (file-exists-p session-file))
(let* ((messages (cust/agent-shell--extract-conversation-messages session-file))
(history-text (when messages
(cust/agent-shell--format-history-for-context messages 30))))
(when (and history-text (not (string-empty-p history-text)))
;; Send the history as a context-setting prompt (let ((context-prompt (format"I'm resuming our previous conversation. Here's the context from our last session:
<previous-conversation>
%s
</previous-conversation>
Please acknowledge that you have this context and are ready to continue. You don't need to summarize it - just confirm you're ready." history-text))
(target-buffer buffer))
;; Use run-at-time to let the UI settle first (run-at-time 0.5nil (lambda ()
(when (buffer-live-p target-buffer)
(with-current-buffer target-buffer
(agent-shell--send-command
:prompt context-prompt
:shell (agent-shell--state)))))))))))
(defun cust/agent-shell--initiate-session-with-resume (shell on-session-init resume-session-id)
"Initiate ACP session resumption with SHELL, resuming RESUME-SESSION-ID.
Uses the ACP session/resume method to continue the conversation.
Must provide ON-SESSION-INIT (lambda ())." (unless on-session-init
(error"Missing required argument: :on-session-init"))
(unless resume-session-id
(error"Missing required argument: resume-session-id"))
;; Capture the session file from pending state (set by cust/agent-shell-with-resume) (let ((session-file cust/agent-shell--pending-resume-session-file))
;; Clear the pending file now that we've captured it (setq cust/agent-shell--pending-resume-session-file nil)
(with-current-buffer (map-elt (agent-shell--state) :buffer)
(agent-shell--update-fragment
:state (agent-shell--state)
:block-id "starting" :body (format"\n\nResuming session %s..." (substring resume-session-id 08))
:append t))
(acp-send-request
:client (map-elt (agent-shell--state) :client)
:request (cust/acp-make-session-resume-request
resume-session-id
(agent-shell--resolve-path (agent-shell-cwd))
(agent-shell--mcp-servers))
:buffer (current-buffer)
:on-success (lambda (response)
;; Store session info (map-put! agent-shell--state
:session (list (cons :id resume-session-id)
(cons :mode-id (map-nested-elt response '(modes currentModeId)))
(cons :modes (mapcar (lambda (mode)
`((:id .,(map-elt mode 'id))
(:name .,(map-elt mode 'name))
(:description .,(map-elt mode 'description))))
(map-nested-elt response '(modes availableModes))))
(cons :model-id (map-nested-elt response '(models currentModelId)))
(cons :models (mapcar (lambda (model)
`((:model-id .,(map-elt model 'modelId))
(:name .,(map-elt model 'name))
(:description .,(map-elt model 'description))))
(map-nested-elt response '(models availableModels))))))
(agent-shell--update-fragment
:state agent-shell--state
:block-id "starting" :label-left (format"%s %s" (agent-shell--status-label "completed")
(propertize"Resumed session"'font-lock-face'font-lock-doc-markup-face))
:body (if session-file
"\n\nLoading conversation history...""\n\nReady (no history file found)")
:append t)
(agent-shell--update-header-and-mode-line)
;; Call the session init callback (funcall on-session-init)
;; Now send the conversation history as context (if we have a file) (when session-file
(cust/agent-shell--send-history-context
session-file
(current-buffer))))
:on-error (lambda (error)
(agent-shell--update-fragment
:state agent-shell--state
:block-id "starting" :label-left (format"%s %s" (agent-shell--status-label "failed")
(propertize"Session resume"'font-lock-face'font-lock-doc-markup-face))
:body (format"\n\nError: %s" (or (map-elt error'message) error))
:append t)))))
(defvar cust/agent-shell--pending-resume-session-id nil"Session ID to resume when initiating the next session.
This is a global variable used during the brief window between
starting agent-shell and session initialization.")
(defvar cust/agent-shell--pending-resume-session-file nil"Session file path for the pending resume.
Set alongside the session ID, cleared after use.")
(defun cust/agent-shell-with-resume (session-id &optional cwd session-file)
"Start agent-shell and resume SESSION-ID.
CWD is the working directory (defaults to current project or default-directory).
SESSION-FILE is the path to the conversation JSONL file for history replay." (interactive "sSession ID to resume: ")
(let* ((target-dir (or cwd
(projectile-project-root)
default-directory))
(default-directory target-dir))
;; Set the resume session ID and file BEFORE starting agent-shell (setq cust/agent-shell--pending-resume-session-id session-id)
(setq cust/agent-shell--pending-resume-session-file session-file)
;; Start agent-shell in the target directory (agent-shell)
(message"Resuming session %s in %s" session-id target-dir)))
;; Advice to intercept session initiation and inject resume parameter(defun cust/agent-shell--initiate-session-advice (orig-fn &rest args)
"Advice to inject resume session ID into session initiation." (if cust/agent-shell--pending-resume-session-id
(let ((resume-id cust/agent-shell--pending-resume-session-id)
;; Extract keyword args - args is (:shell val :on-session-init val) (shell (plist-get args :shell))
(on-session-init (plist-get args :on-session-init)))
;; Clear it so it's only used once (setq cust/agent-shell--pending-resume-session-id nil)
;; Call our custom initiate with resume (cust/agent-shell--initiate-session-with-resume
shell
on-session-init
resume-id))
;; Normal flow (apply orig-fn args)))
(advice-add 'agent-shell--initiate-session :around #'cust/agent-shell--initiate-session-advice)
(defun cust/agent-shell-resume (&optional all-projects)
"Interactively select and resume a previous Claude Code conversation.
With prefix argument ALL-PROJECTS or when called with non-nil argument,
show conversations from all projects. Otherwise show only conversations
from the current project." (interactive "P")
(let* ((project-path (unless all-projects
(or (projectile-project-root)
default-directory)))
(conversations (cust/agent-shell--list-conversations project-path)))
(if (null conversations)
(if all-projects
(user-error"No conversations found in ~/.claude/projects/")
(if (y-or-n-p "No conversations for current project. Show all projects? ")
(cust/agent-shell-resume t)
(user-error"No conversations found")))
;; Build candidates for completing-read (let* ((summary-width 45)
(msgs-width 6)
(branch-width 15)
(candidates
(mapcar (lambda (conv)
(let* ((summary (plist-get conv :summary))
(first-msg (plist-get conv :first-message))
(raw-text (or summary
(when first-msg
(string-trim
(replace-regexp-in-string "[\n\r]+"" " first-msg)))
"(empty)"))
;; Truncate/pad summary to fixed width (display-text (if (> (length raw-text) summary-width)
(concat (substring raw-text 0 (- summary-width 3)) "...")
(format (format"%%-%ds" summary-width) raw-text)))
(msg-count (or (plist-get conv :message-count) 0))
(branch (or (plist-get conv :git-branch) "-"))
(branch-text (if (> (length branch) branch-width)
(concat (substring branch 0 (- branch-width 2)) "..")
(format (format"%%-%ds" branch-width) branch)))
(time (cust/agent-shell--format-timestamp
(plist-get conv :timestamp) nil))
(project-name (plist-get conv :project-name))
(id (plist-get conv :id))
(cwd (plist-get conv :cwd))
;; Format with colors (formatted
(concat display-text
" " (propertize (format"%5d" msg-count) 'face'font-lock-number-face)
" " (propertize branch-text 'face'font-lock-constant-face)
" " (propertize time 'face'font-lock-comment-face)
(when all-projects
(concat" " (propertize (format"[%s]" project-name)
'face'font-lock-comment-face))))))
;; Store id, cwd, and file path (cons formatted (list :id id :cwd cwd :file (plist-get conv :file)))))
conversations))
;; Disable vertico sorting to preserve our timestamp order (vertico-sort-function nil)
(vertico-sort-override-function nil)
(selection (completing-read (if all-projects
"Resume conversation (all projects): ""Resume conversation: ")
candidates nilt))
(selected (cdr (assoc selection candidates)))
(session-id (plist-get selected :id))
(session-cwd (plist-get selected :cwd))
(session-file (plist-get selected :file)))
(when session-id
(cust/agent-shell--resume-conversation session-id session-cwd session-file))))))
(defun cust/agent-shell-resume-all ()
"Resume a conversation from any project." (interactive)
(cust/agent-shell-resume t))
;; Keybinding for quick access(map! :leader
(:prefix-map ("o"."open")
:desc "Resume Claude conversation""R"#'cust/agent-shell-resume))
Conversation persistence (Claude Code compatible)
This section implements bidirectional conversation sharing between agent-shell
and Claude Code CLI. Conversations from agent-shell are written in Claude’s
JSONL format, allowing them to be resumed from the terminal and vice versa.
Session state tracking
Track conversation state needed for Claude Code format: UUIDs, timestamps,
parent chains, etc.
(defvar-local cust/agent-shell--claude-session nil"Claude Code compatible session state for the current buffer.
Contains: session-id, parent-uuid, message-count, project-dir, jsonl-file.")
(defvar cust/agent-shell--claude-version "2.1.7""Version string to use in Claude Code JSONL entries.
This should match Claude Code CLI version for compatibility.")
(defun cust/agent-shell--init-claude-session ()
"Initialize Claude Code compatible session tracking for current buffer.
Called lazily when first message is submitted." (when-let* (((derived-mode-p 'agent-shell-mode))
((boundp'agent-shell--state))
(agent-shell--state)
((eq'claude-code (map-elt (map-elt agent-shell--state :agent-config) :identifier)))
(session-id (map-nested-elt agent-shell--state '(:session :id)))
;; Use default-directory instead of agent-shell-cwd to avoid shell-maker dependency (cwd (expand-file-name default-directory))
(project-dir-name (cust/agent-shell--encode-project-path cwd))
(project-dir (expand-file-name project-dir-name cust/agent-shell-claude-projects-dir))
(jsonl-file (expand-file-name (concat session-id ".jsonl") project-dir)))
;; Create project directory if needed (make-directory project-dir t)
;; Initialize session state (setq cust/agent-shell--claude-session
(list :session-id session-id
:parent-uuid nil :message-count 0 :cwd cwd
:project-dir project-dir
:jsonl-file jsonl-file
:git-branch (cust/agent-shell--get-git-branch cwd)))
;; Write initial queue-operation entry (let* ((timestamp (cust/agent-shell--iso-timestamp))
(entry (list (cons'type"queue-operation")
(cons'operation"dequeue")
(cons'timestamp timestamp)
(cons'sessionId session-id))))
(cust/agent-shell--write-jsonl-entry entry))
(message"Claude session: %s" (file-name-nondirectory jsonl-file))))
(defun cust/agent-shell--get-git-branch (dir)
"Get current git branch for DIR, or nil if not in a git repo." (let ((default-directory dir))
(when (file-directory-p (expand-file-name".git" dir))
(string-trim
(shell-command-to-string "git rev-parse --abbrev-ref HEAD 2>/dev/null")))))
(defun cust/agent-shell--iso-timestamp ()
"Return current time as ISO 8601 timestamp with milliseconds." (let ((time (current-time)))
(format"%s.%03dZ" (format-time-string"%Y-%m-%dT%H:%M:%S" time t)
(/ (nth2 time) 1000))))
(defun cust/agent-shell--generate-uuid ()
"Generate a UUID v4 string." (format"%08x-%04x-%04x-%04x-%012x" (random (expt168))
(random (expt164))
(logior (ash412) (random (expt163))) ; Version 4 (logior (ash214) (random (expt164))) ; Variant 1 (random (expt1612))))
JSONL writing
Write conversation entries in Claude Code’s JSONL format.
Generate and prepend conversation summaries to the JSONL file.
Claude Code stores summaries at the beginning of the file.
(defun cust/agent-shell--generate-summary (text)
"Generate a short summary from TEXT (first user message or significant content).
Returns a string suitable for the summary field." (let* ((clean-text (replace-regexp-in-string "[\n\r]+"" " text))
(truncated (if (> (length clean-text) 60)
(concat (substring clean-text 057) "...")
clean-text)))
truncated))
(defun cust/agent-shell--write-summary (summary-text)
"Write a summary entry to the beginning of the JSONL file.
SUMMARY-TEXT is the conversation summary to add." (when-let* ((session cust/agent-shell--claude-session)
(jsonl-file (plist-get session :jsonl-file))
(leaf-uuid (plist-get session :parent-uuid)))
(when (file-exists-p jsonl-file)
(let* ((summary-entry `((type ."summary")
(summary .,summary-text)
(leafUuid .,leaf-uuid)))
(summary-json (concat (json-encode summary-entry) "\n"))
(existing-content (with-temp-buffer
(insert-file-contents jsonl-file)
(buffer-string))))
;; Prepend summary to file (with-temp-file jsonl-file
(insert summary-json)
(insert existing-content))))))
(defun cust/agent-shell--update-summary-on-idle ()
"Update conversation summary after idle time.
This runs periodically to keep the summary current." (when-let* ((session cust/agent-shell--claude-session)
(jsonl-file (plist-get session :jsonl-file))
((> (plist-get session :message-count) 0)))
;; Read first user message for summary if we don't have one yet (unless (plist-get session :summary-written)
(when-let ((first-msg (cust/agent-shell--get-first-user-message jsonl-file)))
(cust/agent-shell--write-summary
(cust/agent-shell--generate-summary first-msg))
(plist-put cust/agent-shell--claude-session :summary-written t)))))
(defun cust/agent-shell--get-first-user-message (jsonl-file)
"Get the first user message text from JSONL-FILE." (when (file-exists-p jsonl-file)
(with-temp-buffer
(insert-file-contents jsonl-file)
(goto-char (point-min))
(catch 'found (while (not (eobp))
(let* ((line (buffer-substring-no-properties (line-beginning-position) (line-end-position)))
(json (ignore-errors (json-parse-string line :object-type 'alist))))
(when (and json
(string= (alist-get 'type json) "user")
(alist-get 'message json))
(let* ((message (alist-get 'message json))
(content (alist-get 'contentmessage)))
(when (and content (> (length content) 0))
(throw 'found (alist-get 'text (aref content 0)))))))
(forward-line1))
nil))))
Hooks and integration
Hook into agent-shell to capture messages and write them in Claude format.
(defvar cust/agent-shell--pending-assistant-text """Buffer for accumulating assistant message chunks.")
(defun cust/agent-shell--ensure-session ()
"Ensure Claude session is initialized, initializing lazily if needed.
Returns non-nil if session is ready." (or cust/agent-shell--claude-session
(when (and (derived-mode-p 'agent-shell-mode)
(boundp'agent-shell--state)
agent-shell--state
(map-nested-elt agent-shell--state '(:session :id))
(eq'claude-code (map-elt (map-elt agent-shell--state :agent-config) :identifier)))
(cust/agent-shell--init-claude-session)
cust/agent-shell--claude-session)))
(defun cust/agent-shell--capture-user-input (input)
"Capture user INPUT and write to Claude JSONL.
This is called via advice on shell-maker-submit." (when (and (derived-mode-p 'agent-shell-mode)
(stringp input)
(not (string-empty-p (string-trim input)))
(cust/agent-shell--ensure-session))
(cust/agent-shell--write-user-message (string-trim input))))
(defun cust/agent-shell--capture-assistant-chunk (text)
"Accumulate assistant TEXT chunks for later writing." (when cust/agent-shell--claude-session
(setq cust/agent-shell--pending-assistant-text
(concat cust/agent-shell--pending-assistant-text text))))
(defun cust/agent-shell--flush-assistant-message ()
"Write accumulated assistant message to JSONL and reset buffer." (when (and cust/agent-shell--claude-session
(not (string-empty-p cust/agent-shell--pending-assistant-text)))
(cust/agent-shell--write-assistant-message
cust/agent-shell--pending-assistant-text)
(setq cust/agent-shell--pending-assistant-text "")))
;; Advice to capture user input before submission(defun cust/agent-shell--submit-advice (orig-fn &rest args)
"Advice for shell-maker-submit to capture user input." (when (derived-mode-p 'agent-shell-mode)
(let ((input (string-trim
(buffer-substring-no-properties (save-excursion
(goto-char (point-max))
(comint-line-beginning-position))
(point-max)))))
(unless (string-empty-p input)
(cust/agent-shell--capture-user-input input))))
(apply orig-fn args))
(advice-add 'shell-maker-submit :around #'cust/agent-shell--submit-advice)
;; No timers or mode hooks needed - session is initialized lazily;; on first message via cust/agent-shell--ensure-session below.
Message capture via transcript advice
Hook into agent-shell’s existing transcript system to capture messages.
(defun cust/agent-shell--transcript-advice (orig-fn &rest args)
"Advice for agent-shell--append-transcript to also write Claude JSONL.
Intercepts transcript writes to extract message content.";; Call original function (apply orig-fn args)
;; Extract text from args and determine message type (when cust/agent-shell--claude-session
(let ((text (plist-get args :text)))
(when (stringp text)
(cond
;; Agent message header - flush any pending and prepare for new ((string-match"^## Agent" text)
(cust/agent-shell--flush-assistant-message))
;; User message header - already captured via submit advice ((string-match"^## User" text)
nil)
;; Actual content (not headers) ((and (not (string-match"^## " text))
(not (string-match"^### Tool Call" text)))
;; This is message content, accumulate for assistant (cust/agent-shell--capture-assistant-chunk text)))))))
(advice-add 'agent-shell--append-transcript :around #'cust/agent-shell--transcript-advice)
;; Flush assistant message when command finishes(defun cust/agent-shell--on-command-finished ()
"Called when a command/response cycle completes." (when cust/agent-shell--claude-session
(cust/agent-shell--flush-assistant-message)
(cust/agent-shell--update-summary-on-idle)))
;; Hook into shell-maker's on-command-finished if available;; Note: shell-maker--config may be nil during early initialization,;; so we check both boundp AND non-nil. If nil, we skip - the transcript;; advice will still capture messages via agent-shell--append-transcript.(add-hook 'agent-shell-mode-hook (lambda ()
(when (and (boundp'shell-maker--config) shell-maker--config)
(let ((orig-fn (shell-maker-config-on-command-finished shell-maker--config)))
(setf (shell-maker-config-on-command-finished shell-maker--config)
(lambda (input output success)
(when orig-fn (funcall orig-fn input output success))
(cust/agent-shell--on-command-finished)))))))
IBuffer
Projectile integration
By default, ibuffer-projectile only groups file-visiting buffers by project.
This advice extends it to include non-file buffers (like agent-shell, vterm,
compilation, etc.) based on their default-directory.
(defun cust/ibuffer-projectile-root-include-non-file-buffers (orig-fn buf)
"Advice to include non-file buffers in projectile groups.
Falls back to `default-directory' when `buffer-file-name' is nil." (or (funcall orig-fn buf)
(with-current-buffer buf
(when-let ((root (ignore-errors (projectile-project-root))))
(cons (projectile-project-name) root)))))
(advice-add 'ibuffer-projectile-root :around #'cust/ibuffer-projectile-root-include-non-file-buffers)
Casual Transient Menus
Casual provides discoverable transient menus for ibuffer operations
including filtering, sorting, and marking.
(package! casual)
(defun cust/ibuffer-special-buffer-p (buf)
"Return non-nil if BUF name starts with *." (string-prefix-p "*" (buffer-name buf)))
(defvar cust/ibuffer-hide-special-buffers nil"When non-nil, hide buffers starting with *.")
(defun cust/ibuffer-toggle-special-buffers ()
"Toggle visibility of special buffers (those starting with *)." (interactive)
(setq cust/ibuffer-hide-special-buffers (not cust/ibuffer-hide-special-buffers))
(if cust/ibuffer-hide-special-buffers
(progn
(add-to-list 'ibuffer-never-show-predicates#'cust/ibuffer-special-buffer-p)
(message"Hiding special buffers"))
(setq ibuffer-never-show-predicates
(remove #'cust/ibuffer-special-buffer-p ibuffer-never-show-predicates))
(message"Showing all buffers"))
(ibuffer-update nilt))
(use-package! casual
:after ibuffer
:config
(map! :map ibuffer-mode-map
:n "?"#'casual-ibuffer-tmenu
:n "H"#'cust/ibuffer-toggle-special-buffers
:n "F"#'casual-ibuffer-filter-tmenu
:n "s"#'casual-ibuffer-sortby-tmenu
:n "p"#'ibuffer-backwards-next-marked
:n "n"#'ibuffer-forward-next-marked
:n "C-k"#'ibuffer-backward-filter-group
:n "C-j"#'ibuffer-forward-filter-group
:n "$"#'ibuffer-toggle-filter-group)
;; Update transient menu keybindings to match our ibuffer-mode-map (with-eval-after-load 'casual-ibuffer (transient-suffix-put 'casual-ibuffer-tmenu"p" :key "k") ; Move default p (prev line) to k (transient-suffix-put 'casual-ibuffer-tmenu"n" :key "j") ; Move default n (next line) to j (transient-suffix-put 'casual-ibuffer-tmenu"{" :key "p") ; Previous marked → p (transient-suffix-put 'casual-ibuffer-tmenu"}" :key "n") ; Next marked → n (transient-suffix-put 'casual-ibuffer-tmenu"[" :key "C-k") ; Previous group → C-k (transient-suffix-put 'casual-ibuffer-tmenu"]" :key "C-j")) ; Next group → C-j (add-hook 'ibuffer-mode-hook#'hl-line-mode)
(add-hook 'ibuffer-mode-hook#'ibuffer-auto-mode))
Startup Profiling and Optimizations
Benchmark startup time to identify bottlenecks.
Testing Startup Performance:
Run doom sync to apply all configuration changes
Start Emacs and run M-x benchmark-init/show-durations-tree to see startup timings
Check overall startup time with M-x emacs-init-time
For more detailed analysis, start Emacs with emacs --debug-init
To profile specific functions: M-x profiler-start, restart Emacs, then M-x profiler-report
(package! benchmark-init)
(use-package! benchmark-init
:demand t :config
;; To disable collection after init (add-hook 'doom-first-input-hook#'benchmark-init/deactivate))
;; Report startup time(add-hook 'emacs-startup-hook (lambda ()
(message"Emacs loaded in %s with %d garbage collections." (format"%.2f seconds" (float-time (time-subtract after-init-time before-init-time)))
gcs-done)))
Consult
From the :completion vertico module
Since we’re using Marginalia, the separation between buffers and files is already clear,
and there’s no need to use a different face.
(after! consult
(set-face-attribute 'consult-filenil :inherit 'consult-buffer)
(setf (plist-get (alist-get 'perl consult-async-split-styles-alist) :initial) ";")
;; Jump to an outline (map! :leader
(:prefix-map ("s"."search")
:desc "Jump to outline""J"#'consult-outline)))
Corfu
From the :completion corfu module
(after! corfu
(setq corfu-quit-no-match t) ;; Quit immediately when no match (map! :map corfu-map
"SPC"#'corfu-insert-separator ;; Enables multiple orderless patterns;; Unbind C-n/C-p to free them for other modes (use C-j/C-k instead)"C-n"nil"C-p"nil))
Corfu uses child frames for its popup, which do not work in terminal Emacs. corfu-terminal replaces the popup with overlays so completion works correctly in emacsclient -nw sessions.
The dired-recent package provides us with is a convenient way to visit previously visited directories.
(package! dired-recent) ;; convenient package for visiting frequent folders(package! dired-open) ;; open files in correct applications(package! dired-hide-dotfiles) ;; hide or show those pesky .dotfiles
Add some extra configuration options for the dired file manager.
The dired-open can help us making sure that various files are opened in the correct program. For example,
opening a video file in Emacs is probably not going to be a pleasant experience, and would be better to open
in for example Quicktime or, VLC.
On Linux (or XDG enabled environments), the dired-open package has a concept of “auto-detecting” which program that should be used to open certain files. I’m mostly using macOS, which does not support XDG very well.
So, we’ll try to write a the dired-open-macos function to use the native open program instead.
;; FIXME - Need to make this a bit smarter..;; I want to open most files in Emacs, and this lets;; macOS decide a bit too much.;; (use-package! dired-open;; :config;; (add-to-list 'dired-open-functions #'dired-open-macos t);; (setq dired-open-extensions '(("svg" . "qlmanage -p"))));; (eval-after-load "dired-open";; (when (eq system-type 'darwin);; '(defun dired-open-macos ();; "Try to run `open' to open the file under point as long as the `file' is a regular file,;; and file extension does not exists in the `dired-open-functions' alist.";; (interactive);; (if (executable-find "open");; (let ((file (ignore-errors (dired-get-file-for-visit))));; (if (and (f-file-p file) (not (member (file-name-extension file) dired-open-extensions)));; (start-process "dired-open" nil;; "open" (file-truename file)) nil)) nil))))
Especially when visiting my $HOME directory, it’s littered with all sorts of dot files. Let’s add a convenient
way to show or hide them.
For tree-sitter based modes, we can use the treesit-fold package instead.
(package! treesit-fold)
Make folding work from anywhere within a foldable construct, not just on the exact folding marker:
;; TODO AI: We need to work more on this.;; (after! treesit-fold;; ;; Make folding work from anywhere within a foldable construct;; (defun treesit-fold--find-foldable-node-at-point ();; "Find a foldable node at or around point.";; (let ((node (treesit-node-at (point)));; (foldable-types (mapcar #'car (alist-get major-mode treesit-fold-range-alist))));; ;; First check if current node is already foldable;; (if (member (treesit-node-type node) foldable-types);; node;; ;; Otherwise, look for foldable nodes in the ancestry and their children;; (let ((current node));; (while current;; ;; Check if current node has foldable children;; (let ((foldable-child (seq-find;; (lambda (child);; (member (treesit-node-type child) foldable-types));; (treesit-node-children current nil))));; (when foldable-child;; (cl-return foldable-child)));; (setq current (treesit-node-parent current)));; nil))));; ;; Override the default node finding behavior;; (advice-add 'treesit-fold-close :around;; (lambda (orig-fun);; (let ((node (treesit-fold--find-foldable-node-at-point)));; (if node;; (let ((pos (treesit-node-start node)));; (save-excursion;; (goto-char pos);; (funcall orig-fun)));; (funcall orig-fun)))));; (advice-add 'treesit-fold-open :around;; (lambda (orig-fun);; (let ((node (treesit-fold--find-foldable-node-at-point)));; (if node;; (let ((pos (treesit-node-start node)));; (save-excursion;; (goto-char pos);; (funcall orig-fun)));; (funcall orig-fun))))))
Formatting
From the :editor format module
Doom Emacs now uses aphelieia as the default formatting system.
Override to use the latest version from Github.
An unobtrusive way to trim spaces from end of lines.
(package! ws-butler)
Just
Add support for the justfiles.
(package! just-mode)
Language tool
From the :checkers grammar module
This seems pretty neat, so I’ll experiment a bit with it.
Some issues I’d like to see resolved though:
Don’t check org src blocks
Dont check org headers and properties
Look into running the https server to avvoid JVM spinup every time I check grammars
Check grammar at point - now I need to run langtool-correct-buffer and chose from there,
would be nice to just correct what’s at point.
Installation
Requires installation of languagetool which can easily be installed with homebrew on macOS.
$ brew install languagetool
Configuration
Next, we just need to point at the languagetool-commandline.jar file. Easily found somewhere in
the $HOMEBREW_PREFIX directory. Should probably have a better way to point at this though.
(after! magit
(defvar pretty-magit--alist nil"An alist of regexes, an icon, and face properties to apply to icon.")
(defvar pretty-magit--prompt nil"A list of commit leader prompt candidates.")
(defvar pretty-magit--use-commit-prompt? nil"Do we need to use the magit commit prompt?")
(defun pretty-magit--add-magit-faces (&rest _)
"Add face properties and compose symbols for buffer from pretty-magit." (interactive)
(with-silent-modifications
(-each pretty-magit--alist
(lambda (input0 &optional _index)
(let* ((--dash-source-0-- input0)
(rgx (car-safe (prog1 --dash-source-0-- (setq --dash-source-0-- (cdr --dash-source-0--)))))
(char (car-safe (prog1 --dash-source-0-- (setq --dash-source-0-- (cdr --dash-source-0--)))))
(face-props (car --dash-source-0--)))
(save-excursion
(goto-char (point-min))
(while (re-search-forward rgx nilt)
(let* ((--dash-source-1-- (match-data)))
(when (>= (length --dash-source-1--) 2)
(let ((start (nth0 --dash-source-1--))
(end (nth1 --dash-source-1--)))
(when (and start end)
(compose-region start end char)
(when face-props
(add-face-text-property start end face-props)))))))))))))
(defun pretty-magit-add-leader (word char face-props)
"Replace sanitized WORD with CHAR having FACE-PROPS and add to prompts." (add-to-list 'pretty-magit--alist (list (rx-to-string `(: bow
(group ,word ":")))
char face-props))
(add-to-list 'pretty-magit--prompt (concat word ": ")))
(defun pretty-magit-add-leaders (leaders)
"Map `pretty-magit-add-leader' over LEADERS." (-each leaders
(-applify #'pretty-magit-add-leader)))
(defun pretty-magit--use-commit-prompt (&rest args)
(setq pretty-magit--use-commit-prompt? t))
(defun pretty-magit-commit-prompt ()
"Magit prompt and insert commit header with faces." (interactive)
(when (and pretty-magit--use-commit-prompt?
pretty-magit--prompt)
(setq pretty-magit--use-commit-prompt? nil)
(insert (completing-read"Commit Type " pretty-magit--prompt nil'confirm))
(pretty-magit--add-magit-faces)
(evil-insert 1)))
(defun pretty-magit-setup (&optional no-commit-prompts?)
"Advise the appropriate magit funcs to add pretty-magit faces." (advice-add 'magit-status :after 'pretty-magit--add-magit-faces)
(advice-add 'magit-refresh-buffer :after 'pretty-magit--add-magit-faces)
(unless no-commit-prompts?
(remove-hook 'git-commit-setup-hook'with-editor-usage-message)
(add-hook 'git-commit-setup-hook'pretty-magit-commit-prompt)
(add-hook 'git-commit-setup-hook'gptel-magit-generate-message)
(advice-add 'magit-commit-create :after 'pretty-magit--use-commit-prompt)
)))
(after! magit
;; I'm testing out `gptel' to write automatic commit messages, so this is currently disabled.;; (pretty-magit-add-leaders '(("feat" ? (:foreground "#C2C8CD" :height 1.2));; ("add" ? (:foreground "#375E97" :height 1.2));; ("fix" ? (:foreground "#FB6542" :height 1.2));; ("clean" ? (:foreground "#FFBB00" :height 1.2));; ("chore" ? (:foreground "#CE98FF" :height 1.2));; ("docs" ? (:foreground "#3F681C" :height 1.2)))) (pretty-magit-setup))
Run vc-refresh-state() for all buffers in Magit’s post-refresh-hook.
(after! magit
(defun cust/vc-refresh-all-buffers-state ()
"Update version control state in all buffers" (dolist (buf (buffer-list))
(with-current-buffer buf
(vc-refresh-state))))
(add-hook 'magit-post-refresh-hook#'cust/vc-refresh-all-buffers-state))
When copying commit hashes I almost always just want the short version. This
is controlled by the magit-copy-revision-abbreviated variable. The latest commit hash
can be copied from a magit buffer using M-w.
(after! magit
(setq git-commit-summary-max-length 80;; Increase commit summary length git-commit-post-finish-hook-timeout 2;; Wait longer for GPG/YubiKey PIN entry magit-copy-revision-abbreviated t;; Copy short version of hashes magit-list-refs-sortby "-committerdate") ;; Sort by last commited date (latest on top);; Always suggest .worktrees directory for new worktrees (setq magit-worktree-read-directory-name-function
(lambda (prompt)
(let* ((default-dir (expand-file-name".worktrees" (magit-toplevel))))
(unless (file-exists-p default-dir)
(make-directory default-dir t))
(read-directory-name prompt default-dir)))))
Render ANSI escape codes (colors, icons, etc.) in the *magit-process* buffer.
This is useful when git hooks output colored text with Unicode characters.
Some tools output broken ANSI sequences where the ESC character (\e) is
stripped, leaving just [37m instead of \e[37m. We advise the magit process
filter to strip these broken sequences in real-time as output arrives.
(after! magit
(defun my/magit-process-filter-handle-ansi (fn proc string)
"Process ANSI sequences in magit process output.
Applies ansi-color to render valid sequences and strips broken ones.";; First strip broken sequences (missing ESC character) (setq string (replace-regexp-in-string "\\[\\([0-9;]*\\)m"""string))
;; Then apply ansi-color to handle valid sequences (setq string (ansi-color-apply string))
(funcall fn proc string))
(advice-add 'magit-process-filter :around #'my/magit-process-filter-handle-ansi))
Branch Cleanup
Interactive command to bulk-delete local branches that are merged or whose
upstream tracking branch is gone. Accessible from the branch transient via D.
(after! magit
;; --- Helper functions --- (defvar cust/magit-cleanup--protected-branches '("main""master""trunk")
"Branch names that should never appear as cleanup candidates.")
(defun cust/magit-cleanup--merged-branches (base)
"Return list of local branches merged into BASE.
Excludes BASE itself, the current branch, and protected branches." (let* ((current (magit-get-current-branch))
(output (magit-git-lines "branch""--merged" base))
(branches
(cl-loop for line in output
for branch = (string-trim line)
;; Strip leading "* " (current) or "+ " (worktree) markers for name = (cond
((string-prefix-p "* " branch) (substring branch 2))
((string-prefix-p "+ " branch) (substring branch 2))
(t branch))
unless (or (string= name base)
(string= name current)
(string-empty-p name)
(member name cust/magit-cleanup--protected-branches))
collect name)))
branches))
(defun cust/magit-cleanup--gone-branches ()
"Return list of local branches whose upstream tracking branch is gone.
Excludes protected branches." (let* ((output (magit-git-lines
"branch""--format=%(refname:short) %(upstream:track)")))
(cl-loop for line in output
for trimmed = (string-trim line)
when (string-match"\\`\\(.+\\) \\[gone\\]\\'" trimmed)
unless (member (match-string 1 trimmed)
cust/magit-cleanup--protected-branches)
collect (match-string 1 trimmed))))
;; --- Buffer state --- (defvar-local cust/magit-cleanup--branches nil"Alist of (BRANCH . SELECTED-P) for cleanup candidates.")
(defvar-local cust/magit-cleanup--prune nil"Whether to prune remote tracking branches.")
(defvar-local cust/magit-cleanup--base nil"The base branch used for merge detection.")
(defvar-local cust/magit-cleanup--merged nil"List of branch names that are merged.")
(defvar-local cust/magit-cleanup--gone nil"List of branch names whose upstream is gone.")
;; --- Mode and rendering --- (defvar magit-branch-cleanup-mode-map
(make-sparse-keymap)
"Keymap for `magit-branch-cleanup-mode'.")
(define-derived-mode magit-branch-cleanup-mode special-mode "Branch-Cleanup""Major mode for selecting branches to delete." (setq truncate-lines t)
(setq buffer-read-only t))
(evil-define-key 'normal magit-branch-cleanup-mode-map
(kbd "t") #'cust/magit-cleanup--toggle
(kbd "RET") #'cust/magit-cleanup--toggle
(kbd "a") #'cust/magit-cleanup--select-all
(kbd "u") #'cust/magit-cleanup--deselect-all
(kbd "x") #'cust/magit-cleanup--execute
(kbd "j") #'cust/magit-cleanup--next
(kbd "n") #'cust/magit-cleanup--next
(kbd "k") #'cust/magit-cleanup--prev
(kbd "p") #'cust/magit-cleanup--prev
(kbd "q") #'quit-window)
(defun cust/magit-cleanup--render ()
"Render the cleanup buffer contents." (let ((inhibit-read-only t))
(erase-buffer)
(insert (propertize (format"Branch Cleanup (base: %s)\n\n" cust/magit-cleanup--base)
'face'magit-section-heading))
;; Merged branches (when cust/magit-cleanup--merged
(insert (propertize (format"Merged into %s:\n" cust/magit-cleanup--base)
'face'magit-section-secondary-heading))
(dolist (branch cust/magit-cleanup--merged)
(let ((selected (alist-get branch cust/magit-cleanup--branches
nilnil#'string=)))
(insert (format"%s %s\n" (if selected "[x]""[ ]")
(propertize branch 'face'magit-branch-local)))))
(insert"\n"))
;; Gone branches (when cust/magit-cleanup--gone
(insert (propertize"Upstream gone:\n"'face'magit-section-secondary-heading))
(dolist (branch cust/magit-cleanup--gone)
(let ((selected (alist-get branch cust/magit-cleanup--branches
nilnil#'string=)))
(insert (format"%s %s\n" (if selected "[x]""[ ]")
(propertize branch 'face'magit-branch-local)))))
(insert"\n"))
;; Prune option (insert"---\n")
(insert (format"%s Prune remote tracking branches (git fetch --prune)\n\n" (if cust/magit-cleanup--prune "[x]""[ ]")))
;; Help line (insert (propertize"[t] toggle [a] all [u] none [x] execute [q] quit"'face'font-lock-comment-face))
(goto-char (point-min))
;; Move to first selectable item (cust/magit-cleanup--next)))
;; --- Navigation --- (defun cust/magit-cleanup--branch-at-point ()
"Return the branch name at point, or nil." (save-excursion
(beginning-of-line)
(when (looking-at"\\[.\\] \\(.+\\)$")
(match-string-no-properties 1))))
(defun cust/magit-cleanup--prune-line-p ()
"Return non-nil if point is on the prune option line." (save-excursion
(beginning-of-line)
(looking-at"\\[.\\] Prune remote")))
(defun cust/magit-cleanup--next ()
"Move to the next selectable item." (interactive)
(let ((found nil))
(while (and (not found) (not (eobp)))
(forward-line1)
(when (or (cust/magit-cleanup--branch-at-point)
(cust/magit-cleanup--prune-line-p))
(setq found t)))
(beginning-of-line)))
(defun cust/magit-cleanup--prev ()
"Move to the previous selectable item." (interactive)
(let ((found nil))
(while (and (not found) (not (bobp)))
(forward-line-1)
(when (or (cust/magit-cleanup--branch-at-point)
(cust/magit-cleanup--prune-line-p))
(setq found t)))
(beginning-of-line)))
;; --- Toggle and selection --- (defun cust/magit-cleanup--toggle ()
"Toggle the item under point." (interactive)
(cond
((cust/magit-cleanup--branch-at-point)
(let* ((branch (cust/magit-cleanup--branch-at-point))
(current (alist-get branch cust/magit-cleanup--branches
nilnil#'string=)))
(setf (alist-get branch cust/magit-cleanup--branches nilnil#'string=)
(not current))
(cust/magit-cleanup--refresh-line)))
((cust/magit-cleanup--prune-line-p)
(setq cust/magit-cleanup--prune (not cust/magit-cleanup--prune))
(cust/magit-cleanup--refresh-line))))
(defun cust/magit-cleanup--refresh-line ()
"Refresh the checkbox on the current line." (let ((inhibit-read-only t))
(save-excursion
(beginning-of-line)
(when (looking-at"\\[.\\]")
(cond
((cust/magit-cleanup--branch-at-point)
(let* ((branch (cust/magit-cleanup--branch-at-point))
(selected (alist-get branch cust/magit-cleanup--branches
nilnil#'string=)))
(delete-region (line-beginning-position) (line-end-position))
(insert (format"%s %s" (if selected "[x]""[ ]")
(propertize branch 'face'magit-branch-local)))))
((cust/magit-cleanup--prune-line-p)
(delete-region (line-beginning-position) (line-end-position))
(insert (format"%s Prune remote tracking branches (git fetch --prune)" (if cust/magit-cleanup--prune "[x]""[ ]")))))))))
(defun cust/magit-cleanup--select-all ()
"Select all branches." (interactive)
(setq cust/magit-cleanup--branches
(mapcar (lambda (pair) (cons (car pair) t))
cust/magit-cleanup--branches))
(cust/magit-cleanup--render))
(defun cust/magit-cleanup--deselect-all ()
"Deselect all branches." (interactive)
(setq cust/magit-cleanup--branches
(mapcar (lambda (pair) (cons (car pair) nil))
cust/magit-cleanup--branches))
(cust/magit-cleanup--render))
;; --- Execution --- (defun cust/magit-cleanup--execute ()
"Delete selected branches and optionally prune remotes." (interactive)
(let* ((selected (cl-loop for (branch . sel) in cust/magit-cleanup--branches
when sel collect branch))
(prune cust/magit-cleanup--prune)
(count (length selected)))
(when (and (= count 0) (not prune))
(user-error"No branches selected and prune not enabled"))
(when (yes-or-no-p (format"Delete %d branch%s%s? " count
(if (= count 1) """es")
(if prune " and prune remotes""")))
(dolist (branch selected)
(magit-run-git "branch""-d" branch))
(when prune
(magit-run-git "fetch""--prune"))
(magit-refresh)
(quit-window t)
(message"Deleted %d branch%s%s." count
(if (= count 1) """es")
(if prune ", pruned remotes""")))))
;; --- Entry point --- (defun cust/magit-branch-cleanup ()
"Interactively select and delete merged/orphaned branches." (interactive)
(let* ((base (magit-main-branch))
(merged (cust/magit-cleanup--merged-branches base))
(gone (cust/magit-cleanup--gone-branches))
(all-branches (cl-union merged gone :test #'string=)))
(if (null all-branches)
(message"No branches to clean up.")
(let ((buf (get-buffer-create"*magit-branch-cleanup*")))
(with-current-buffer buf
(magit-branch-cleanup-mode)
(setq cust/magit-cleanup--base base)
(setq cust/magit-cleanup--merged merged)
(setq cust/magit-cleanup--gone gone)
(setq cust/magit-cleanup--branches
(mapcar (lambda (b) (cons b t)) all-branches))
(setq cust/magit-cleanup--prune nil)
(cust/magit-cleanup--render))
(let ((win (display-buffer-in-side-window
buf '((side . bottom)))))
(when win
(fit-window-to-buffer win)
(select-window win)))))))
;; Register in branch transient (transient-append-suffix 'magit-branch"x"'("D""Cleanup" cust/magit-branch-cleanup)))
Code Review
;; Adds the *Code-Review* buffer to the current perspective(add-hook 'code-review-mode-hook (lambda ()
(persp-add-buffer (current-buffer))))
;; Emojis are fun!(add-hook 'code-review-mode-hook#'emojify-mode)
;; Bind ? to the transient menu in code-review buffers(map! :after code-review
:map code-review-mode-map
:n "?"#'code-review-transient-api
:n "C-n"#'magit-section-forward
:n "C-p"#'magit-section-backward)
;; Use the forge credentials for authentication (from ~/.authinfo.gpg)(setq code-review-auth-login-marker 'forge)
;; Open the review buffer in the current window instead of a bottom split(setq code-review-new-buffer-window-strategy #'switch-to-buffer)
;; Fix closql v2.3+ compatibility: closql--remake-instance produces objects;; with an eieio--class struct at index 0 instead of a class name symbol.;; When closql-insert later calls closql--abbrev-class on the coerced list,;; it fails because the method only dispatches on (subclass closql-object).;; Normalizing index 0 before insert fixes this.(define-advice closql-insert (:before (_db obj &optional _replace) code-review-fix-class-tag)
(when (eieio--class-p (aref obj 0))
(aset obj 0 (eieio--class-name (aref obj 0)))))
;; Fix stale reference to code-review-db-connection (removed in closql v2 migration).;; The old variable no longer exists; closql manages connections internally now.(define-advice code-review-db-all-unfinished (:override () code-review-fix-stale-connection)
(let ((class 'code-review-db-pullreq)
(db (code-review-db)))
(->> (emacsql db
[:select :*
:from 'pullreq :where (and (= saved 't)
(is finished nil))])
(mapcar (lambda (row) (closql--remake-instance class db row))))))
Marginalia is a tool (written by the same author as vertico) which adds marginalia to the mini-buffer completions. Marginalia are marks and annotations placed at the margin of a page in a book.
The below settings are basically just copied of tecosaur’s config, and makes it look a bit nicer.
Add color to file attributes
Don’t display user:group information if I am the owner/group
When a file modified time is quite recent, use relative age (eg. 2h ago)
Outshine attempts to bring the look and feel of org-mode to the world outside Org major mode.
It’s an extension of outline-minor-mode that should act as a replacement of outline-mode.
(setq projectile-enable-caching t projectile-auto-cleanup-known-projects t projectile-project-search-path '("~/workspace") ;; A relic directory from when I used Eclipse back in the days projectile-globally-ignored-files '(".DS_Store") ;; Super annoying files projectile-globally-ignored-directories '(".git";; I never want to cache files in these directories".idea"".import"".expert"".elixir_ls"".htmlcov"".pytest_cache""_build""__pycache__""deps""node_modules"))
;; Elixir umbrella project detection(defun projectile-elixir-umbrella-root (dir)
"Find the Elixir umbrella project root if DIR is inside one." (when-let* ((current-dir (or dir default-directory))
(project-dir (locate-dominating-file current-dir "mix.exs")))
;; Check if this project is inside an apps/ directory (let* ((project-path (directory-file-name project-dir))
(parent-dir (file-name-directory project-path)))
(when (and parent-dir
(string-match-p "/apps/?$" parent-dir))
;; We're inside an apps/ directory, look for umbrella root (let ((umbrella-root (file-name-directory (directory-file-name parent-dir))))
(when (file-exists-p (expand-file-name"mix.exs" umbrella-root))
umbrella-root))))))
(after! projectile
;; Add C# and F# project files as root markers (dolist (file '("*.csproj""*.fsproj"))
(add-to-list 'projectile-project-root-files file))
;; Add umbrella detection function to the beginning of the list;; This ensures umbrella projects are detected before individual apps (add-to-list 'projectile-project-root-functions#'projectile-elixir-umbrella-root))
Spelling
Easily cycle between the languages I use (English and Norwegian) by hitting F8.
(let ((langs '("en""no")))
(setq lang-ring (make-ring (length langs)))
(dolist (elem langs) (ring-insert lang-ring elem)))
(defun cycle-ispell-languages ()
"Cycle between languages in the language ring `lang-ring`." (interactive)
(let ((lang (ring-ref lang-ring -1)))
(ring-insert lang-ring lang)
(ispell-change-dictionary lang)))
;; Cycle languages with F8(global-set-key (kbd "<f8>") #'cycle-ispell-languages)
;; And add a Doom shortcut to the "toggle" menu for good measures(map! :leader
(:prefix-map ("t"."toggle")
:desc "Next spell checker language""S"#'cycle-ispell-languages))
For a personal dictionaries (with all the misspelled words and such)
(use-package! flyspell
:when (modulep! :checkers spell +flyspell)
:after ispell
;; :hook (find-file . flyspell-on-for-buffer-type) ;; Getting errors, needs fix :init
(defun flyspell-on-for-buffer-type ()
"Enable Flyspell appropriately for the major mode of the current buffer.
Uses `flyspell-prog-mode' for modes derived from `prog-mode', so only strings
and comments get checked. Other buffers get `flyspell-mode' to check all text.
If flyspell is already enabled for buffer, do nothing." (interactive)
(if (not (symbol-value flyspell-mode)) ;; if not already enabled (progn
(if (derived-mode-p 'prog-mode)
(progn
(message"Flyspell on (code)")
(flyspell-prog-mode))
(progn ;; else (message"Flyspell on (text)")
(flyspell-mode 1))))))
:config
;; Significantly speeds up flyspell, which would otherwise print;; messages for every word when checking the entire buffer (setq flyspell-issue-welcome-flag nil flyspell-issue-message-flag nil))
Downloading dictionaries
Currently using Aspell with Norwegian and English languages.
Should probably document installation.
Highlights symbols with overlays while providing a keymap for various operations on the highlighted symbols.
(package! symbol-overlay)
Advice removing all symbol overlays when hitting ESC.
(defun cust/advice-symbol-overlay-remove-all (orig-fun &rest args)
"Remove all symbol overlays when pressing ESC" (interactive)
(when (symbol-overlay-get-list 0)
(symbol-overlay-remove-all))
(apply orig-fun args))
Set up some basic keybindings
(use-package! symbol-overlay
:hook (prog-mode . symbol-overlay-mode)
:config
(evil-define-key '(normal insert) 'global (kbd "s-i") #'symbol-overlay-put) ;; Put an overlay on the symbol on point (evil-define-key '(normal insert) 'global (kbd "s-n") #'symbol-overlay-jump-next) ;; Jump to next symbol on point (evil-define-key '(normal insert) 'global (kbd "s-p") #'symbol-overlay-jump-prev) ;; Jump to previous symbol on point (evil-define-key '(normal visual insert) 'global [escape] #'cust/evil-esc) ;; We need a custom ESC function for the following advice (advice-add 'cust/evil-esc :around #'cust/advice-symbol-overlay-remove-all)) ;; Advice ESC to remove all symbol overlays
Tramp
Tramp makes accessing remote file systems using Emacs a blast.
(after! tramp
(setq tramp-default-method "scp"))
Treemacs
Automatically remove projects from the treemacs-persist file when no longer present.
(setq treemacs-persist-file nil) ;; Disable using the treemacs-persist file. It cause too much trouble when removing or moving projects around.
Make treemacs pretty and functional.
(after! (treemacs winum)
(setq doom-themes-treemacs-theme "doom-colors"; Enable nice colors for treemacs doom-themes-treemacs-enable-variable-pitch t) ; Enable variable-pitch font (setq winum-ignored-buffers-regexp
(delete (regexp-quote (format"%sFramebuffer-" treemacs-buffer-name-prefix))
winum-ignored-buffers-regexp))
;; This PR cause treemacs to appear on the bottom instead of on the left/right hand side;; https://github.com/Alexander-Miller/treemacs/pull/971;; Workaround: (set-popup-rule! "^ \\*Treemacs" :side treemacs-position
:width treemacs-width
:quit nil)
(treemacs-project-follow-mode t)
(treemacs-follow-mode t)
(treemacs-define-RET-action 'file-node-open#'treemacs-visit-node-in-most-recently-used-window)
(treemacs-define-RET-action 'file-node-closed#'treemacs-visit-node-in-most-recently-used-window))
Vertico is the new kid on the block when it comes to searching in Emacs. Built on top of the native
Emacs search APIs instead of 3rd party tools.
(after! vertico
;; Emacs 28+: Hide commands in M-x that doesn't work in the current mode.;; Vertico commands are hidden in normal buffers. (setq read-extended-command-predicate #'command-completion-default-include-p)
;; These mappings seems a bit inverted, but it works as I like it, so I dunno...? (map! :map vertico-map
"C-u"#'vertico-scroll-down
"C-d"#'vertico-scroll-up
"C-c C-o"#'embark-export))
Tips’n tricks
Sometimes you want to input some value that’s similar to a pre-selected choice. We can use the input
value by hitting M-<enter> to use our input value instead of the pre-selected value.
Vertico Posframe (experimental)
I’ve seen some cool stuff using a separate posframe for displaying vertico results. I’m still not convinced,
because it tends to hide the content of my buffers when displayed on top of it.
Either case; it can be enabled by installing the vertico-posframe package.
(package! vertico-posframe)
And enabled like this.
(after! vertico
(vertico-posframe-mode 1))
Very large files
The very large files mode loads large files in chunks, letting us open ridiculously large files!
Extra snippets
Snippets are basic text files (no extension), located in directories representing the mode they will
be active for. For a quick guide on how we can organize snippets, take a look at this page.
Doom already enables indent-bars via the :ui indent-guides module and sets indent-bars-prefer-character t
on macOS (bitmaps are slower on Mac). We add performance optimizations:
This makes manual pages look pretty by adding variable pitch fortification and colors 🤗
(package! info-colors)
To use this we’ll just hook into Info.
(use-package! info-colors
:after info
:hook (Info-selection-hook . info-colors-fontify-node)
:commands (info-colors-fontify-node))
Ultra Scroll
Instead of using Dooms built-in smooth-scroll, I’m using the ultra-scroll package.
The only caveat (so far) is that it requires us to drop scroll-margin, but that will hopefully
be fixed in the future.
(after! lsp-mode
(setq read-process-output-max (*10241024) ;; 1mb lsp-auto-guess-root t lsp-file-watch-threshold 1000000 lsp-idle-delay 0.500 lsp-keep-workspace-alive nil lsp-modeline-code-actions-segments '(count icon name)
lsp-response-timeout 10)
(defun cust/kill-lsp-child-processes (workspace)
"Kill child processes of WORKSPACE's LSP server.
Some LSP servers spawn child processes that don't get cleaned up
when the workspace is shut down. This ensures orphaned processes
are terminated." (when-let* ((proc (lsp--workspace-proc workspace))
(pid (process-id proc)))
(call-process"pkill"nilnilnil"-P" (number-to-string pid))))
(add-hook 'lsp-after-uninitialized-functions#'cust/kill-lsp-child-processes))
Emacs LSP Performance Booster
Emacs LSP Performance Booster is a wrapper executable written in Rust that improves the performance
of LSP mode. See build instructions in the Github repository.
Use treesit-auto to automatically install language grammar files.
(package! treesit-auto)
(use-package! treesit-auto
:custom
(treesit-auto-install 'prompt)
:config
;; Pre-compute available grammars once at startup to avoid slow runtime checks;; on every file open. This scans once instead of on each set-auto-mode call.;; This gives a MAJOR boost in increasing the time it takes to load files!! (setq treesit-auto-langs
(cl-loop for recipe in treesit-auto-recipe-list
when (treesit-language-available-p (treesit-auto-recipe-lang recipe))
collect (treesit-auto-recipe-lang recipe)))
(treesit-auto-add-to-auto-mode-alist 'all)
(global-treesit-auto-mode))
Yaml
Yaml comes in many different flavors, let’s select schema with ,s.
It’s nice to see ANSI colour codes displayed. However, until Emacs 28 it’s not possible to do this without modifying the buffer, so let’s condition this block on that.
Sometimes I’m a bit lazy and just want to click around with the mouse.
(with-eval-after-load 'org (require 'org-mouse))
Keybindings
Add some handy keybindings under SPC-, x for emphasizing text in org-mode.
(after! org
(defmacro cust/org-emphasize (fname char)
"Macro that creates a function for setting emphasises in org-mode"`(defun ,fname () (interactive)
(org-emphasize ,char))))
Org tables aren’t the prettiest thing to look at.
This package is supposed to redraw them in the buffer with box-drawing characters.
Sounds like an improvement to me! We’ll make use of this with writeroom-mode.
While org-hide-emphasis-markers is very nice, it can sometimes make edits which
occur at the border a bit more fiddley.
We can improve this situation without sacrificing visual amenities with the org-appear package.
(use-package! org-appear
:hook (org-mode . org-appear-mode)
:config
(setq org-appear-autoemphasis t org-appear-autosubmarkers t org-appear-autolinks nil)
;; for proper first-time setup, `org-appear--set-elements';; needs to be run after other hooks have acted. (run-at-time nilnil#'org-appear--set-elements))
Symbols
This section is pretty much just copied from tecosaurs config (again…)
This piece of code improves how the capturing templates look.
(after! org-capture
(defun org-capture-select-template-prettier (&optional keys)
"Select a capture template, in a prettier way than default
Lisp programs can force the template by setting KEYS to a string." (let ((org-capture-templates
(or (org-contextualize-keys
(org-capture-upgrade-templates org-capture-templates)
org-capture-templates-contexts)
'(("t""Task" entry (file+headline """Tasks")
"* TODO %?\n %u\n %a")))))
(if keys
(or (assoc keys org-capture-templates)
(error"No capture template referred to by \"%s\" keys" keys))
(org-mks org-capture-templates
"Select a capture template\n━━━━━━━━━━━━━━━━━━━━━━━━━""Template key: "`(("q",(concat (nerd-icons-octicon "nf-oct-stop" :face 'nerd-icons-red :v-adjust 0.01) "\tAbort")))))))
(advice-add 'org-capture-select-template :override #'org-capture-select-template-prettier)
(defun org-mks-pretty (table title &optional prompt specials)
"Select a member of an alist with multiple keys. Prettified.
TABLE is the alist which should contain entries where the car is a string.
There should be two types of entries.
1. prefix descriptions like (\"a\" \"Description\")
This indicates that `a' is a prefix key for multi-letter selection, and
that there are entries following with keys like \"ab\", \"ax\"…
2. Select-able members must have more than two elements, with the first
being the string of keys that lead to selecting it, and the second a
short description string of the item.
The command will then make a temporary buffer listing all entries
that can be selected with a single key, and all the single key
prefixes. When you press the key for a single-letter entry, it is selected.
When you press a prefix key, the commands (and maybe further prefixes)
under this key will be shown and offered for selection.
TITLE will be placed over the selection in the temporary buffer,
PROMPT will be used when prompting for a key. SPECIALS is an
alist with (\"key\" \"description\") entries. When one of these
is selected, only the bare key is returned." (save-window-excursion
(let ((inhibit-quit t)
(buffer (org-switch-to-buffer-other-window "*Org Select*"))
(prompt (or prompt "Select: "))
case-fold-search
current)
(unwind-protect
(catch 'exit (while t (setq-local evil-normal-state-cursor (listnil))
(erase-buffer)
(insert title "\n\n")
(let ((des-keys nil)
(allowed-keys '("\C-g"))
(tab-alternatives '("\s""\t""\r"))
(cursor-type nil))
;; Populate allowed keys and descriptions keys;; available with CURRENT selector. (let ((re (format"\\`%s\\(.\\)\\'" (if current (regexp-quote current) "")))
(prefix (if current (concat current " ") "")))
(dolist (entry table)
(pcase entry
;; Description. (`(,(and key (pred (string-match re))) ,desc)
(let ((k (match-string 1 key)))
(push k des-keys)
;; Keys ending in tab, space or RET are equivalent. (if (member k tab-alternatives)
(push "\t" allowed-keys)
(push k allowed-keys))
(insert (propertize prefix 'face'font-lock-comment-face) (propertize k 'face'bold) (propertize"›"'face'font-lock-comment-face) " " desc "…""\n")))
;; Usable entry. (`(,(and key (pred (string-match re))) ,desc .,_)
(let ((k (match-string 1 key)))
(insert (propertize prefix 'face'font-lock-comment-face) (propertize k 'face'bold) " " desc "\n")
(push k allowed-keys)))
(_ nil))))
;; Insert special entries, if any. (when specials
(insert"─────────────────────────\n")
(pcase-dolist (`(,key ,description) specials)
(insert (format"%s %s\n" (propertize key 'face'(bold nerd-icons-red)) description))
(push key allowed-keys)))
;; Display UI and let user select an entry or;; a sub-level prefix. (goto-char (point-min))
(unless (pos-visible-in-window-p (point-max))
(org-fit-window-to-buffer))
(let ((pressed (org--mks-read-key allowed-keys
prompt
(not (pos-visible-in-window-p (1- (point-max)))))))
(setq current (concat current pressed))
(cond
((equal pressed "\C-g") (user-error"Abort"))
;; Selection is a prefix: open a new menu. ((member pressed des-keys))
;; Selection matches an association: return it. ((let ((entry (assoc current table)))
(and entry (throw 'exit entry))))
;; Selection matches a special entry: return the;; selection prefix. ((assoc current specials) (throw 'exit current))
(t (error"No entry available")))))))
(when buffer (kill-buffer buffer))))))
(advice-add 'org-mks :override #'org-mks-pretty))
Templates
Set up the actual templates for different categories.
Here’s a nice overview of org-capture-template variables.
It would also be nice to improve how the capture dialogue looks
The org-capture bin is rather nice, but I’d be nicer with a smaller frame, and no modeline.
(defun cust/typescript-lsp-maybe ()
"Start LSP for TypeScript only if not in a Deno project.
Deno projects use deno-ls via their own mode hooks." (unless (deno-ts-project-p)
(lsp!)))
(defun cust/typescript-prettier-maybe ()
"Enable prettier-mode only if not in a Deno project." (unless (deno-ts-project-p)
(prettier-mode 1)))
(use-package! typescript-ts-mode
:hook (typescript-ts-mode . cust/typescript-prettier-maybe)
:config
(add-hook! '(typescript-ts-mode-hook tsx-ts-mode-hook) #'cust/typescript-lsp-maybe))
Deno
This section configures support for Deno, inspired by this post.
First we need a way to know if we’re in a Deno project or not.
(defun deno-ts-project-p ()
"Return non-nil if current buffer is in a Deno project.
Checks for deno.json or deno.jsonc in any parent directory." (let ((dir (or (and buffer-file-name (file-name-directorybuffer-file-name))
default-directory)))
(or (locate-dominating-file dir "deno.json")
(locate-dominating-file dir "deno.jsonc"))))
Override the default apheleia deno formatters to include the --config flag.
This ensures deno fmt finds the project’s deno.json with formatting options like singleQuote.
Define new major modes for Deno. We’ll activate these modes if we’re in a Deno project.
;; Deno TypeScript mode (for .ts files)(define-derived-mode deno-ts-mode typescript-ts-mode "Deno[TS]""Major mode for Deno TypeScript files." :group 'deno (setq-local apheleia-formatter 'denofmt-ts)
;; Disable TypeScript LSP servers - we use deno-ls instead (setq-local lsp-disabled-clients '(ts-ls jsts-ls)))
;; Deno TSX mode (for .tsx files)(define-derived-mode deno-tsx-mode tsx-ts-mode "Deno[TSX]""Major mode for Deno TSX files." :group 'deno (setq-local apheleia-formatter 'denofmt-tsx)
(setq-local lsp-disabled-clients '(ts-ls jsts-ls)))
;; Deno JavaScript mode (for .js files)(define-derived-mode deno-js-mode js-ts-mode "Deno[JS]""Major mode for Deno JavaScript files." :group 'deno (setq-local apheleia-formatter 'denofmt-js)
(setq-local lsp-disabled-clients '(ts-ls jsts-ls)))
;; Deno JSON mode (for .json files)(define-derived-mode deno-json-mode json-ts-mode "Deno[JSON]""Major mode for Deno JSON files." :group 'deno (setq-local apheleia-formatter 'denofmt-json))
;; Deno Markdown mode (for .md files)(define-derived-mode deno-md-mode markdown-mode "Deno[MD]""Major mode for Deno Markdown files." :group 'deno (setq-local apheleia-formatter 'denofmt-md))
;; Auto-switch to Deno modes after the base mode is set;; This runs after treesit-auto has set up the tree-sitter mode(defun deno--maybe-activate-deno-mode ()
"Switch to appropriate Deno mode if in a Deno project." (when (deno-ts-project-p)
(pcase major-mode
('typescript-ts-mode (deno-ts-mode))
('tsx-ts-mode (deno-tsx-mode))
('js-ts-mode (deno-js-mode))
('json-ts-mode (deno-json-mode))
('markdown-mode (deno-md-mode)))))
(add-hook 'after-change-major-mode-hook#'deno--maybe-activate-deno-mode)
;; Register Deno LSP server(defun deno--register-lsp-client ()
"Register the Deno LSP client if not already properly registered." (require 'lsp-mode)
(lsp-register-client
(make-lsp-client
:new-connection (lsp-stdio-connection
(lambda () (list (or (executable-find "deno") "deno") "lsp")))
:major-modes '(deno-ts-mode deno-tsx-mode deno-js-mode)
:priority 10 :server-id 'deno-ls :initialization-options (lambda () (list :clientInfo (list :name "deno-ls")))
:notification-handlers (lsp-ht ("window/logMessage"'ignore))
:add-on? nil)))
(defun deno--lsp-start ()
"Ensure Deno LSP client is registered and start LSP." (deno--register-lsp-client)
(lsp))
(add-hook! '(deno-ts-mode-hook deno-tsx-mode-hook deno-js-mode-hook) #'deno--lsp-start)
Python
LSP Python
Add some extra ignored-directories for LSP.
(after! (python lsp-mode)
(add-to-list 'lsp-file-watch-ignored-directories"[/\\\\]\\.eggs\\'")
(add-to-list 'lsp-file-watch-ignored-directories"[/\\\\]\\build\\'")
;; Make sure pyright can find the virtualenv;; (add-hook 'pyvenv-post-activate-hooks (lambda ();; (when (modulep! :lang python +pyright);; (setq lsp-pyright-venv-path pyvenv-virtual-env)))) )
Also, check out this handy guide for extra performance tips!
It’s recommended to use plist for deserialization. In order to achieve that we need to export a
LSP_USE_PLISTS=true environmental variable and ensure that Emacs knows about it (before lsp-mode is compiled).
Elixir
Use the latest and greatest!
(package! flycheck-dialyxir)
Flycheck integration
;; Override the `lsp-credo-version' variable to get the latest version.;; It has to be set before `lsp-credo.el' is loaded.(custom-set-variables '(lsp-credo-version "0.3.0"))
(use-package! flycheck-dialyxir
:when (and (modulep! :checkers syntax)
(not (modulep! :checkers syntax +flymake)))
:after elixir-mode
:config (flycheck-dialyxir-setup))
Dexter LSP
Dexter is Remote’s take on an LSP server for Elixir written in Go.
Install Dexter globally using mise:
mise plugin add dexter https://github.com/remoteoss/dexter.git && mise use -g dexter@latest
Remember to add .dexter.db* to your .gitignore file.
(after! lsp-mode
(lsp-register-client
(make-lsp-client
:new-connection (lsp-stdio-connection
(lambda () (list (string-trim (shell-command-to-string "mise which dexter")) "lsp")))
:major-modes '(elixir-mode elixir-ts-mode heex-ts-mode)
:priority 2; Higher priority than expert-ls, so dexter is preferred :server-id 'dexter-ls :initialization-options (lambda ()
(list :followDelegates t :debug nil))
:notification-handlers (lsp-ht ("window/logMessage"'ignore))
:add-on? nil)))
;; Note: The hook for lsp is already set up for elixir-ts-mode after expert-ls configuration
Expert LSP
The official language server for Elixir. Kept as a fallback but disabled from auto-starting
so dexter-ls is always used. Enable manually with M-x lsp if needed.
Configure mix format to run from the project root where .formatter.exs lives.
This ensures it respects project-specific formatting settings like line length.
CRITICAL: We MUST redirect stderr to prevent compilation output from overwriting files.
We save stdin to a temp file, format it, and output the result to ensure clean handling.
Configure apheleia to use rebar3 fmt for Erlang formatting. The formatter must run from
the project root (where rebar.config lives), so we use apheleia-from-project-root.
(after! apheleia
;; Override csharpier to use `dotnet csharpier` for local tool support. (setf (alist-get 'csharpier apheleia-formatters)
'("dotnet""csharpier""format""--write-stdout")))
C-sharp is supported by default in newer versions of Emacs through csharp-tree-sitter-mode.
Install the dotnet package as well to get some extra goodies.
(package! dotnet)
Execute M-x treesit-install-language-grammar and enter c-sharp. When prompted if you want to do it interactively, enter “Yes”,
and paste the Github repository (tree-sitter/tree-sitter-c-sharp) for the grammar files.
Just keep pressing <enter> to accept defaults for the rest of the process.
LSP Dotnet
Use csharp-ls as the language server. If a project has csharp-ls installed as a local dotnet tool
(in .config/dotnet-tools.json), use that version. Otherwise, fall back to the globally installed
version at ~/.local/bin/csharp-ls.
(after! lsp-mode
(defun +csharp--project-has-local-csharp-ls-p ()
"Check if the current project has csharp-ls as a local dotnet tool." (when-let* ((project-root (or (lsp-workspace-root)
(locate-dominating-file default-directory ".sln")
(locate-dominating-file default-directory ".csproj")))
(tools-file (expand-file-name".config/dotnet-tools.json" project-root)))
(when (file-exists-p tools-file)
(condition-case nil (let* ((json-object-type 'alist)
(json-array-type 'list)
(content (json-read-file tools-file))
(tools (alist-get 'tools content)))
(assoc'csharp-ls tools))
(errornil)))))
(defun +csharp--cls-find-executable ()
"Find csharp-ls executable, preferring project-local over global.
If project has csharp-ls as a local dotnet tool, use `dotnet tool run csharp-ls`.
Otherwise, use the global installation at ~/.local/bin/csharp-ls." (if (+csharp--project-has-local-csharp-ls-p)
(list"dotnet""tool""run""csharp-ls")
(expand-file-name"~/.local/bin/csharp-ls")))
;; Override the default executable finder (advice-add 'lsp-csharp--cls-find-executable :override #'+csharp--cls-find-executable))
;; Use lsp-deferred to avoid blocking file loading - LSP starts when Emacs is idle(add-hook! 'csharp-ts-mode-hook#'lsp-deferred)
(use-package! dotnet
:defer t; Don't load until explicitly needed :commands (dotnet-mode dotnet-run dotnet-build dotnet-test)
:config
(setq dotnet-project-search-max-depth 5)) ; Reduce search depth for faster lookups;; Defer dotnet-mode activation to idle time(defun +csharp--setup-dotnet-mode-deferred ()
"Set up dotnet-mode after a short delay to avoid blocking file loading." (run-with-idle-timer
1.0nil (lambda ()
(when (and (buffer-live-p (current-buffer))
(derived-mode-p 'csharp-ts-mode'csharp-mode))
(dotnet-mode 1)
;; Set project directory lazily (setq-local dotnet-project-directory
(or (locate-dominating-file default-directory ".sln")
(locate-dominating-file default-directory ".csproj")
default-directory))))))
(add-hook! 'csharp-ts-mode-hook#'+csharp--setup-dotnet-mode-deferred)
(add-to-list 'auto-mode-alist'("\\.csproj\\'". csproj-mode))
Keybindings
Add the sharper-main-transient menu to local leader.
Rustic is an extension of rust-mode which adds a number of useful features. Most rustic features are bound to the C-c C-c
prefix, which I finds a bit cumbersome. Let’s rebind them to the localleader so we have them easy accessible.
Advice the *cargo-run* buffer to accept user input (why doesn’t it already?).
(after! rustic
(defadvice! rustic-cargo-run-accept-user-input ()
"Advices the *cargo-run* buffer to run in comint-mode and accept user input" :after 'rustic-cargo-run (interactive)
(let ((current-window (selected-window))
(cargo-window (display-buffer (get-buffer"*cargo-run*") nil'visible)))
(select-window cargo-window)
(comint-mode)
(read-only-mode 0)
(select-window current-window))))
LSP Rust
Auto-detect Cargo.toml by walking up from the current file. This handles Rust crates nested inside
non-Rust projects (e.g. a NIF inside an Elixir umbrella).
(defun cust/find-cargo-toml ()
"Walk up from `buffer-file-name' and return the nearest Cargo.toml path, or nil." (when-let ((file (buffer-file-name)))
(let ((dir (locate-dominating-file (file-name-directory file) "Cargo.toml")))
(when dir
(expand-file-name"Cargo.toml" dir)))))
(after! (rustic lsp-mode)
(add-hook 'rustic-mode-hook (lambda ()
(when-let ((cargo (cust/find-cargo-toml)))
(setq lsp-rust-analyzer-linked-projects (vector cargo))))
-90))
Configures lsp-mode hints for Rust (using rust-analyzer)
(From rust-emacs-setup guide)
(after! (rustic lsp-mode)
(when (eq rustic-lsp-server 'rust-analyzer)
(setq lsp-eldoc-render-all t lsp-rust-analyzer-cargo-watch-command "clippy" lsp-rust-analyzer-display-chaining-hints t lsp-rust-analyzer-display-closure-return-type-hints t lsp-rust-analyzer-display-lifetime-elision-hints-enable "skip_trivial" lsp-rust-analyzer-display-lifetime-elision-hints-use-parameter-names nil lsp-rust-analyzer-display-parameter-hints nil lsp-rust-analyzer-display-reborrow-hints nil lsp-rust-analyzer-server-display-inlay-hints t)))
Configures lsp-ui for Rust
(after! (rustic lsp-ui-mode)
(setq lsp-ui-peek-always-show t lsp-ui-sideline-show-hover t lsp-ui-doc-enable nil))
Golang
Installing Go
I’m using ASDF for managing various programming languages.
$ asdf install golang latest
$ asdf global golang latest
Next, there’s a bunch of dependencies we need to install in order to have a smooth experience.
Make sure the GOPATH environment variable is properly set!
gocode for code completion and eldoc support
godoc for documentation lookup
gorename for extra refactoring commands
guru for code navigation and refactoring commands
gore REPL
goimports optional auto-formatting on saving files and fixing imports
gotest for generating test code
gomodifytags for manipulating tags
gopls language server
gotestsum a friendly test runner
govulncheck finds known vulnerabilities in project dependencies
$ go install github.com/x-motemen/gore/cmd/gore@latest
$ go install github.com/stamblerre/gocode@latest
$ go install golang.org/x/tools/cmd/godoc@latest
$ go install golang.org/x/tools/cmd/goimports@latest
$ go install golang.org/x/tools/cmd/gorename@latest
$ go install golang.org/x/tools/cmd/guru@latest
$ go install github.com/cweill/gotests/gotests@latest
$ go install github.com/fatih/gomodifytags@latest
$ go install golang.org/x/tools/gopls@latest
$ go install gotest.tools/gotestsum@latest
$ go install golang.org/x/vuln/cmd/govulncheck@latest
Security checker
The gosec tool inspects source code for security problems by scanning the Go AST.
When using the new go-ts-mode instead of go-mode, we loose some functionality that probably will
be fixed in upstreams Doom config soon.
(defun lsp-go-install-save-hooks ()
"Set up some before-save hooks to format buffer and add/delete imports" (add-hook! 'before-save-hook#'lsp-format-buffer tt)
(add-hook! 'before-save-hook#'lsp-organize-imports tt))
Add the go-ts-mode to major-mode-remap-alist so that we use the tree-sitter mode when coding Go.
