An Emacs Configuration

This repository contains my Emacs configuration which is built using emacs-twist. I use home-manager to install the configuration.

Note: This configuration is currently built and tested only on Linux.

For technical details, check out DeepWiki.

Trying out
Setup.el
Performance
Supported systems
Custom conventions
Macro packages
Built-ins
Typography settings
Org
Treesit-based major modes
Working with specific services
User package (akirak-*.el)
Packages
Software package management
Workarounds
Post init
Notes
License

Trying out

If you have Nix 2.9+ installed, you can try out the Emacs configuration without installing it. Note: Binary cache is only available for Linux x86-64 from Cachix. If you are using other platforms such as Mac, it may take several minutes to build the packages on your machine.

There are two variants of the configuration. One is built with the pgtk version of Emacs, which runs on Wayland:

nix run github:akirak/emacs-config#emacs-pgtk-on-tmpdir

There is another version, an X11 variant, which is now discouraged:

nix run github:akirak/emacs-config#emacs-on-tmpdir

Both commands create a temporary directory which will be used as user-emacs-directory containing an init file. The temporary directory will be cleaned up when Emacs exits.

Setup.el

Setup.el is an alternative to the famous use-package. I am interested to see if it can reduce the amount of configuration code.

(eval-when-compile
  (require 'setup)
  (require 'cl-lib)

  ;; Exactly the same definition as a snippet available at
  ;; https://www.emacswiki.org/emacs/SetupEl#h5o-4 but renamed
  (defmacro define-setup-macro (name signature &rest body)
    "Shorthand for `setup-define'.
  NAME is the name of the local macro.  SIGNATURE is used as the
  argument list for FN.  If BODY starts with a string, use this as
  the value for :documentation.  Any following keywords are passed
  as OPTS to `setup-define'."
    (declare (debug defun))
    (let (opts)
      (when (stringp (car body))
        (setq opts (nconc (list :documentation (pop body))
                          opts)))
      (while (keywordp (car body))
        (let* ((prop (pop body))
               (val `',(pop body)))
          (setq opts (nconc (list prop val) opts))))
      `(setup-define ,name
         (cl-function (lambda ,signature ,@body))
         ,@opts)))

  (define-setup-macro :package (package)
    "Fake installation of PACKAGE."
    :repeatable t
    :shorthand cadr))

:auto-insert

(eval-when-compile
  (define-setup-macro
   :auto-insert (&rest entries)
   "Add ENTRIES to `auto-insert-alist'."
   `(with-eval-after-load 'autoinsert
      (dolist (entry (reverse ',entries))
        (add-to-list 'auto-insert-alist entry)))))

:defer

(eval-when-compile
  (define-setup-macro :defer (seconds &optional func)
    "Call a function at N seconds after init."
    `(add-hook 'after-init-hook
               (lambda ()
                 (run-with-timer ,seconds nil
                                 ,(or func (setup-get 'hook)))))))

:el-patch

(eval-when-compile
  (setup-define :el-patch
    (lambda (&rest body)
      `(when (require 'el-patch nil t)
         ,@body))
    :documentation "Evaluate el-patch definitions."
    :debug '(setup)
    :after-loaded t
    :indent 0))

:embark

(eval-when-compile
  (define-setup-macro
   :embark (map interactive &rest bindings)
   "Proxy or bind embark bindings."
   :indent 2
   `(with-eval-after-load 'embark
      ,@(cl-loop for (key cmd name) in bindings
                 collect `(keymap-set ,map ,key
                                      ,(if interactive
                                           `(defun ,name (arg)
                                              (interactive ,interactive)
                                              (,cmd arg))
                                         `(quote ,cmd)))))))

:ffap

(eval-when-compile
  (define-setup-macro
   :ffap (func)
   "Add a mode-specific entry to ffap-alist."
   (let ((symbol (if (symbolp func)
                     func
                   (eval func)))
         (mode (setup-get 'mode)))
     `(with-eval-after-load 'ffap
        (add-to-list 'ffap-alist '(,mode . ,symbol))))))

:global-keymap

(eval-when-compile
  (define-setup-macro
   :global-keymap (key command)
   "Use `keymap-global-set' to define global keybindings."
   :repeatable t
   `(keymap-global-set ,key ,command)))

:huan

(eval-when-compile
  (define-setup-macro
   :huan (&rest entries)
   "Add ENTRIES to `huan-mode-symbols-alist' for the mode."
   :indent 0
   `(with-eval-after-load 'huan
      (let ((mode ',(setup-get 'mode))
            (entries ',entries))
        (if-let* ((cell (assq mode huan-mode-symbols-alist)))
            (let ((sym (make-symbol "entries")))
              (set sym (cdr cell))
              (dolist (ent (reverse entries))
                (add-to-list sym ent))
              (setcdr cell (symbol-value sym)))
          (push (cons mode entries)
                huan-mode-symbols-alist))))))

:keymap

(eval-when-compile
  (define-setup-macro
   :keymap (key command)
   "Use `keymap-set' to define keybindings."
   :after-loaded t
   :repeatable t
   `(keymap-set ,(setup-get 'map) ,key ,command)))

:keymap-unset

(eval-when-compile
  (define-setup-macro
   :keymap-unset (key)
   "Use `keymap-unset' to define keybindings."
   :after-loaded t
   :repeatable t
   `(keymap-unset ,(setup-get 'map) ,key)))

:mode-project-roots

Specify extra root files to help eglot correctly identify project roots.

(defvar akirak-project-per-mode-root-files nil)

(eval-when-compile
  (define-setup-macro
   :mode-project-roots (&rest filenames)
   "Define file names indicating the project root."
   `(add-to-list 'akirak-project-per-mode-root-files
                 (cons ',(setup-get 'mode) ',filenames)
                 nil
                 (lambda (x y) (eq (car x) (car y))))))

:mode-repl

(eval-when-compile
  (define-setup-macro :mode-repl (repl-fn)
    "Add an entry to `rtog/mode-repl-alist'."
    `(progn
       (with-eval-after-load 'repl-toggle
         (push (cons ',(setup-get 'mode) ',repl-fn)
               rtog/mode-repl-alist))
       (add-hook ',(setup-get 'hook)
                 #'repl-toggle-mode))))

:nixpkgs

(eval-when-compile
  (define-setup-macro :nixpkgs (&rest nixpkgs)
    "Fake installation of packages from NIXPKGS for executables."))

:org-babel-language

(eval-when-compile
  (define-setup-macro
   :org-babel-language (t-or-language)
   "Define file names indicating the project root."
   (let ((language (if (eq t-or-language t)
                       (thread-last
                         (setup-get 'feature)
                         (symbol-name)
                         (string-remove-prefix "ob-")
                         (intern))
                     t-or-language)))
     `(with-eval-after-load 'ob
        (cl-pushnew '(,language . t) org-babel-load-languages)))))

:org-open

(eval-when-compile
  (define-setup-macro
   :org-open (file command &rest plist)
   `(with-eval-after-load 'org
      (cl-pushnew (cons ,file
                        ,(if (plist-get plist :file)
                             `(defun ,(intern (format "akirak/org-open-%s"
                                                      (if (string-match (rx (+ alnum)) file)
                                                          (match-string 0 file)
                                                        file)))
                                  (filename _)
                                (,command filename))
                           `,command))
                  org-file-apps))))

:org-src-lang

(eval-when-compile
  (define-setup-macro
   :org-src-lang (&rest langs)
   "Add an entry to `org-src-lang-modes' for the mode."
   `(with-eval-after-load "org-src"
      (dolist (lang ',langs)
        (let ((name ',(thread-last
                        (setup-get 'mode)
                        (symbol-name)
                        (string-remove-suffix "-mode"))))
          (add-to-list 'org-src-lang-modes
                       (cons (if (stringp lang)
                                 lang
                               (string-remove-suffix "-ts" name))
                             (intern name))))))))

:org-template

(eval-when-compile
  (define-setup-macro
   :org-template (file)
   "Load templates from the Org file."
   `(when (or (eq t akirak/enabled-status-tags)
              (memq 'personal akirak/enabled-status-tags))
      (add-hook ',(setup-get 'hook)
                (lambda () (akirak-org-dog-use-templates ,file))))))

:package-files

(defvar akirak-consult-package-files nil)
(defvar akirak-project-vc-extra-root-markers nil
  "Swap for `project-vc-extra-root-markers'.

`project-vc-extra-root-markers' slows down Emacs in many ways, so I
prefer keeping it empty throughout most of the time. Use
`akirak-project-with-extra-vc-root-markers' macro to explicitly declare
when you need the extra root markers.")

(eval-when-compile
  (define-setup-macro
   :package-files (&rest filenames)
   "Define file names of package files."
   `(dolist (filename ',filenames)
      (add-to-list 'akirak-consult-package-files filename)
      (add-to-list 'akirak-project-vc-extra-root-markers filename))))

:project-roots

(eval-when-compile
  (define-setup-macro
   :project-roots (&rest globs)
   (dolist (glob globs)
     (add-to-list 'akirak-project-vc-extra-root-markers glob))))

:reformatters

(eval-when-compile
  (define-setup-macro
   :reformatters (&rest entries)
   "Define reformatters."
   (let ((feature (setup-get 'feature)))
     (macroexp-progn
      (mapcar (pcase-lambda (`(,name . ,args))
                `(reformatter-define ,name ,@args))
              entries)))))

:repeat

(eval-when-compile
  (define-setup-macro
   :repeat (keymap &rest commands)
   "Set the repeat map of commands."
   :indent 1
   (dolist (cmd commands)
     (put cmd 'repeat-map keymap))))

:set

(eval-when-compile
  (define-setup-macro
   :set (&rest args)
   "Set the default values of variables."
   `(setq-default ,@args)))

Generally speaking, setopt is preferred over setq, but it slows down the startup performance.

:status

By default, settings inside :status clauses are not loaded.

(defvar akirak/enabled-status-tags nil)

(eval-when-compile
  (define-setup-macro :status (tag &rest progn)
    "Conditionally expand the macro."
    :indent 1
    (when (or (eq t akirak/enabled-status-tags)
              (memq tag akirak/enabled-status-tags))
      (macroexp-progn progn))))

Performance

benchmark-init

Benchmarks for require and load calls https://github.com/dholm/benchmark-init-el

(setup (:package benchmark-init)
  (:require benchmark-init)
  (add-hook 'after-init-hook 'benchmark-init/deactivate))

gcmh

the Garbage Collector Magic Hack

(setup (:package gcmh)
  (:hook-into after-init-hook)
  (:set gcmh-verbose init-file-debug
        gcmh-high-cons-threshold (* 128 1024 1024)))

Supported systems

os-release

(defun akirak/os-release ()
  (when (file-readable-p "/etc/os-release")
    (with-temp-buffer
      (insert-file-contents "/etc/os-release")
      (let (result)
        (while (re-search-forward (rx bol (group (+ (any "_" upper)))
                                      "=")
                                  nil t)
          (push (cons (match-string 1)
                      (replace-regexp-in-string
                       "\"" ""
                       (buffer-substring (point) (pos-eol))))
                result))
        result))))

(let ((alist (akirak/os-release)))
  (defconst akirak/os-id
    (cdr (assoc "ID" alist)))
  (defconst akirak/os-pretty-name
    (cdr (assoc "PRETTY_NAME" alist))))

Interacting with the underling system

(defcustom akirak/system-leave-hook nil
  "Hook to run when the user leaves the computer."
  :type 'hook)

(defun akirak/system-leave-hook ()
  ;; It may be better to run the hooks outside of any project context, but I
  ;; haven't found any actual situation that needs it yet.
  (run-hook-wrapped
   'akirak/system-leave-hook
   (lambda (fn)
     (condition-case err
         (funcall fn)
       (error
        (message "Error while running %s as part of akirak/system-leave-hook: %s"
                 fn err))))))

Specific systems

(defalias 'akirak/wsl-p #'akirak-wsl-p)

Custom conventions

Prefix for mode-specific commands

(defcustom akirak/mode-prefix-key "C-,"
  "Prefix for mode-specific keybindings."
  :type 'string)

<f12> as a prefix for miscellaneous commands

I use <f12> as a prefix for miscellaneous keybindings on the global map.

;; NOTE: I am currently not using which-key, so this should not be loaded.
(with-eval-after-load 'which-key
  (pcase-dolist (`(,key . ,description)
                 '(("a" . "ai")
                   ("c" . "capture")
                   ("c f" . "frame")
                   ("c s" . "screenshot")
                   ("c r" . "record screen")
                   ("d" . "disk")
                   ("e" . "emacs")
                   ("g" . "forge")
                   ("n" . "nix")
                   ("s" . "system")
                   ("S" . "secrets")))
    (which-key-add-keymap-based-replacements
      global-map (concat "<f12> " key) description)))

C-z as a prefix for session commands

(define-prefix-command 'akirak/c-z-map)
;; C-z is bound to suspend-frame by default, but I won't use it anyway
(keymap-global-set "C-z" 'akirak/c-z-map)

Key translation map

(setup key-translation-map
  (:status opinionated
    (keymap-global-unset "M-r")
    (keymap-set key-translation-map "M-r" "C-x r")

    (keymap-set key-translation-map "C-9" "C-x x")))

Window management

(defcustom akirak/display-popup-window-function #'pop-to-buffer
  "Function used to display popup windows."
  :type 'function)

Macro packages

el-patch

Future-proof your Elisp

(setup (:package el-patch))

Built-ins

abbrev

(setup abbrev
  (:set save-abbrevs nil)
  (:status personal
    (:when-loaded
      (:hook-into git-commit-mode
                  vc-git-log-edit-mode
                  markdown-mode
                  org-mode)
      (define-abbrev-table 'global-abbrev-table
        '(("wip" "WIP")
          ("fixme" "FIXME")
          ("afaik" "AFAIK")
          ("imo" "IMO")
          ("imho" "IMHO")
          ;; Common mistypes
          ("teh" "the")
          ("ort" "org")
          ("meang" "meant"))))))

autoinsert

(setup autoinsert
  (:set auto-insert 'other
        auto-insert-query nil)
  (:when-loaded
    ;; Delete the default template for HTML.
    (delete (assq 'html-mode auto-insert-alist) auto-insert-alist))
  (:with-mode auto-insert-mode
    (:hook-into after-init-hook)))

autorevert

(setup autorevert
  (:set auto-revert-avoid-polling t)
  (:with-mode global-auto-revert-mode
    (:hook-into after-init-hook)))

bindings

(setup bindings
  ;; Exclude global-mode-string from mode-line-misc-info.
  ;; See the settings for mini-modeline.
  (:set mode-line-misc-info nil))

bookmark

(setup bookmark
  (:set bookmark-save-flag t
        bookmark-sort-flag 'last-modified)

  (defun akirak/delete-bookmark-to-here ()
    "Delete a bookmark record to the current location, if any"
    (interactive)
    (bookmark-maybe-load-default-file)
    (cl-flet
        ((remk
           (record)
           (thread-last
             (cdr record)
             (seq-filter (pcase-lambda (`(,key . ,alist))
                           (memq key '(filename
                                       handler
                                       front-context-string))))
             (seq-sort-by (lambda (record)
                            (symbol-name (car record)))
                          #'string<))))
      (let ((this (bookmark-make-record)))
        (when-let* ((record (seq-find (lambda (record)
                                      (equal (remk record) (remk this)))
                                    bookmark-alist)))
          ;; TODO This seem to be ineffective on bookmarks created using org-bookmark-heading.
          (bookmark--remove-fringe-mark
           (bookmark-get-bookmark (car record) 'noerror))
          (bookmark-delete (car record))
          (message "Deleted \"%s\"" (car record)))))))

browse-url

(setup browse-url
  ;;    (:org-open "\\.x?html?\\'" browse-url)

  (:status personal
    (advice-add 'browse-url-can-use-xdg-open
                :override #'akirak-open-can-use-default-program)
    (advice-add 'browse-url-xdg-open
                :override #'akirak-open-default)

    (:set browse-url-handlers `((,(rx bos "http" (?  "s") "://"
                                      (or "localhost"
                                          (and (+ digit) (* "." (+ digit))))
                                      (or (any ":/") eos))
                                 . akirak-browse-url-private-url)
                                ;; Some web sites don't support alternative
                                ;; browsers well. I don't blame those services.
                                ;; It would be sometimes necessary to rely on
                                ;; non-standard browser technologies in order to
                                ;; implement an advanced user experience on web.
                                ;; Instead of avoiding those services entirely,
                                ;; I will force use of a chromium-compatible
                                ;; browser only in specific web sites to keep
                                ;; using my preferred browser elsewhere.
                                (,(rx bos "http" (?  "s") "://"
                                      (or "airtable.com"
                                          "figma.com")
                                      (or "/" eos))
                                 . akirak-browse-url-chromium-default)))))

buffer.c

(setup buffer
  (:set buffer-file-coding-system 'utf-8
        fill-column 80
        indicate-empty-lines t
        ;; In some major modes, you should turn on truncate-lines.
        ;; They should be configured alongside individual modes.
        truncate-lines nil)
  (:with-mode shr-mode
    (:local-set truncate-lines t))

  ;; A more lightweight version of midnight
  (run-with-idle-timer
   600 nil
   (defun akirak/cleanup-buffers ()
     (dolist (buffer (buffer-list))
       (when (and (derived-mode-p 'dired-mode 'special-mode)
                  (not (file-directory-p (buffer-local-value
                                          'default-directory buffer))))
         (message "Kill buffer %s as the directory does not exist" buffer)
         (kill-buffer buffer))))))

Line spacing

;; buffer.c
(setup line-spacing
  (:with-mode (org-mode markdown-mode)
    (:local-set line-spacing 0.5))
  (:with-mode (Help-mode helpful-mode Info-mode)
    (:local-set line-spacing 0.3))
  (:with-mode (nov-mode eww-mode)
    (:local-set line-spacing 0.4)))

Tab width

(setup tab-width
  (:set tab-width 2)
  (:with-mode (org-mode)
    ;; `tab-width' must be set to 8 in `org-mode', and there is no choice.
    (:local-set tab-width 8))
  (:with-mode (emacs-lisp-mode)
    (:local-set tab-width 8))
  (:with-mode (makefile-mode zig-mode zig-ts-mode)
    (:local-set tab-width 4))
  (:with-mode (js-mode typescript-mode sh-mode python-mode)
    (:local-set tab-width 2)))

calc

(setup calc
  (:set calc-kill-line-numbering nil)
  (:global-keymap "<f12> c c" #'calc))

calendar

(setup calendar
  (add-to-list 'display-buffer-alist
               '((major-mode . calendar-mode)
                 (display-buffer-in-side-window)))

  (:global-keymap "C-z m"
           (defun akirak/calendar (&optional arg)
             (interactive "P")
             (if (and (derived-mode-p 'org-mode)
                      (bound-and-true-p org-dog-file-mode)
                      (memq (object-class (org-dog-buffer-object))
                            '(org-dog-datetree-file
                              org-dog-facade-datetree-file)))
                 (org-reverse-datetree-calendar)
               (calendar arg)))))

callproc.c

(setup callproc
  (:only-if (eq system-type 'windows-nt))
  (:set shell-file-name (executable-find "bash")))

compile

(setup compile
  (:set compilation-ask-about-save nil
        compilation-save-buffers-predicate #'save-some-buffers-root
        compilation-auto-jump-to-first-error nil
        compilation-scroll-output t
        compilation-environment '("TERM=xterm-256color"))

  (:global-keymap "<f9>" #'recompile)

  (:set compilation-error-regexp-alist
        ;; This is a fallback value. The value may be replaced with a
        ;; command-specific value if `akirak-compile-auto-error-mode ' is turned
        ;; on.
        `((,(rx word-start
                (group (any alpha "._/") (* (any "-_./[]_" alnum)))
                ":" (group (+ digit))
                (optional ":" (group (+ digit)))
                (or ":" word-end))
           1 2 3)))

  ;; This code has been stolen from somewhere. I don't remember where, but the
  ;; same code can be found in many repositories on GitHub.
  (add-hook 'compilation-start-hook #'akirak/xterm-color-compilation-start)
  (defun akirak/xterm-color-compilation-start (proc)
    ;; We need to differentiate between compilation-mode buffers
    ;; and running as part of comint (which at this point we assume
    ;; has been configured separately for xterm-color)
    (when (eq (process-filter proc) 'compilation-filter)
      ;; This is a process associated with a compilation-mode buffer.
      ;; We may call `xterm-color-filter' before its own filter function.
      (set-process-filter
       proc
       (lambda (proc string)
         (funcall 'compilation-filter proc
                  (xterm-color-filter string)))))))

completion-preview

(setup completion-preview
  (:hook-into corfu-mode-hook)
  (:with-map completion-preview-active-mode-map
    (:keymap "C-j" #'completion-preview-insert)))

custom

The following variable defines variables that can be saved to custom-file:

(custom-declare-group
 'akirak/local
 (mapcar
  (lambda (sym)
    (list sym 'custom-variable))
  '(auth-sources                        ; Can be machine-dependent
    org-agenda-span                     ; Can be dependent on the work context
    ;; Work context
    user-full-name
    user-mail-address
    bookmark-default-file
    org-memento-workhour-alist
    org-memento-file
    org-memento-policy-file
    send-mail-function
    smtpmail-smtp-server
    smtpmail-stream-type
    smtpmail-smtp-service
    akirak-git-clone-root
    nix3-flake-clone-root
    akirak-log-private-file
    akirak-org-clock-history-threshold
    akirak-worktree-directories
    akirak-org-log-file
    akirak/font-height
    akirak/org-memento-export-directory
    ;; Dynamic
    safe-local-variable-values))
 "List of variables I save to custom-file.")

(defun akirak/customize-local ()
  "Configure host-local custom variables."
  (interactive)
  (dolist (x (get 'akirak/local 'custom-group))
    (pcase x
      ((and `(,sym custom-variable)
            (guard (not (symbol-file sym))))
       (let ((name (symbol-name sym)))
         (catch 'loaded
           (while (string-match (rx bos (group (+ anything)) "-") name)
             (setq name (match-string 1 name))
             (when (require (intern name) nil t)
               (throw 'loaded t))))))))
  (require 'cus-edit)
  (customize-group 'akirak/local))

The other variables must not be saved, and they should be put in configuration:

(setup custom
  (:global-keymap "<f12> e v" #'customize-variable)
  (:global-keymap "<f12> e o" #'customize-variable-other-window)
  (:global-keymap "<f12> e g" #'customize-group)
  (:status personal
    ;; Don't allow saving a variable that is not included in the whitelist
    (advice-add 'custom-variable-mark-to-save
                :before
                (defun akirak/customize-save-variable-check (widget)
                  (unless (memq (widget-value widget)
                                (mapcar #'car (get 'akirak/local 'custom-group)))
                    (error "Variable %s should not be saved to custom-file. \
See akirak/custom-variable-whitelist"
                           (widget-value widget)))))))

delsel

(setup delsel
  (:with-mode delete-selection-mode
    (:hook-into after-init-hook)))

desktop

(setup desktop
  (:when-loaded
    ;; Use `desktop-after-read-hook' to display a dashboard.
    (add-hook 'desktop-globals-to-save 'desktop-after-read-hook)))

dired

(setup dired
  (:set dired-recursive-copies 'always
        dired-recursive-deletes 'top
        dired-auto-revert-buffer t
        dired-listing-switches "-alh --time-style=long-iso")
  (:mode-repl akirak-shell-new-other-window))

display-fill-column-indicator

(setup display-fill-column-indicator
  (add-hook 'after-init-hook #'global-display-fill-column-indicator-mode))

edebug

(setup edebug
  (:global-keymap "<f12> e r" #'edebug-remove-instrumentation))

ediff

(setup ediff
  (:set ediff-split-window-function #'split-window-horizontally
        ediff-prepare-buffer-hook
        (defun akirak/ediff-prepare-buffer ()
          (when (derived-mode-p 'org-mode)
            (if (fboundp 'org-fold-show-all)
                (org-fold-show-all)
              (message "akirak/ediff-prepare-buffer: Function `org-fold-show-all' is not bound"))))))

ediff-wind

(setup ediff-wind
  (:set ediff-window-setup-function #'ediff-setup-windows-plain))

editfns.c

(setup editfns.c
  (defmacro akirak/def-char-insert-command (char name)
    `(defun ,(intern (format "akirak/insert-%s" name)) (n)
       (interactive "P")
       (self-insert-command (or n 1) ,char)))
  (:global "C-x 8 2" (akirak/def-char-insert-command 11834 two-em-dash))

  ;; Useful for working with code in a tree-sitter mode
  (defun akirak/append-char-to-previous-thing (char)
    (interactive "c")
    (save-excursion
      (if (re-search-backward (rx (not (any space))) nil t)
          (insert-char char)
        (user-error "No target location"))))
  (:global "C-c h" #'akirak/append-char-to-previous-thing))

editorconfig

EditorConfig Emacs Plugin https://github.com/editorconfig/editorconfig-emacs#readme

(setup editorconfig)

It is required only in specific projects, so I won’t turn on the mode by default.

eldoc

(setup eldoc
  (:with-hook turn-on-eldoc-mode
    (:hook-into emacs-lisp-mode))

  ;; Bind akirak-eldoc-show-buffer instead
  ;; (:global-keymap "C-c e" #'eldoc-doc-buffer)

  (:set eldoc-documentation-strategy 'eldoc-documentation-compose))

elec-pair

(setup elec-pair
  (:with-mode electric-pair-mode
    (:hook-into after-init-hook)))

While the mode is generally useful, the exception is lispy-mode, which overrides self-insert-command and conflicts with the features of the package.

electric

The built-in electric package provides the following modes:

[ ] electric-indent-mode: Use major-mode specific indentation functions instead?
[ ] electric-layout-mode: It may be useful in some programming modes
[ ] electric-quote-mode: Maybe I’ll turn it on in some specific projects

(setup electric)

elisp-mode

(setup elisp-mode
  (:with-mode emacs-lisp-mode
    (:huan
      ("eval-after-load" "with-eval-after-load")
      ("add-hook" "remove-hook")
      ("advice-add" "advice-remove"))
    (:hook outline-minor-mode)
    (:local-set imenu-generic-expression
                (append lisp-imenu-generic-expression
                        `(("Misc"
                           ,(rx bol "("
                                (or (and "c" (not (any "l")))
                                    (any "ab" "d-z"))
                                (* (any "-" alnum))
                                "-"
                                "def" (+ (not (any space)))
                                (+ (any blank))
                                (group (+ (not (any space control "\n()")))))
                           1)
                          ("Config"
                           "^(\\(?:setup\\|use-package\\)[[:blank:]]+\\_<\\([^[:space:]]+\\)"
                           1)))))

  (:with-mode lisp-data-mode
    (:file-match "/recipes/[-a-z0-9]+\\'")
    (:org-src-lang "tempo"))

  (:auto-insert
   ("\\.dir-locals\\(?:-2\\)?\\.el\\'"
    . (> ";;; Directory Local Variables\n"
         ";;; For more information see (info \"(emacs) Directory Variables\")\n\n"
         "((org-mode . ((gac-debounce-interval . 180)\n"
         "              (eval . (git-auto-commit-mode t)))))'"))
   ("-tests?\\.el\\'" . (> ";;; -*- lexical-binding: t -*-\n\n"
                           "(require 'buttercup)\n"
                           "(require '" (replace-regexp-in-string
                                         "-tests?\\'" ""
                                         (file-name-base (buffer-file-name)))
                           ")\n\n"
                           _ "\n\n"
                           "(provide '" (file-name-base (buffer-file-name)) ")\n"))
   ("\\.el\\'" . (> ";;; "
                    (file-name-nondirectory (or buffer-file-name (buffer-name)))
                    " --- " _
                    " -*- lexical-binding: t -*-\n"
                    "\n\n\n"
                    "(provide '"
                    (file-name-base (or buffer-file-name (buffer-name)))
                    ")\n"
                    ";;; "
                    (file-name-nondirectory (or buffer-file-name (buffer-name)))
                    " ends here"))
   ("/recipes/[-a-z0-9]+\\'" . (> "(" (file-name-nondirectory (buffer-file-name))
                                  " :fetcher github :repo \"" _ "\")")))

  (defun akirak/emacs-lisp-eval-buffer-or-load-file ()
    (interactive)
    (when (eq major-mode 'emacs-lisp-mode)
      (if buffer-file-name
          (load-file buffer-file-name)
        (eval-buffer)))))

eww

(setup eww
  (:also-load shr-tag-pre-highlight)
  (:with-hook eww-after-render-hook
    (:hook eww-readable
           visual-line-mode))
  (:keymap "C-c C-n" #'outline-next-heading
           "C-c C-p" #'outline-previous-heading
           "^"
           (defun akirak/eww-directory-up ()
             (interactive nil eww-mode)
             (let* ((url (eww-current-url))
                    (urlobj (url-generic-parse-url url))
                    (filename (url-filename urlobj)))
               (when (string-match-p "?" (car (url-path-and-query urlobj)))
                 (user-error "URL contains a query, so this command won't work"))
               (unless filename
                 (error "url-filename is nil"))
               (when (pcase (file-name-base filename)
                       (""
                        (setf (url-filename urlobj)
                              (file-name-directory (directory-file-name filename))))
                       ((rx bol "index" (or "." eol))
                        (let ((dir (file-name-directory (directory-file-name
                                                         (file-name-directory filename)))))
                          (if (equal (url-type urlobj) "file")
                              (let ((basename (file-name-base filename)))
                                (setf (url-filename urlobj)
                                      (concat (or (locate-dominating-file dir basename)
                                                  (user-error "No file named %s in ancestors"
                                                              basename))
                                              (file-name-base filename))))
                            (setf (url-filename urlobj)
                                  dir))))
                       (_
                        (setf (url-filename urlobj)
                              (file-name-directory filename))))
                 (eww (url-recreate-url urlobj)))))))

executable

(setup executable
  (add-hook 'after-save-hook #'executable-make-buffer-file-executable-if-script-p))

ffap

(setup ffap
  (:set ffap-file-finder (defun akirak/ffap-file-finder (file)
                           (if (akirak/ffap-prefer-other-window-p file)
                               (find-file-other-window file)
                             (find-file file)))
        ffap-directory-finder (defun akirak/ffap-directory-finder (dir)
                                (if (akirak/ffap-prefer-other-window-p dir t)
                                    (dired-other-window dir)
                                  (dired dir))))

  (defun akirak/ffap-prefer-other-window-p (file &optional dirp)
    ;; If not visiting a file buffer directly, prefer other window.
    (not (and (buffer-file-name)
              ;; If not visiting a file in the same project, prefer other
              ;; window.
              (equal (when-let* ((pr (project-current nil
                                                      default-directory)))
                       (project-root pr))
                     (when-let* ((pr (project-current nil
                                                      (if dirp
                                                          file
                                                        (file-name-directory file)))))
                       (project-root pr))))))

  (:global-keymap "C-c f" (defun akirak/ffap (&optional arg)
                            (interactive "P")
                            (if-let* ((window (and (numberp arg)
                                                   (akirak-window--other-window nil arg))))
                                (progn
                                  (display-buffer-override-next-command
                                   `(lambda (buffer _)
                                      (window--display-buffer buffer ,(selected-window)
                                                              'reuse)))
                                  (with-selected-window window
                                    (akirak-avy-ffap)))
                              (if arg
                                  (akirak-avy-ffap)
                                (ffap))))))

fileio.c

(setup fileio
  (:set delete-by-moving-to-trash t))

filelock.c

(setup filelock
  ;; lock files will kill `npm start'
  (:set create-lockfiles nil))

files

(setup files
  (:set backup-by-copying t
        backup-directory-alist
        `(("." . ,(locate-user-emacs-file "backup/")))
        delete-old-versions t
        version-control t
        view-read-only t
        auto-mode-case-fold nil
        require-final-newline t
        remote-file-name-inhibit-delete-by-moving-to-trash t
        ;; pkgs/top-level/all-packages.nix in nixpkgs: 1.5 MB
        large-file-warning-threshold (* 1024 1024 2))

  (:when-loaded
    (:set locate-dominating-stop-dir-regexp
          (rx-to-string `(or (regexp ,locate-dominating-stop-dir-regexp)
                             ;; Prevent scanning of directories with extensive
                             ;; entries.
                             (and bol "/nix/store/" (+ (any "-._" alnum)) "/" eol))))

    ;; Based on https://lonely.town/@jvillasante@hachyderm.io/110232974766557148
    (add-to-list 'backup-directory-alist
                 (cons (rx bos (or "/tmp/"
                                   "/dev/shm/"
                                   "/run/"))
                       nil)))

  (:set find-sibling-rules
        (let ((basename (rx (group (+ (not (any "/")))))))
          `((,(concat basename "\\.ml\\'") "\\1.mli")
            (,(concat basename "\\.mli\\'") "\\1.ml")
            (,(concat basename "\\.ex\\'") "\\1.html.heex")
            (,(concat basename "\\.html\\.heex\\'") "\\1.ex")
            (,(concat basename "_test\\.go\\'") "\\1.go")
            (,(concat basename "\\.go\\'") "\\1_test.go"))))
  (keymap-set ctl-x-map "," #'find-sibling-file)

  (advice-add 'abort-if-file-too-large
              :before-while
              (defun akirak/ad-before-abort-if-file-too-large (_size
                                                               _op-type
                                                               filename &rest _)
                (not (string-match-p (rx (or ".org"
                                             ".pdf"
                                             ".epub")
                                         eos)
                                     filename))))

  (:status personal
    (let* (;; (mix-format '((eval . (mix-format-on-save-mode t))))
           ;; (prettier '((eval . (prettier-on-save-mode t))))
           (jq-format '((eval . (jq-format-on-save-mode t))))
           ;; (sqlformat '((eval . (sqlformat-on-save-mode t))))
           (lsp '((eval . (akirak/eglot-ensure-with-formatter))))
           (lsp-no-formatter '((eval . (akirak/eglot-ensure))))
           (flymake-eslint '((eval . (flymake-eslint-enable))))
           (ocamlformat '((eval . (ocamlformat-on-save-mode t))))
           (nixfmt '((eval . (nixfmt-on-save-mode t))))
           (zig-fmt '((eval . (zig-format-on-save-mode t))))
           (copilot '((eval . (copilot-mode t))))
           (default  `((astro-ts-mode . (,@lsp-no-formatter))
                       (css-mode . (,@lsp-no-formatter))
                       (elixir-ts-mode . (,@lsp))
                       (erlang-mode . (,@lsp-no-formatter))
                       (gleam-ts-mode . (,@lsp))
                       (go-ts-mode . (,@lsp))
                       (haskell-mode . (,@lsp))
                       (heex-ts-mode . (,@lsp))
                       (js-ts-mode . (,@lsp-no-formatter))
                       (json-ts-mode . (,@lsp-no-formatter))
                       (just-mode . (,@lsp-no-formatter))
                       (neocaml-mode . ((eval . (ocaml-eglot))))
                       (neocamli-mode . ((eval . (ocaml-eglot))))
                       (python-mode . (,@lsp))
                       (nix-ts-mode . (,@lsp-no-formatter ,@nixfmt))
                       (rust-ts-mode . (,@lsp))
                       (svelte-mode . (,@lsp ,@flymake-eslint))
                       (tsx-ts-mode . (,@lsp-no-formatter))
                       (tuareg-mode . ((eval . (ocaml-eglot))
                                       ,@ocamlformat))
                       (typescript-ts-mode . (,@lsp-no-formatter))
                       (web-mode . (,@lsp))
                       (zig-mode . (,@lsp-no-formatter ,@zig-fmt))
                       (zig-ts-mode . (,@lsp-no-formatter ,@zig-fmt))
                       ("renovate.json" . (,@jq-format)))))
      (dir-locals-set-class-variables
       'personal
       `((nix-ts-mode . (,@lsp-no-formatter ,@nixfmt))
         (org-mode . (eval . (jinx-mode 1)))))
      (dir-locals-set-class-variables
       'default
       default)
      (dir-locals-set-class-variables
       'foss
       (cons `(prog-mode . (,@copilot))
             default)))
    (dir-locals-set-directory-class "~/config/" 'personal)
    (dir-locals-set-directory-class "~/emacs-config/" 'personal)
    (dir-locals-set-directory-class "~/work2/learning/" 'default)
    (dir-locals-set-directory-class "~/work2/foss/" 'foss)

    (:set ignored-local-variable-values
          ;; github:melpa/melpa
          '((eval . (and buffer-file-name
                         (not (eq major-mode 'package-recipe-mode))
                         (or (require 'package-recipe-mode nil t)
                             (let ((load-path (cons "../package-build" load-path)))
                               (require 'package-recipe-mode nil t)))
                         (package-recipe-mode)))))))

Notes:

Use akirak-files-ensure-abbrev-list to update directory-abbrev-alist. (see akirak).
For now, I won’t use derived-mode-add-parents to turn on the extra derived mode check.

find-func

(setup find-func
  (:global-keymap "C-x M-l" #'find-library)
  (add-hook 'find-function-after-hook
            (defun akirak/find-function-focus ()
              (recenter-top-bottom 0))))

flymake

(setup flymake
  (:set flymake-show-diagnostics-at-end-of-line nil)
  (:keymap "M-g M-n" #'flymake-goto-next-error
         "M-g M-p" #'flymake-goto-prev-error))

fns.c and xfns.c

(setup fns
  (:set use-dialog-box nil
        use-short-answers t))

(setup xfns
  (:set x-gtk-use-system-tooltips nil))

frame

(setup frame
  (blink-cursor-mode -1)
  (set-frame-parameter nil 'alpha '(98 . 96))

  (:set window-divider-default-places 'bottom-only
        window-divider-default-bottom-width 1)
  (if (daemonp)
      (add-hook 'server-after-make-frame-hook #'window-divider-mode)
    (window-divider-mode 1))

  (add-hook 'after-delete-frame-functions
            (defun akirak/prepare-kill-emacs-after-delete-frame (_frame)
              (when (and server-clients
                         (= 1 (length (frame-list))))
                ;; Run a subset of kill-emacs-hook to persist data.
                (let ((sym (gensym "kill-emacs-hook")))
                  (set sym (remove 'server-force-stop
                                   (default-value 'kill-emacs-hook)))
                  (run-hooks sym)))))

  (defconst akirak/base-frame-title-format
    '(" - GNU Emacs"
      (emacs-version
       (" " emacs-version))
      (twist-configuration-revision
       (" @ " twist-configuration-revision))
      (akirak/emacs-profile-name
       (" (" akirak/emacs-profile-name ")"))
      (system-name
       (" on " system-name))
      (akirak/os-pretty-name
       (", " akirak/os-pretty-name))))

  (defconst akirak/default-frame-title-format
    (cons '(org-memento-current-block
            org-memento-frame-title-format
            "%b")
          akirak/base-frame-title-format))

  (setq org-clock-frame-title-format
        (cons '(t org-mode-line-string)
              akirak/base-frame-title-format))

  (setq frame-title-format akirak/default-frame-title-format))

help

(setup help
  (:set help-window-keep-selected t)
  (keymap-set help-map "C-h" nil))

hippie-exp

(setup hippie-exp
  (:global-keymap "C-M-/" #'hippie-expand)
  (:set hippie-expand-try-functions-list
        '(try-complete-file-name-partially
          try-complete-file-name
          try-expand-dabbrev
          try-expand-dabbrev-visible
          try-expand-dabbrev-from-kill)))

hl-line

(setup hl-line
  (:with-mode hl-line-mode
    (:hook-into prog-mode-hook
                text-mode-hook)))

image

(setup image
  (:nixpkgs "graphicsmagick")
  (:set image-use-external-converter t))

image-file

(setup image-file
  ;; `file-name-handler-alist' is emptied in early-init.el and restored in
  ;; `after-init-hook'. `auto-image-file-mode' should be loaded after the alist
  ;; has been restored.
  (add-hook 'after-init-hook #'auto-image-file-mode 70))

imenu

(setup imenu
  (defun akirak/set-imenu-max-item-width ()
    (setq imenu-max-item-length (min (or (frame-text-width) 80)
                                     120)))

  (if (daemonp)
      (add-hook 'server-after-make-frame-hook #'akirak/set-imenu-max-item-width)
    (akirak/set-imenu-max-item-width)))

indent

(setup indent
  (:set tab-always-indent 'complete)

  ;; Unbind `tab-to-tab-stop'
  (keymap-global-unset "M-i"))

indent.c

(setup indent
  (:set indent-tabs-mode nil)

  (defun akirak/turn-on-indent-tabs-mode ()
    (interactive)
    (setq indent-tabs-mode 1))

  (dolist (mode-hook '(makefile-mode-hook go-ts-mode-hook cue-mode-hook))
    (add-hook mode-hook 'akirak/turn-on-indent-tabs-mode)))

isearch

(setup isearch
  (:set isearch-allow-scroll t
        isearch-lazy-count t)
  (:keymap "M-q" #'isearch-query-replace
           "M-RET" (defun akirak/isearch-quit-with-region ()
                     (interactive)
                     (pcase-exhaustive isearch-match-data
                       (`(,begin ,end ,_)
                        (isearch-exit)
                        (goto-char begin)
                        (push-mark)
                        (goto-char end)
                        (activate-mark))))))

jit-lock

(setup jit-lock
  (:set jit-lock-defer-time 0))

js-mode

(setup js-mode
  (:file-match "\\.c?js\\'")
  (:set js-indent-level 2))

keymap.c

(setup keymap.c
  (:status opinionated
    (:with-map minibuffer-local-map
      (:keymap "C-u" #'backward-kill-sentence))))

mailcap

(setup mailcap
  (:when-loaded
    (advice-add 'mailcap-parse-mimetypes
                :around
                (defun akirak/ad-around-mailcap-parse-mimetypes (orig &rest args)
                  (require 'akirak-mime)
                  (if (and (not args)
                           (not mailcap-mimetypes-parsed-p))
                      (or (akirak-mime-set-mime-extensions)
                          (funcall orig))
                    (apply orig args))))
    (advice-add 'mailcap-parse-mailcaps
                :around
                (defun akirak/ad-around-mailcap-parse-mailcaps (orig &rest args)
                  (require 'akirak-mime)
                  (if (and (not args)
                           (not mailcap-parsed-p))
                      (or (akirak-mime-set-mime-extensions)
                          (funcall orig))
                    (apply orig args))))))

menu-bar

(setup menu-bar
  (:status opinionated
    (:global-keymap "<f12> <f12>" #'toggle-debug-on-error)))

minibuf.c

Use the recommended settings for vertico.

(setup minibuf.c
  ;; Do not allow the cursor in the minibuffer prompt
  (setq minibuffer-prompt-properties
        '(read-only t cursor-intangible t face minibuffer-prompt))
  (add-hook 'minibuffer-setup-hook #'cursor-intangible-mode)

  (setq read-extended-command-predicate #'command-completion-default-include-p)

  ;; Enable recursive minibuffers
  (setq enable-recursive-minibuffers t))

Resources:

https://github.com/minad/vertico#configuration

minibuffer

(setup minibuffer
  (:set completion-category-defaults nil
        completion-category-overrides
        '((file (styles partial-completion))
          (url (styles substring))))

  (defun akirak/minibuffer-tilde ()
    "During `find-file', replace the minibuffer input with the home directory."
    (interactive)
    (if minibuffer-completing-file-name
        (progn
          (delete-region (minibuffer-prompt-end) (point-max))
          (goto-char (point-max))
          (insert "~/"))
      (insert "~")))
  (keymap-set minibuffer-mode-map "~" #'akirak/minibuffer-tilde)

  (defun akirak/minibuffer-slash ()
    "During `find-file', replace the minibuffer input with the root directory."
    (interactive)
    (if (and minibuffer-completing-file-name
             (eq ?/ (char-after (1- (point)))))
        (let ((ident (file-remote-p (buffer-substring-no-properties
                                     (minibuffer-prompt-end) (point-max))
                                    'ident)))
          (delete-region (minibuffer-prompt-end) (point-max))
          (goto-char (point-max))
          (when ident
            (insert ident))
          (insert "/"))
      (insert "/")))
  (keymap-set minibuffer-mode-map "/" #'akirak/minibuffer-slash))

misc

(setup misc
  (:set duplicate-region-final-position -1)
  (:global-keymap "C-c d" #'duplicate-dwim))

mule

(setup mule-cmds
  (set-language-environment "UTF-8"))

mule-cmds

(setup mule-cmds
  ;; (add-hook 'set-language-environment-hook
  ;;           (defun akirak/post-set-language-environment ()
  ;;             "Turn off `flyspell-mode' depending on the language."
  ;;             (when (member current-language-environment
  ;;                           '("Japanese"))
  ;;               (flyspell-mode -1))))
  )

multisession

(setup multisession
  ;; Prefer sqlite backend for learning purposes
  (:set multisession-storage 'sqlite))

mwheel

(setup mwheel
  (:set mouse-wheel-tilt-scroll t))

nxml-mode

(setup nxml-mode
  (:file-match "\\.xml\\'"
               "\\.svg\\'")
  (:org-src-lang "xml" "svg"))

outline

(setup outline
  (:with-mode outline-minor-mode
    (:status opinionated
      (:keymap "M-RET" #'outline-insert-heading))))

paragraphs

(setup paragraphs
  (:set sentence-end-double-space nil))

paren

(setup paren
  (:with-mode show-paren-mode
    (:hook-into after-init-hook)))

pixel-scroll

(setup pixel-scroll
  (:only-if (version<= "29" emacs-version)
            (:with-mode pixel-scroll-precision-mode
              ;; TODO: Find a better way to hook the minor mode
              (:hook-into find-file-hook
                          eww-mode-hook
                          help-mode-hook))))

process.c

(setup process
  ;; Expand read-process-output-max for lsp-mode
  (:set read-process-output-max (* 1024 1024)))

profiler

(setup profiler
  (defun akirak/profiler-toggle ()
    (interactive)
    (require 'profiler)
    (if (profiler-running-p)
        (progn
          (profiler-report)
          (profiler-stop)
          (profiler-reset))
      (call-interactively #'profiler-start)))

  (:status opinionated
    (:global-keymap "<f12> e p" #'akirak/profiler-toggle)))

project

Operations on the current project

(setup project
  (:when-loaded
    (add-hook 'project-find-functions
              (defun akirak/project-nix-store-finder (dir)
                (save-match-data
                  (when (string-match (rx bol "/nix/store/" (+ (not (any "/"))) "/")
                                      dir)
                    `(nix-store ,(match-string 0 dir)))))
              t)
    (cl-defmethod project-root ((project (head nix-store)))
      (cadr project)))

  (:status opinionated
    (:when-loaded
      (:with-map ctl-x-map
        ;; Don't use c-x p for the prefix map.
        (:keymap-unset "p")
        ;; Rebind the key
        (:keymap "p" #'akirak-consult-project-file))
      (keymap-global-set "C-x M" project-prefix-map)

      (add-hook 'project-find-functions #'akirak-project-worktree-group-finder))))

prolog

(setup prolog
  (:file-match "\\.pl\\'"))

pulse

(setup pulse
  (:set pulse-momentary-iterations 10
        pulse-delay .2))

python

(setup python
  (:with-mode python-ts-mode
    (:mode-repl akirak/euporie-project)))

re-builder

(setup re-builder
  (:set reb-re-syntax 'rx)

  (advice-add 'reb-empty-regexp
              :override
              (lambda ()
                (cond ((reb-lisp-syntax-p) (el-patch-swap "'()" "`(and bol)"))
                      (t "")))))

recentf

(setup recentf
  (:hook-into after-init-hook)
  (:set recentf-max-saved-items 1000
        recentf-auto-cleanup 'never
        ;; Default value. Some packages add extra entries after the package is
        ;; loaded.
        recentf-exclude (list (concat "^" (regexp-opt (list "/nix/store/"
                                                            "/dev/shm/"
                                                            (abbreviate-file-name
                                                             user-emacs-directory))
                                                      :group)))))

register

(setup register
  (:set register-preview-delay 0.5))

repeat

(setup repeat
  (:hook-into after-init-hook)
  (:set repeat-echo-function #'ignore)

  ;; Based on a snippet from
  ;; https://karthinks.com/software/it-bears-repeating/#adding-a-hydra-like-prompt-to-repeat-mode
  ;; (advice-add 'repeat-post-hook :after #'repeat-help--which-key-popup)
  (defun repeat-help--which-key-popup ()
    (when (require 'which-key nil t)
      (if-let* ((keymap (or repeat-map
                            (repeat--command-property 'repeat-map))))
          (when (eq keymap 'diff-hl-command-map)
            (run-at-time
             which-key-idle-delay nil
             `(lambda ()
                (which-key--create-buffer-and-show
                 nil (symbol-value ',keymap)))))
        (which-key--hide-popup)))))

replace

(setup replace
  (:global-keymap "C-c o" #'occur))

savehist

(setup savehist
  (:hook-into after-init-hook))

This is a recommended setting for use with vertico. See https://github.com/minad/vertico#configuration.

saveplace

(setup saveplace
  (:with-mode save-place-mode
    (:hook-into after-init-hook)))

sgml-mode

(setup sgml-mode
  (:with-map html-mode-map
    ;; I don't use facemenu commands, so save M-o
    (:keymap-unset "M-o"))

  (:with-map sgml-mode-map
    (:keymap "C-j" #'newline-and-indent
             "<remap> <sgml-close-tag>" #'akirak-sgml-close-tag))

  (defun akirak-sgml-close-tag ()
    (interactive)
    (let ((tag (car (save-excursion
                      (sgml-get-context)))))
      (when (and tag (sgml-tag-p tag))
        (if (and (> (point) (sgml-tag-start tag))
                 (< (point) (sgml-tag-end tag)))
            (progn
              (goto-char (sgml-tag-end tag))
              (save-excursion
                (sgml-close-tag)))
          (sgml-close-tag))))))

shr

(setup shr
  (:set shr-bullet " ‣ "))

sh-script

(setup sh-script
  (:set sh-indentation 2))

simple

(setup simple
  (:set suggest-key-bindings nil
        what-cursor-show-names t
        ;; Don't auto-save remote files.
        remote-file-name-inhibit-auto-save t)

  (:global-keymap "<remap> <count-words-region>" #'akirak/count-words-dwim
                  "<remap> <delete-horizontal-space>" #'cycle-spacing
                  "<remap> <upcase-word>" #'upcase-dwim
                  "<remap> <downcase-word>" #'downcase-dwim
                  "<remap> <capitalize-word>" #'capitalize-dwim)

  ;; I often type this sequence unintensionally. I never use this command, so
  ;; just disable the keybinding.
  (:global-keymap "C-x C-n" nil)

  (:set kill-region-dwim 'emacs-word)
  ;; unix-word is too aggressive for editing file names. zsh has the better
  ;; default for this operation, so wait until Emacs implements it.
  ;;
  ;; (add-hook 'minibuffer-setup-hook
  ;;           (defun akirak/minibuffer-custom-setup ()
  ;;             (when minibuffer-completing-file-name
  ;;               (setq-local kill-region-dwim 'unix-word))))
  ;; Alternative to kill-region-dwim option
  (when (version< emacs-version "31")
    (:global-keymap "C-w" (defun akirak/kill-region-or-backward-kill-word (&optional arg)
                            "If a region is active, run `kill-region'. Otherwise, run `backward-kill-word'."
                            (interactive "p")
                            (if (region-active-p)
                                (kill-region (region-beginning) (region-end))
                              (backward-kill-word arg)))))

  (defun akirak/count-words-dwim ()
    (interactive)
    (save-restriction
      (when (derived-mode-p 'org-mode)
        (narrow-to-region (save-excursion
                            (org-back-to-heading)
                            (org-end-of-meta-data t)
                            (point))
                          (save-excursion
                            (org-end-of-subtree)
                            (when (looking-at (rx bol))
                              (end-of-line 0))
                            (point))))
      (call-interactively #'count-words)))

  (defun akirak/delete-zero-width-spaces (start end)
    "Delete zero-width spaces in the region."
    (interactive "r")
    (replace-regexp-in-region
     (format "[%s]+" (mapconcat #'char-to-string (list 8203 8288 8205 8204 65279)))
     "" start end))

  (defun akirak/kill-word-dwim (&optional arg)
    (interactive "P")
    (require 'thingatpt)
    (cond
     ((equal arg '(4))
      (when (looking-at (rx (+ blank)))
        (goto-char (match-end 0)))
      (let ((eol (line-end-position)))
        (kill-region (point)
                     (or (re-search-forward (rx (+ blank)) eol t)
                         eol))))
     ((looking-at (rx (syntax open-parenthesis)))
      (pcase-exhaustive (funcall show-paren-data-function)
        (`(,open-start ,_ ,_ ,close-end . ,_)
         (kill-region open-start close-end))))
     ((looking-at (rx (syntax string-quote)))
      (pcase-exhaustive (thing-at-point-bounds-of-string-at-point)
        (`(,begin . ,end)
         (kill-region begin end))))
     (t
      (kill-word arg))))

  (:with-map prog-mode-map
    (:keymap "<remap> <kill-word>" #'akirak/kill-word-dwim))

  (:status opinionated
    (:global-keymap "C-a"
                    (defun akirak/back-to-indentation-or-bol ()
                      (interactive)
                      (if (or (looking-at "^")
                              (string-match-p (rx (not (any space)))
                                              (buffer-substring-no-properties
                                               (line-beginning-position)
                                               (point))))
                          (back-to-indentation)
                        (beginning-of-line)))

                    "M-z" #'zap-up-to-char
                    "M-Z" #'zap-to-char)))

skeleton

(setup skeleton
  (:set skeleton-end-newline t)

  (defvar-local akirak/skeleton-local-positions nil)

  (add-hook 'skeleton-end-hook
            (defun akirak/skeleton-start ()
              (setq akirak/skeleton-local-positions
                    (cl-loop for xs
                             on skeleton-positions
                             collect (- (car xs)
                                        (or (cadr xs)
                                            skeleton-point))
                             into result
                             finally return (reverse result)))
              (when akirak/skeleton-local-positions
                (local-set-key [tab] #'akirak/skeleton-pop-positions))))

  (defun akirak/skeleton-pop-positions ()
    (interactive)
    (when-let* ((n (pop akirak/skeleton-local-positions)))
      (forward-char n)
      (if akirak/skeleton-local-positions
          (message "Remaining %d positions" (length akirak/skeleton-local-positions))
        (local-unset-key [tab])))))

smerge

(setup smerge
  (:global-keymap "C-c g u" #'smerge-keep-upper
           "C-c g l" #'smerge-keep-lower))

sqlite-mode

(setup sqlite-mode
  (:org-open "\\.sqlite3?\\'" sqlite-mode-open-file :file t))

startup

(setup startup
  (:set inihibit-startup-screen t
        inhibit-default-init t
        inhibit-startup-echo-area-message t
        initial-buffer-choice (lambda () (or (get-buffer "*dashboard*")
                                             (get-buffer "*Messages*")))
        initial-scratch-message nil
        initial-major-mode 'fundamental-mode))

*scratch* buffer is shown at startup. You can set initial-buffer-choice to a function or a buffer name depending on the context.

Initialization time

(add-hook 'emacs-startup-hook
          (defun akirak/show-init-time ()
            (message "Emacs initialized in %.3f sec with %d garbage collection(s)"
                     (float-time (time-subtract after-init-time before-init-time))
                     gcs-done)))

subr

(setup subr
  (:with-map ctl-x-x-map
    (:keymap "+" #'make-directory))
  (:status opinionated
    ;; (:global-keymap "C-h" 'backward-delete-char)
    ))

C-h is one of the sh-emulation bindings.

subword

(setup subword
  ;; (add-hook 'prog-mode-hook (defun akirak/enable-superword-mode ()
  ;;                             (superword-mode 1)))
  )

tab-bar

(setup tab-bar
  (:set tab-bar-auto-width-max '(350 25))

  (:with-map tab-prefix-map
    (:keymap "R" #'akirak/tab-bar-set-tab-name-from-org-clock))

  (defun akirak/tab-bar-set-tab-name-from-org-clock ()
    (interactive)
    (if-let* ((heading (when (org-clocking-p)
                         (org-entry-get (or org-clock-hd-marker
                                            org-clock-marker)
                                        "ITEM"))))
        (tab-bar-rename-tab heading)
      (user-error "Not clocking in")))

  ;; Not currently used.
  ;; (:set tab-bar-tab-name-function #'akirak/tab-bar-tab-name)
  ;; (:when-loaded
  ;;   (:also-load vc-git))
  (defun akirak/tab-bar-tab-name ()
    "An experimental function for determining the name of a tab."
    (let* ((buffer (window-buffer (or (minibuffer-selected-window)
                                      (and (window-minibuffer-p)
                                           (get-mru-window)))))
           (dir (buffer-local-value 'default-directory buffer))
           ;; project-current is slow, so use vc instead. For now, only
           ;; Git is supported
           (vc-root (vc-git-root dir)))
      (if (or (not vc-root)
              (buffer-local-value 'org-src-mode buffer)
              (buffer-base-buffer buffer))
          (buffer-name buffer)
        (format "%s:%s"
                (thread-first
                  (directory-file-name vc-root)
                  (file-name-nondirectory)
                  (truncate-string-to-width 12))
                (if (eq 'dired-mode (buffer-local-value 'major-mode buffer))
                    (file-relative-name dir vc-root)
                  (buffer-name buffer)))))))

tempo

(setup tempo
  (:set tempo-interactive t)

  (advice-add 'tempo-insert-prompt-compat
              :before
              (defun akirak/tempo-bind-tab (&rest _args)
                (local-set-key [tab] #'akirak/tempo-forward-mark)))

  (defun akirak/tempo-forward-mark ()
    (interactive)
    (unless (tempo-forward-mark)
      (local-unset-key [tab]))))

terminal.c

(setup terminal
  (:set ring-bell-function 'ignore))

thingatpt

(setup thingatpt
  (define-prefix-command 'akirak/thingatpt-map)
  (keymap-global-set "M-m" akirak/thingatpt-map)

  (defmacro akirak/thingatpt-def-region (thing)
    `(defun ,(intern (format "akirak/select-%s" thing)) ()
       (interactive)
       (pcase (bounds-of-thing-at-point ',thing)
         (`(,beg . ,end)
          (goto-char beg)
          (push-mark)
          (goto-char end)
          (activate-mark)))))

  (akirak/thingatpt-def-region sentence)
  (keymap-set akirak/thingatpt-map "s" #'akirak/select-sentence)
  (akirak/thingatpt-def-region paragraph)
  (keymap-set akirak/thingatpt-map "p" #'akirak/select-paragraph))

timer

(setup timer
  ;; Suspending may run after 5 minutes of idle, so the buffers should be saved
  ;; sooner than that.
  (run-with-idle-timer 240 nil
                       (defun akirak/save-all-buffers-non-interactively ()
                         (when (fboundp 'akirak-org-clock-snooze)
                           (akirak-org-clock-snooze 3))
                         (save-some-buffers 'force)))
  ;; Also run when the user explicitly leaves the computer.
  (add-hook 'akirak/system-leave-hook
            #'akirak/save-all-buffers-non-interactively
            50))

tooltip

(setup tooltip
  (tooltip-mode -1))

tramp

(setup tramp
  (:when-loaded
    ;; Based on https://lonely.town/@jvillasante@hachyderm.io/110232974766557148
    (add-to-list 'backup-directory-alist
                 (cons tramp-file-name-regexp nil))))

transient

Transient commands

(setup (:package transient)
  (autoload 'transient-define-prefix "transient" nil t))

Because transient is developed by the maintainer of magit, it is better to update them together. Thus I will explicitly install this package rather than using the built-in version.

treesit

(setup treesit)

vc-hooks

(setup vc-hooks
  (:set vc-follow-symlinks t
        vc-make-backup-files t))

view

(setup view
  (:set view-inhibit-help-message t)

  (:with-map view-mode-map
    ;; conflict with a binding in lispy-mode
    (:keymap-unset "d")
    (:keymap
     "<remap> <scroll-up-command>" #'View-scroll-half-page-forward
     "<remap> <scroll-down-command>" #'View-scroll-half-page-backward)))

warnings

(setup warnings
  (:set warning-minimum-level :error))

which-func

(setup which-func
  (:set which-func-non-auto-modes '(minibuffer-mode
                                    org-mode
                                    nov-mode))
  (add-hook 'after-init-hook #'which-function-mode))

whitespace

(setup whitespace
  (:set whitespace-style
        '(face trailing missing-newline-at-eof tab-mark))
  (:hook-into prog-mode
              markdown-mode
              conf-mode
              sgml-mode)

  (:status theme
    (:set whitespace-trailing
          '(((t (:underline (:color "firebrick"
                                    :style wave
                                    :position nil))))))))

windmove

(setup windmove
  (:status opinionated
    (add-hook 'after-init-hook
              (defun akirak/setup-windmove ()
                (windmove-default-keybindings 'control)))))

window

(setup window
  (:set recenter-positions '(top middle bottom))
  (:global-keymap "<f8>" #'window-toggle-side-windows)

  (:when-loaded
    (push 'akirak-window-fallback-reuse-window
          (car display-buffer-fallback-action)))

  ;; Delay setting of `switch-to-buffer-obey-display-actions' so initial buffers
  ;; are displayed using `switch-to-buffer'.
  (defun akirak/after-frame-window-setup ()
    ;; Enable display-buffer-alist in many unsupported functions.
    (setq switch-to-buffer-obey-display-actions t))
  (if (daemonp)
      (add-hook 'server-after-make-frame-hook #'akirak/after-frame-window-setup)
    (add-hook 'emacs-startup-hook #'akirak/after-frame-window-setup))

  (defun akirak/ad-no-obey-display-actions (orig &rest args)
    (let ((switch-to-buffer-obey-display-actions nil))
      (apply orig args)))
  (advice-add 'consult-buffer :around #'akirak/ad-no-obey-display-actions)
  (advice-add 'org-dog-find-file :around #'akirak/ad-no-obey-display-actions)
  ;; (advice-add 'org-src-switch-to-buffer
  ;;             :override
  ;;             (defun akirak/org-src-switch-to-buffer (buffer context)
  ;;               (unless (eq org-src-window-setup 'current-window)
  ;;                 (message "This function should be used only when
  ;; `org-src-window-setup' is \='current-window, but it is %s"
  ;;                          org-src-window-setup))
  ;;               (let ((switch-to-buffer-obey-display-actions nil))
  ;;                 (switch-to-buffer buffer))))

  (defun akirak/scroll-half-height (&optional window)
    (/ (1- (window-height (or window (selected-window)))) 2))

  ;; I use a normal keyboard, so it is hard to access cursor keys.
  (keymap-global-set "C-x 9" #'previous-buffer)
  (:repeat ctl-x-map previous-buffer)

  (:global-keymap
   ;; TODO: scroll-other-window and scroll-other-window-down
   "<remap> <scroll-up-command>"
   (defun akirak/scroll-half-page-forward (&optional arg)
     (interactive "P")
     (if (numberp arg)
         (scroll-up arg)
       (scroll-up (akirak/scroll-half-height))))
   "<remap> <scroll-down-command>"
   (defun akirak/scroll-half-page-backward (&optional arg)
     (interactive "P")
     (if (numberp arg)
         (scroll-down arg)
       (scroll-down (akirak/scroll-half-height))))))

window.c

(setup window
  (:set fast-but-imprecise-scrolling t
        scroll-preserve-screen-position t))

winner

(setup winner
  (:hook-into after-init-hook)
  (:when-loaded
    (cl-pushnew "*Calendar*" winner-boring-buffers))

  (:status opinionated
    (:global-keymap "<f7>" #'winner-undo
             "S-<f7>" #'winner-redo)))

woman

(setup woman
  (:global-keymap "<f1> M-m" #'woman))

word-wrap-mode

(setup word-wrap-mode
  (:with-mode word-wrap-whitespace-mode
    (:hook-into shr-mode)))

xdisp.c

(setup xdisp
  ;; I have never encountered a situation where I need to deal with R-L
  ;; direction so far
  (:set bidi-inhibit-bpa t
        bidi-display-reordering 'left-to-right
        bidi-paragraph-direction 'left-to-right
        scroll-conservatively 1))

Typography settings

Theme packages

modus-themes

Elegant, highly legible and customizable themes https://github.com/protesilaos/modus-themes

(setup (:package modus-themes)
  ;; See [[info:modus-themes#Override colors]]
  ;; and [[info:modus-themes#Customization Options]]
  (:set modus-operandi-palette-overrides
        '((bg-main "#e1d9c2")
          (fg-main "#333333")
          (bg-heading-1 bg-dim)
          (overline-heading-2 border))

        modus-themes-bold-constructs nil
        modus-themes-italic-constructs t
        modus-themes-paren-match '(bold intence)
        modus-themes-org-blocks 'gray-background
        modus-themes-disable-other-themes t

        modus-themes-links '(neutral-underline)

        modus-themes-headings
        '((1 . (medium variable-pitch 1.5))
          (2 . (rainbow variable-pitch 1.1))
          (4 . (variable-pitch))))

  (when (or window-system
            (daemonp))
    (require 'modus-themes)
    (load-theme 'modus-operandi :no-confirm)))

Font families

You need to install the fonts separately.

(defun akirak/enable-fonts (&optional value skip-check)
  (let ((families (font-family-list))
        (value (or value akirak/font-family-alist)))
    (pcase-dolist (`(,face ,family . ,plist) value)
      (if (or (member family families)
              skip-check)
          (if-let* ((fontset (plist-get plist :fontset)))
              (set-fontset-font fontset face family nil
                                (plist-get plist :add))
            (set-face-attribute face nil :family family))
        (message "Font family %s is not installed" family)
        ;; (delq (assq face value) value)
        ;; (set symbol value)
        ))))

(defcustom akirak/font-family-alist
  '((default "Cascadia Code")
    (fixed-pitch "Cascadia Code")
    (variable-pitch "Inter")
    (kana "Source Han Sans HC" :fontset t)
    (han "Source Han Sans HC" :fontset t)
    (emoji "Noto Color Emoji" :fontset t :add prepend)
    (symbol "Symbola" :fontset t :add append))
  "Alist of font families for faces."
  :type '(repeat (list symbol
                       string
                       (plist :inline t
                              :options
                              (((const :fontset)
                                (choice (const :tag "Default" t)
                                        (string :tag "Name of a fontset")))))))
  :set (lambda (symbol value)
         (set symbol value)
         (when (or window-system
                   (daemonp))
           (akirak/enable-fonts value (daemonp)))))

(when (daemonp)
  (add-hook 'server-after-make-frame-hook
            (defun akirak/server-set-fonts ()
              (akirak/enable-fonts nil t)
              (remove-hook 'server-after-make-frame-hook #'akirak/server-set-fonts))))

(eval-after-load 'outline
  (defun akirak/set-outline-families ()
    (when-let* ((family (cadr (assq 'variable-pitch akirak/font-family-alist))))
      (dolist (x '(outline-1
                   outline-2
                   outline-3
                   outline-4
                   outline-5
                   outline-6
                   outline-7
                   outline-8))
        (set-face-attribute x nil :family family)))))

(eval-after-load 'org
  (defun akirak/set-org-faces ()
    (set-face-attribute 'org-tag nil :inherit 'fixed-pitch)
    (set-face-attribute 'org-todo nil :inherit 'fixed-pitch)))

Font size and line spacing

Override font heights for certain faces.

I think it would be better to create my own theme, but I don’t have enough time for it.

(defcustom akirak/font-height 107
  "Default height of the font."
  :group 'akirak
  :type 'integer
  :set (lambda (sym value)
         (set sym value)
         (set-face-attribute 'default nil :height value)))

;; In Emacs 29.1, the default height of `variable-pitch-text' is 1.1, but it
;; should be the same as other text, especially in a mixed pitch environment.
(set-face-attribute 'variable-pitch-text nil :height 1.0)

;; (eval-after-load 'outline
;;   (defun akirak/apply-outline-font-heights ()
;;     (set-face-attribute 'outline-1 nil :height 1.54)
;;     (set-face-attribute 'outline-2 nil :height 1.41)
;;     (set-face-attribute 'outline-3 nil :height 1.3)
;;     (set-face-attribute 'outline-4 nil :height 1.19)
;;     (set-face-attribute 'outline-5 nil :height 1.1)
;;     (set-face-attribute 'outline-6 nil :height 1.07)
;;     (set-face-attribute 'outline-7 nil :height 1.03)
;;     (set-face-attribute 'outline-8 nil :height 1.0)))

(eval-after-load 'shr
  (defun akirak/apply-shr-font-heights ()
    (set-face-attribute 'shr-text nil :height 1.15)
    (set-face-attribute 'shr-h1 nil :height 1.54)
    (set-face-attribute 'shr-h2 nil :height 1.45)
    (set-face-attribute 'shr-h3 nil :height 1.4)
    (set-face-attribute 'shr-h4 nil :height 1.33)
    (set-face-attribute 'shr-h5 nil :height 1.2)
    (set-face-attribute 'shr-h6 nil :height 1.2)))

(eval-after-load 'org
  (defun akirak/apply-org-font-heights ()
    (set-face-attribute 'org-tag nil :height (ceiling (* 1.05 akirak/font-height)))))

Other outline styles (e.g. colors)

(with-eval-after-load 'shr
  ;; Inherit styles from org headings.
  ;; The result is dependent on the theme.
  (pcase-dolist (`(,face . ,parent)
                 '((shr-h1 . org-level-1)
                   (shr-h2 . org-level-2)
                   (shr-h3 . org-level-3)
                   (shr-h4 . org-level-4)
                   (shr-h5 . org-level-5)
                   (shr-h6 . org-level-6)))
    (set-face-attribute face nil :inherit parent)))

Width and wrap

(setq akirak/default-body-width 86)

Org

Embrace Org as a common document format for Emacs.

These variables need to be set in prior to any package settings related to org:

(setq org-modules
      '(org-id
        org-clock
        org-crypt
        ;; Built-in link types I need
        ol-info
        ol-man
        ol-eww))

doct

DOCT: Declarative Org capture templates https://github.com/progfolio/doct

(setup (:package doct))

oahu

Manage Org searches https://git.sr.ht/~akirak/oahu.el

(setup (:package oahu)
  (:status personal
    (keymap-set akirak/c-z-map "SPC" #'oahu-view)
    (:global-keymap "<menu>" #'oahu-view
             "S-<menu>" #'oahu-alternative-view
             "C-<menu>" #'oahu-view-global
             "C-x g" (defun akirak-oahu-goto-context (&optional view)
                       (interactive)
                       (require 'oahu)
                       (pcase (or view oahu-last-view)
                         (`(Project ,pr . ,_)
                          (akirak-project-switch (project-root pr)))
                         (`(Org ,x . ,_)
                          (when-let* ((file (seq-find #'stringp x))
                                      (file (org-dog-resolve-relative-file file)))
                            (find-file file)))
                         (`(OrgBookmark . ,bookmark)
                          (org-rooted-view bookmark)))))))

ob-duckdb

Org Babel functions for DuckDB SQL https://github.com/gggion/ob-duckdb.el

(setup (:package ob-duckdb)
  (:org-babel-language t))

ob-graphql

Org-Babel execution backend for GraphQL source blocks https://github.com/jdormit/ob-graphql

(setup (:package ob-graphql)
  (:org-babel-language t))

ob-mermaid

org-babel support for mermaid evaluation https://github.com/arnm/ob-mermaid

(setup (:package ob-mermaid))

ob-restclient

org-babel functions for restclient-mode

(setup (:package ob-restclient)
  (:org-babel-language t))

org

Outline-based notes management and organizer https://orgmode.org

(setup (:package org)
  (:with-mode org-mode
    (:set org-log-done 'time
          org-log-into-drawer t
          org-startup-folded 'content
          ;; If necessary, set up startup indent in individual files
          org-startup-indented nil
          org-startup-truncated nil
          org-enforce-todo-dependencies t
          org-use-speed-commands t
          ;; Enlarge for olivetti-mode
          org-tags-column -80
          org-track-ordered-property-with-tag t
          org-extend-today-until 6
          ;; Consider org-extend-today-until in org-reverse-datetree
          org-use-effective-time t
          ;; Use the last clocked time in org-todo
          org-use-last-clock-out-time-as-effective-time t
          ;; https://yiufung.net/post/org-mode-hidden-gems-pt1/
          org-cycle-separator-lines 0
          org-blank-before-new-entry '((heading . nil)
                                       (plain-list-item . auto))
          org-imenu-depth 6
          ;; Prevent an annoying behaviour probably due to org's bug.
          org-link-search-must-match-exact-headline t
          org-catch-invisible-edits 'show-and-error
          org-enforce-todo-dependencies nil
          org-enforce-todo-checkbox-dependencies t
          ;; Prevent from saving org-refile and org-capture locations to bookmarks
          org-bookmark-names-plist nil)

    (:when-loaded
      (when (require 'akirak-org nil t)
        (:hook #'akirak-org-protected-mode)))

    (:global-keymap "M-g o" #'org-open-at-point-global)

    (defvar akirak/org-file-apps-set-from-mime nil)
    (advice-add 'org-open-file
                :before
                (defun akirak/ad-org-open-file-set-apps (&rest _)
                  (unless akirak/org-file-apps-set-from-mime
                    (akirak-mime-update-org-file-apps)
                    (setq akirak/org-file-apps-set-from-mime t))))

    (:when-loaded
      (:status personal
        (when (require 'akirak-org-config nil t)
          (akirak-org-config-setup)
          (run-with-idle-timer 240 nil #'akirak-org-scan-type-tags)))

      (add-to-list 'org-file-apps '(t . mailcap) t)

      (add-to-list 'display-buffer-alist
                   '("\\*Org Select\\*"
                     (display-buffer-in-side-window
                      '((side . bottom))))
                   t)
      (setq org-structure-template-alist
            (seq-sort-by #'car #'string-collate-lessp
                         (cl-remove-duplicates
                          (append '(("d" . "definition")
                                    ;; Override CENTER block
                                    ("c" . "toc")
                                    ("t" . "takeaway")
                                    ("i" . "aside"))
                                  org-structure-template-alist)
                          :key #'car
                          ;; Needed to override existing bindings
                          :from-end t
                          :test #'equal))))))

Completion

(setup org-mode
  ;; When `org-tag-persistent-alist' is non-nil,
  ;; `org-current-tag-alist' is set, and tags from
  ;; `org-get-buffer-tags' are unavailable in completion.
  ;;
  ;; To provide non-persistent tags, enable this option to
  ;; feed tags from all agenda files.
  ;;
  ;; This will be safe, since I use categories instead of
  ;; tags to identify work projects.
  (:set org-complete-tags-always-offer-all-agenda-tags t)

  ;; https://emacs.stackexchange.com/questions/21171/company-mode-completion-for-org-keywords
  (:hook (defun akirak-org-add-completion-at-point ()
           (add-hook 'completion-at-point-functions 'pcomplete-completions-at-point
                     nil t))))

Display settings

(setup org
  ;; Based on https://lepisma.xyz/2017/10/28/ricing-org-mode/
  (:set org-ellipsis " ⌄ "
        org-pretty-entities t
        org-hide-emphasis-markers nil
        org-hide-leading-stars nil
        org-fontify-whole-heading-line t
        org-fontify-done-headline nil
        org-fontify-quote-and-verse-blocks t
        org-image-actual-width t
        org-image-max-width 'fill-column))

Keybindings

(setup org
  (:with-mode org-mode
    ;; These bindings should be set by default, but just in case.
    (:keymap "C-a" #'org-beginning-of-line
             "C-e" #'org-end-of-line)

    (:status opinionated
      (:set org-special-ctrl-a/e t
            org-M-RET-may-split-line nil)

      (:when-loaded
        (when (require 'akirak-org nil t)
          (:hook #'akirak-org-eldoc-setup)))

      (:global-keymap "M-g h" #'akirak-org-avy-heading)

      (:keymap-unset "C-'"
                     ;; I don't use any of these bindings and want to use them for other purposes
                     "C-c ["
                     "C-c ]"
                     ;; C-c C-x u is bound to org-metaup, but I use another binding
                     ;; (currently M-P) for the command.
                     "C-c C-x u")
      (:keymap akirak/mode-prefix-key (lookup-key org-mode-map (kbd "C-c C-x"))
               "<" #'akirak-org-angle-open
               "[" #'akirak-org-square-open
               "*" #'akirak-org-bold
               "/" #'akirak-org-italic
               "_" #'akirak-org-underlined
               "=" #'akirak-org-verbatim
               "`" #'akirak-org-inline-code
               "~" #'akirak-org-inline-code
               "+" #'akirak-org-strike-through
               "C-c b" #'akirak-org-select-region-dwim
               ;; Override the default binding to `org-feed-update-all'.
               "C-c C-x g" #'akirak-org-gh-transient
               "C-c C-x h" #'org-edit-headline
               "C-c C-x t" #'akirak-org-table-create-or-edit
               "C-c C-x y" #'akirak-org-yank-into-new-block
               "C-c C-x ' c" #'akirak-org-avy-clone-subtree
               "C-c C-x ' r" #'avy-org-refile-as-child
               "C-c C-x C-w" #'org-cut-subtree
               ;; Overrides the default binding to org-next-link, but I will drop
               ;; it in favor of link-hint
               "C-c C-x C-p" #'akirak-org-copy-property-value
               "C-c C-x u r" #'org-update-radio-target-regexp
               "C-c C-x u _" #'akirak-org-auto-decorate-words
               "M-s o" #'org-pivot-search-from-files
               ;; M-up/down/left/right is unavailable on Chromebooks, so I need
               ;; alternative bindings for commands bound on those keys.
               "M-N" #'org-metadown
               "M-P" #'org-metaup
               "M-H" #'org-shiftmetaleft
               "M-L" #'org-shiftmetaright
               "M-g a" #'akirak-org-goto-beginnning-of-content
               "M-g e" #'akirak-org-goto-before-next-heading
               "C-M-u" (defun akirak/org-up-element ()
                         (interactive)
                         (if (org-match-line org-heading-regexp)
                             (progn
                               (org-up-element)
                               (org-fold-show-entry))
                           (require 'org-element)
                           (let ((context (org-element-context)))
                             (while (= (point) (org-element-property :begin context))
                               (setq context (org-element-property :parent context)))
                             (goto-char (org-element-property :begin context))
                             (org-show-context)))))

      (:with-map org-read-date-minibuffer-local-map
        (:keymap "C-p" (defun akirak/org-calendar-previous-week ()
                         (interactive)
                         (org-eval-in-calendar '(calendar-forward-week -1)))
                 "C-n" (defun akirak/org-calendar-next-week ()
                         (interactive)
                         (org-eval-in-calendar '(calendar-forward-week 1)))
                 "<tab>" (defun akirak/org-calendar-next-day ()
                           (interactive)
                           (org-eval-in-calendar '(calendar-forward-day 1)))
                 "S-<iso-lefttab>" (defun akirak/org-calendar-previous-day ()
                                     (interactive)
                                     (org-eval-in-calendar '(calendar-forward-day -1))))))))

org-agenda

(setup org-agenda
  (:set org-agenda-start-with-clockreport-mode nil
        org-agenda-remove-tags nil
        org-agenda-use-tag-inheritance t
        org-agenda-sticky nil
        org-agenda-restore-windows-after-quit t
        org-agenda-window-setup 'current-window)
  (:status personal
    (:set org-agenda-start-on-weekday 1))
  (:local-set truncate-lines t)
  (:keymap-unset "TAB" "<tab>")
  (:keymap "C-c ." #'akirak-org-edit-active-ts
         ;; Use "o" instead of "<tab>".
         "o" #'org-agenda-goto)

  ;; Keybinding compatibility with org-mode.
  (defvar akirak/org-agenda-prefix-map (make-sparse-keymap))
  (with-eval-after-load 'org-agenda
    (keymap-set org-agenda-mode-map akirak/mode-prefix-key
                akirak/org-agenda-prefix-map))

  (defmacro akirak/org-agenda-wrap-orig-command (org-command)
    `(defun ,(intern (format "akirak/%s-from-agenda" org-command)) ()
       (interactive)
       (org-agenda-with-point-at-orig-entry (buffer-substring (pos-bol) (pos-eol))
         (call-interactively ',org-command))))

  (:with-map akirak/org-agenda-prefix-map
    (:keymap "r" #'octopus-refile
           "S" (akirak/org-agenda-wrap-orig-command
                org-super-links-store-link)
           "C" (defun akirak/org-agenda-make-check-list ()
                 (interactive)
                 (let (result)
                   (save-excursion
                     (while (text-property-search-forward 'org-agenda-structural-header)
                       (push (string-trim (buffer-substring-no-properties
                                           (pos-bol) (pos-eol)))
                             result)))
                   (kill-new (mapconcat (lambda (s)
                                          (concat "- [ ] " s))
                                        (nreverse result)
                                        "\n"))
                   (message "Stored a check list to the kill ring")))))

  (keymap-set help-map "M-a"
              (defun akirak/org-default-agenda ()
                (interactive)
                (unless (bound-and-true-p org-clock-history)
                  (akirak-org-clock-add-agenda-files 7))
                (let ((org-agenda-custom-commands
                       `(("a" "The agenda"
                          ((agenda)
                           ,(org-memento-make-agenda-block))))))
                  (org-agenda nil "a")))))

org-babel (ob)

(setup ob
  (:set org-confirm-babel-evaluate nil
        org-babel-load-languages
        '((shell . t)
          (emacs-lisp . t)
          (sqlite . t)
          (sql . t)))

  ;; By default, org-babel can't execute source block in an indirect buffer,
  ;; which I find frustrating. This function advice enables that.
  (advice-add 'org-babel-result-to-file
              :around
              (defun akirak/ad-around-org-babel-result-to-file (orig &rest args)
                (let ((point (point)))
                  (with-current-buffer (org-base-buffer (current-buffer))
                    (save-excursion
                      (goto-char point)
                      (apply orig args)))))))

org-capture

(setup org-capture
  ;; org-capture adds an item after a note in the logbook. This is likely to be
  ;; a bug, but I will work around it for now.
  (advice-add 'org-capture-place-item
              :before
              (defun akirak/ad-before-org-capture-place-item (&rest _)
                (org-end-of-meta-data t)
                (when (and (looking-at-p org-heading-regexp)
                           (re-search-backward (rx anything "\n") nil t))
                  (beginning-of-line 2))))

  (add-hook 'org-capture-prepare-finalize-hook
            (defun akirak/org-capture-maybe-fill-headline ()
              "Edit the headline if it is missing."
              (unless (eq this-command 'org-capture-kill)
                (goto-char (point-min))
                (let ((headline (org-get-heading t t t t)))
                  (when (string-empty-p headline)
                    (org-edit-headline))))))

  (add-hook 'org-capture-prepare-finalize-hook #'akirak-org-capture-push-history))

org-clock

(setup org-clock
  (:set org-clock-history-length 50
        org-clock-goto-may-find-recent-task nil
        org-clock-mode-line-total 'today
        org-clock-out-remove-zero-time-clocks t
        org-clock-in-resume t

        org-clock-persist t
        ;; I may simply close Emacs to leave the work
        org-clock-persist-query-save t
        org-clock-persist-query-resume nil
        org-clock-auto-clockout-timer (* 15 60)
        ;; Don't ask about exiting but about saving
        org-clock-ask-before-exiting nil

        ;; I use mini-modeline extensively
        org-clock-clocked-in-display 'both
        org-clock-string-limit 0
        ;; org-clock-string-limit 40 ; mini-modeline

        ;; Use `org-clock-display' to track time on projects weekly or monthly
        org-clock-display-default-range 'thisweek

        org-clock-heading-function
        (defun akirak/org-clock-mode-line-heading ()
          (concat (file-name-base (buffer-name)) ": "
                  (org-link-display-format
                   (org-no-properties (org-get-heading t t t t)))))

        org-clocktable-defaults
        (list :fileskip0 t :stepskip0 t :tcolumns 1
              ;; Remaining arguments are the same as defaults
              :maxlevel 2 :lang "en" :scope 'file :block nil
              :wstart 1 :mstart 1 :tstart nil :tend nil :step nil
              :tags nil :match nil :emphasize nil :link nil
              :narrow '40! :indent t :filetitle nil :hidefiles nil
              :formula nil :timestamp nil :level nil
              :formatter nil))

  (add-hook 'akirak/system-leave-hook
            (defun akirak/org-clock-out-maybe ()
              (when (org-clocking-p)
                (org-clock-out)))
            10)

  (defcustom akirak-org-clock-allow-in-buffer nil
    "Whether to allow `org-clock-in' in the current buffer.

Set this variable to t locally if you want to enable `org-clock-in'."
    :type 'boolean
    :local t)

  (advice-add 'org-clock-in :before #'akirak/block-org-clock-in)
  (defun akirak/block-org-clock-in (&rest _args)
    "An advice to block unindesirable `org-clock-in'."
    (when (and (memq this-command '(org-clock-in
                                    org-agenda-clock-in))
               (require 'org-dog-core nil t)
               (not (bound-and-true-p akirak-org-clock-allow-in-buffer)))
      (if-let* ((filename (buffer-file-name (org-base-buffer (current-buffer))))
                (filename (thread-last
                            filename
                            (abbreviate-file-name)
                            (expand-file-name))))
          ;; Skip unconditionally if org-dog is unavailable
          (when (or (not (string-match-p org-dog--root-regexp filename))
                    (and (bound-and-true-p org-memento-file)
                         (equal filename (expand-file-name org-memento-file))))
            (user-error "You cannot clock in to this file"))
        (user-error "You cannot clock in to a heading without a file")))))

org-element

(setup org-element
  ;; Disable the cache entirely. Note that this variable is not a custom
  ;; variable.
  (:set org-element-cache-persistent nil))

org-habit

(setup org-habit
  (:set org-habit-following-days 7
        org-habit-graph-column 55
        org-habit-preceding-days 14
        org-habit-scheduled-past-days 7
        org-habit-show-done-always-green t))

org-id

(setup org-id
  (:set org-id-link-to-org-use-id t))

org-link (ol)

(setup ol
  ;; Workaround for a bug of missing autoload
  (autoload 'org-bibtex-store-link "ol-bibtex")

  (:status opinionated
    (:global-keymap "C-c l" #'org-store-link)
    (with-eval-after-load 'org-agenda
      (keymap-set org-agenda-mode-map
                  "C-c l"
                  #'(lambda ()
                      (interactive)
                      (org-agenda-with-point-at-orig-entry
                          (thing-at-point 'line)
                        (org-store-link nil 'interactive))))))

  (:with-feature isearch
    (:with-map isearch-mode-map
      (:keymap "<remap> <org-insert-link>"
               (defun akirak/org-insert-link-isearch ()
                 "Create a link on the isearch-highlighted region."
                 (interactive)
                 (pcase-exhaustive isearch-match-data
                   (`(,begin ,end . ,_)
                    (isearch-done)
                    (goto-char begin)
                    (push-mark)
                    (goto-char end)
                    (activate-mark)
                    (call-interactively #'org-insert-link))))))))

org-refile

(setup org-refile
  (:set org-log-refile nil
        org-refile-targets '((nil :maxlevel . 99)
                             (org-agenda-files :maxlevel . 99))
        org-outline-path-complete-in-steps nil
        org-refile-allow-creating-parent-nodes 'confirm
        org-refile-use-outline-path 'file))

org-src

(setup org-src
  (:set org-src-tab-acts-natively t
        ;; It would be nice if there were split-window-above option.
        org-src-window-setup 'split-window-below)

  (advice-add 'org-src-switch-to-buffer
              :before
              (defun akirak/org-src-maybe-jump-to-result (buffer context)
                (unless (memq org-src-window-setup '(split-window-below
                                                     split-window-right))
                  (message "This function should be used only when \
`org-src-window-setup' has a certain value"))
                (when (alist-get :file (caddr (org-babel-get-src-block-info)))
                  (if-let* ((pos (org-babel-where-is-src-block-result)))
                      (goto-char pos)
                    (goto-char (org-element-end (org-element-at-point-no-context))))
                  (recenter-top-bottom 0))))

  (defun akirak/org-src-save-hook-for-update ()
    (when (eq this-command 'org-edit-src-save)
      (org-with-point-at org-src--beg-marker
        (org-babel-execute-src-block)
        (org-redisplay-inline-images))))

  (:when-loaded
    (add-hook 'org-src-mode-hook
              (defun akirak/org-src-auto-update-setup ()
                "Set up auto-updating of image source blocks."
                ;; If the source block has :file parameter, set up an `after-save-hook'.
                (when (org-with-point-at org-src--beg-marker
                        (alist-get :file (caddr (org-babel-get-src-block-info))))
                  (add-hook 'post-command-hook
                            #'akirak/org-src-save-hook-for-update
                            nil
                            t)))
              100)))

Tags

(setup org-tags
  (:set org-group-tags t
        org-tags-exclude-from-inheritance '("ORDERED" "crypt")))

orgabilize

Converts web pages into Org https://github.com/akirak/orgabilize.el

(setup (:package orgabilize)
  (:nixpkgs "readability-cli")
  (add-hook 'org-ctrl-c-ctrl-c-hook #'orgabilize-update-link-title)
  ;; (with-eval-after-load 'embark
  ;;   (keymap-set embark-url-map "r"
  ;;               (defun akirak/embark-archive-url-to-org (url)
  ;;                 (interactive "s")
  ;;                 (orgabilize-org-archive url))))
  (:embark embark-url-map "s"
    ("r" orgabilize-org-archive akirak/embark-url-archive-org))
  (:when-loaded
    (setq orgabilize-title-escape-alist
          (append (eval (car (get 'orgabilize-title-escape-alist 'standard-value)))
                  '(("[｜│|][^z-a]+[｜│|]" . "│")
                    ("([^z-a]+)" . "")
                    ("^[^。]+。" . "")
                    ("|" . "│")
                    ("[【】]" . ""))))))

orgabilize-playwright

Playwright backend for scraping web pages https://github.com/akirak/orgabilize.el

(setup (:package orgabilize-playwright)
  ;; A custom package from github:akirak/nix-playwright-mcp
  (:nixpkgs playwright-mcp)
  (:set orgabilize-use-playwright t
        orgabilize-playwright-mcp-name "playwright-headless"))

org-autolist

Improved list management in org-mode

(setup (:package org-autolist)
  (:hook-into org-mode-hook)
  (:when-loaded
    ;; Inside a block, org-autolist splits the block instead of adding a new
    ;; item. This advice is a workaround for the issue.
    (advice-add 'org-meta-return
                :around
                (defun akirak/org-autolist-ad-around-org-meta-return (orig &rest args)
                  (if (and (eq this-command 'org-return)
                           (org-at-item-p)
                           (eolp))
                      (org-insert-item)
                    (apply orig args))))))

org-bookmark-heading

Emacs bookmark support for Org mode http://github.com/alphapapa/org-bookmark-heading

(setup (:package org-bookmark-heading)
  (:set org-bookmark-heading-make-ids t)
  ;; Ensure the library is used when creating a bookmark
  (add-to-list 'org-modules 'org-bookmark-heading))

org-crypt

(setup org-crypt
  (defun akirak/setup-org-crypt ()
    (setq-local buffer-auto-save-file-name nil)
    (add-hook 'before-save-hook #'org-encrypt-entries nil t)))

org-dog

A programmable workflow layer for Org mode https://github.com/akirak/org-dog

(setup (:package org-dog)
  (with-eval-after-load 'org-id
    (org-dog-id-mode t))
  (add-hook 'org-mode-hook #'org-dog-file-mode-maybe)

  (:set org-dog-context-path-patterns
        `(("^\\.github/" . "services/github.com")
          ("\\.h?eex\\'" . "programming/elixir")
          ("package\\.yaml\\'" . "programming/haskell")
          ("packages\\.json\\'" . "programming/javascript")
          ("tsconfig\\." . "programming/typescript")
          ("\\.envrc\\'" . "programming/envrc")
          ("dune\\(?:-[^/]+\\)?\\'" . "programming/ocaml")
          ("hie\\.yaml\\'" . "programming/haskell")
          ("/graphql/" . "programming/graphql")
          ("Cargo\\.toml\\'" . "programming/rust")
          ("\\.editorconfig\\'" . "programming/editorconfig")
          ("astro\.config\.[cm]?js\\'" . "software/astro.build")
          ("machines/\\([-a-z0-9]+\\)/" . "hosts/\\1")
          ("renovate.json\\'" . "software/renovate-bot"))
        org-dog-clock-in-fallback-fn #'akirak-capture-clock-in
        org-dog-clock-default-query-filter
        (lambda (query)
          (concat "!tags:ARCHIVE " query)))

  (add-to-list 'recentf-exclude
               (defun akirak/org-dog-recentf-p (file)
                 (when (featurep 'org-dog)
                   (string-match-p (concat (regexp-opt (mapcar #'car org-dog-repository-alist)
                                                       :paren)
                                           "[^z-a]+\\.org$")
                                   file))))

  (defun akirak/org-dog-turn-on-transclusion ()
    (org-transclusion-mode t))
  (add-hook 'org-dog-find-file-hook #'akirak/org-dog-turn-on-transclusion)
  (add-hook 'org-dog-before-search-hook #'akirak/org-dog-turn-on-transclusion)

  ;; (add-hook 'org-dog-file-mode-hook #'org-dog-header-line-enable)

  (add-hook 'org-dog-file-registration-hook
            (defun akirak/org-dog-add-agenda-file (file-obj)
              (when (string-match-p (rx bol
                                        (or "meta"
                                            (and "personal/" (+ (not (any "/"))) eol)
                                            "employment/"
                                            "errands"))
                                    (oref file-obj relative))
                (add-to-list 'org-agenda-files (oref file-obj absolute)))))

  ;; Add all file tags in the registered files to the persistent tag alist.
  ;; This is important for the propagation feature of org-dog-datetree.el.
  (add-hook 'org-dog-file-registration-hook
            (defun akirak/org-dog-add-file-tags (file-obj)
              (org-dog-with-file-header (oref file-obj absolute)
                (dolist (tag org-file-tags)
                  (unless (assoc tag org-tag-persistent-alist)
                    (setq org-tag-persistent-alist
                          (append org-tag-persistent-alist
                                  (list (list (substring-no-properties tag))))))))))

  (add-hook 'org-dog-reload-hook
            (defun akirak/org-dog-add-extra-agenda-files ()
              (require 'org-dog-overview)
              (setq org-agenda-files
                    (thread-last
                      (org-dog-overview-scan org-agenda-files :fast t)
                      (mapcar #'car)
                      (reverse)))
              (when (bound-and-true-p org-memento-file)
                (add-to-list 'org-agenda-files org-memento-file t))))

  (:status personal
    (add-hook 'org-dog-clock-in-success-hook
              #'akirak-org-git-add-properties-if-none))

  (:when-loaded
    (:also-load org-dog-embark
                org-dog-facade))

  (add-to-list 'display-buffer-alist
               '("*Org Dog Tablist Files*"
                 (display-buffer-in-tab)))

  (with-eval-after-load 'org-dog-overview
    (keymap-set org-dog-overview-mode-map
                "+" #'org-dog-add-header-link))

  (:status personal
    (:auto-insert
     (("\\.org\\'" . "Org Dog files")
      . akirak/org-dog-auto-insert))
    (with-eval-after-load "autoinsert"
      (add-to-list 'auto-insert-alist
                   'akirak/org-dog-auto-insert
                   t))

    (defun akirak/org-dog-auto-insert ()
      (when-let* ((obj (org-dog-buffer-object)))
        (cl-typecase obj
          (org-dog-facade-datetree-file
           (skeleton-insert
            `(> "#+title: " _
                n "#+REVERSE_DATETREE_USE_WEEK_TREE: nil"
                n "#+REVERSE_DATETREE_DATE_FORMAT: %Y-%m-%d %A"
                n "#+REVERSE_DATETREE_MONTH_FORMAT: %Y-%m"
                n "#+REVERSE_DATETREE_YEAR_FORMAT: %Y"
                n
                n "* Backlog"
                n "* " (format-time-string "%Y")
                n "* Activities"
                ,@(when (string-prefix-p "programming/" (oref obj relative))
                    '(n "* Libraries"))
                n "* Index"
                n "* Resources"))))))

    (when (daemonp)
      (:defer 1
              (defun akirak/org-dog-load-on-startup ()
                ;; I don't want to hide the init time in the echo area.
                (let ((inhibit-message t))
                  (require 'org-dog)
                  (org-dog-reload-files t)
                  ;; Enable only after the Org files have been loaded.
                  (add-hook 'after-change-major-mode-hook
                            #'akirak-org-dog-use-major-mode-templates)
                  (akirak-org-clock-rebuild-history)
                  (when (fboundp 'akirak/dashboard-init-on-startup)
                    (akirak/dashboard-init-on-startup))))))))

consult-org-dog

https://github.com/akirak/org-dog

(setup (:package consult-org-dog)
  (:global-keymap "M-g M-/" #'consult-org-dog)
  (:set consult-org-dog-tag-super-groups
        '(("@epic"
           (:todo "DONE")
           (:todo "UNDERWAY")
           (:auto-category t)))))

octopus

Transient commands for Org Dog https://github.com/akirak/org-dog

(setup (:package octopus)
  (:global-keymap "M-g M-o" #'octopus-find-file
                  "M-s M-o" #'octopus-find-node)

  (keymap-set akirak/c-z-map "I" #'octopus-clock-in)
  (keymap-set akirak/c-z-map "C-i" #'octopus-clock-in)

  (:set octopus-find-node-verbs
        '((?f "Display a node" nil akirak/org-pivot-search-from-files)
          (?v "Display a search view" nil akirak-org-ql-search-files)
          (?o "Open a heading link" nil akirak-org-ql-open-link)
          (?i "Insert a target" nil org-nlink-insert-plain))
        octopus-super-link-drawer-list '("BLOCKING")
        octopus-category-max-entries 4)

  (:with-feature org
    (:when-loaded
      (:with-map org-mode-map
        (:keymap "C-c C-x l" #'octopus-insert-link)
        (:keymap "C-c C-x r" #'octopus-refile))))

  (:with-feature org-agenda
    (:when-loaded
      (:with-map org-agenda-mode-map
        (:keymap "<remap> <org-agenda-refile>" #'octopus-refile))))

  (:with-feature org-capture
    (:when-loaded
      (:with-map org-capture-mode-map
        (:keymap "<remap> <org-capture-refile>" #'octopus-capture-refile))))

  (:when-loaded
    (transient-append-suffix #'octopus-find-node
      'octopus-clocked-file-suffix
      '("b" "Placeholder" org-rooted-find-or-create))

    (transient-append-suffix #'octopus-clock-in
      'octopus-read-dog-file-suffix
      '("." "Project" akirak-org-clock-in-to-project))))

org-dog-context

(setup org-dog-context
  (:status personal
    (:when-loaded
      (org-dog-context-set-alist 'project
        :callback #'akirak-org-dog-project-context))))

org-dog-embark

An example embark configuration for org-dog https://github.com/akirak/org-dog

(setup (:package org-dog-embark)
  (:with-map org-dog-embark-file-map
    (:keymap "v" (defun akirak/oahu-view-org-file (file)
                 (interactive "sFile: ")
                 (oahu-view 'Org (list file))))))

org-dog-export

Export Org contents to various formats https://github.com/akirak/org-dog

(setup (:package org-dog-export))

org-dog-facade

Facade Org files https://github.com/akirak/org-dog

(setup (:package org-dog-facade)
  (add-hook 'org-capture-prepare-finalize-hook
            #'akirak/org-dog-datetree-propagate)
  (:set org-dog-datetree-propagate-on-refile t
        org-dog-datetree-generate-id-on-refile t
        org-dog-datetree-tag-predicate
        (defun akirak/org-dog-datetree-tag-propagated-p (tag)
          (string-match-p (rx bol (or "@tldr"
                                      (not (any "@"))))
                          tag)))

  (defun akirak/org-dog-datetree-propagate ()
    (require 'org-reverse-datetree)
    (require 'org-dog-datetree)
    (when (org-reverse-datetree-guess-date)
      (org-dog-datetree-propagate-by-tag nil :local t))))

org-dog-root

(setup org-dog-root
  (:when-loaded
    (add-hook 'mode-line-misc-info org-dog-root-mode-item)))

org-epubinfo

Integrate Org with epubinfo program https://github.com/akirak/org-epubinfo

(setup (:package org-epubinfo)
  (:nixpkgs customPackages.epubinfo))

org-hyprctl

Manage Hyprctl workspaces from Org mode https://github.com/akirak/org-hyprctl/

(setup (:package org-hyprctl)
  (keymap-set akirak/c-z-map "w" #'org-hyprctl-popup)
  (:keymap "C-M-n" #'move-dup-move-lines-down
         "C-M-p" #'move-dup-move-lines-up)
  (with-eval-after-load 'org
    (add-hook 'org-ctrl-c-ctrl-c-hook #'org-hyprctl-update)))

org-indent

(setup org-indent
  (:set org-indent-mode-turns-on-hiding-stars t))

org-lang-env

Per-entry language environment https://github.com/akirak/org-lang-env

(setup (:package org-lang-env))

org-make-toc

Automatic tables of contents for Org files http://github.com/alphapapa/org-make-toc

(setup (:package org-make-toc))

org-ml

Functional Org Mode API

(setup (:package org-ml))

org-nlink

Utilities for in-file links https://github.com/akirak/org-nlink.el

(setup (:package org-nlink)
  (:with-feature org
    (:with-map org-mode-map
      (:keymap "M-s l" #'org-nlink-occur)))

  (:set org-nlink-extra-files
        (defun akirak/org-nlink-extra-org-files ()
          (require 'org-dog-context)
          (require 'org-dog-overview)
          (append (thread-last
                    (org-dog-context-file-objects
                     (org-dog-context-org-tags-1 (org-get-tags)))
                    (mapcar (lambda (obj)
                              (oref obj absolute))))
                  (when-let* ((filename (buffer-file-name (org-base-buffer (current-buffer)))))
                    (thread-last
                      (org-dog-overview-scan (list (abbreviate-file-name filename))
                                             :clear t)
                      (mapcar #'car)))))
        org-nlink-target-verify-function
        (defun akirak/org-nlink-verify-location ()
          (require 'org-dog)
          (let ((obj (org-dog-buffer-object)))
            (if (and obj
                     (object-of-class-p obj 'org-dog-facade-datetree-file)
                     (looking-at org-complex-heading-regexp)
                     (= 1 (- (match-end 1) (match-beginning 1)))
                     (not (equal "Index" (match-string 4))))
                (progn
                  (org-end-of-subtree)
                  nil)
              t))))

  (add-hook 'org-open-link-functions #'org-nlink-open-link))

consult-org-nlink

Consult interface for org-nlink https://github.com/akirak/org-nlink.el

(setup (:package consult-org-nlink)
  (:set consult-org-nlink-insert-super-link 'ask)
  (:with-feature org
    (:with-map org-mode-map
      (:keymap "C-x i" #'consult-org-nlink-insert)))
  (:with-feature isearch
    (:with-map isearch-mode-map
      (:keymap "C-x i" #'consult-org-nlink-isearch))))

org-pivot-search

Experimental search command for Org files https://github.com/akirak/org-pivot-search

(setup (:package org-pivot-search)
  (:set org-pivot-search-annotation-function #'akirak-org-entry-annotation)

  (defun akirak/org-pivot-search-from-files (files)
    (org-pivot-search-from-files files :interactive t)))

org-ql

Org Query Language, search command, and agenda-like view https://github.com/alphapapa/org-ql

(setup (:package org-ql)
  (:also-load akirak-org-ql)
  ;; Temporarily workaround
  (autoload 'org-dblock-write:org-ql "org-ql-search")

  (:set org-ql-completing-read-reverse-paths nil)

  (:with-feature org
    (:keymap "C-c C-x /" #'org-ql-sparse-tree)))

org-ql-view

(setup org-ql-view
  ;; I don't want this function to be called every time `org-capture' is fired.
  (advice-add 'org-ql-view--link-store
              :before-while
              (defun akirak/org-ql-view-link-needed-p (&rest _args)
                (eq this-command 'org-store-link)))

  (:when-loaded
    (require 'akirak-org-ql-view)
    (:set akirak-org-ql-view-super-group-alist
          (akirak-org-ql-view-update-super-group-alist))
    (transient-replace-suffix 'org-ql-view-dispatch
      'org-ql-view--transient-super-groups
      '("g" "Groups" akirak-org-ql-view-set-super-groups))))

org-recur

Recurring org-mode tasks https://github.com/mrcnski/org-recur

(setup (:package org-recur)
  (:status opinionated
    (with-eval-after-load 'org
      (when (require 'akirak-org-recur nil t)
        (akirak-org-recur-mode t)))))

org-reverse-datetree

Create reverse date trees in org-mode https://github.com/akirak/org-reverse-datetree

(setup (:package org-reverse-datetree)
  (:set org-reverse-datetree-month-format "%Y-%m")

  (with-eval-after-load 'org
    (keymap-set org-mode-map "C-c C-x M-j" #'org-reverse-datetree-calendar))

  (with-eval-after-load 'calendar
    (keymap-set calendar-mode-map "]" #'org-reverse-datetree-calendar-next)
    (keymap-set calendar-mode-map "[" #'org-reverse-datetree-calendar-previous)
    (keymap-set calendar-mode-map "RET" #'org-reverse-datetree-display-entry)))

org-rooted

Boards for Org https://github.com/akirak/org-rooted

(setup (:package org-rooted)
  (:set org-rooted-show-archived-entries-in-view t
        org-rooted-ignored-group-heading-regexp (rx bol (or "Backlog"
                                                            "Authors"
                                                            (repeat 4 digit))))
  (:with-mode org-rooted-view-mode
    (:hook org-rooted-view-fold-mode))

  (:when-loaded
    (require 'akirak-org-capture)
    (:set org-rooted-default-capture-template
          (concat "* %i\n"
                  akirak-org-capture-default-drawer
                  "%?")))
  (:global-keymap "M-s M-p" #'org-rooted-find-or-create))

org-super-agenda

Supercharge your agenda http://github.com/alphapapa/org-super-agenda

(setup (:package org-super-agenda)
  (with-eval-after-load 'org-agenda
    (org-super-agenda-mode t))
  (:also-load akirak-org-super-agenda)
  (:status personal
    (:set org-super-agenda-groups '((:name "Timeline" :time-grid t)
                                    (:auto-category t)))))

org-super-links

Make super links https://github.com/toshism/org-super-links

(setup (:package org-super-links)
  (:with-feature org
    (:with-map org-mode-map
      (:keymap "C-c C-x L" #'org-super-links-insert-link
             "C-c C-x S" #'org-super-links-store-link))))

org-transclusion

Transclude text content via links https://github.com/nobiot/org-transclusion

(setup (:package org-transclusion)
  ;; `org-transclusion-mode' is usually turned on by `org-dog'.
  (:set org-transclusion-add-all-on-activate t))

org-volume

Retrieve metadata of volumes from inside Org https://github.com/akirak/org-volume

(setup (:package org-volume)
  (:set org-volume-image-download-method #'akirak-image-insert-offline-link
        org-volume-dblock-defaults '(:lang "en" :limit 1)))

ox-gfm

Github Flavored Markdown Back-End for Org Export Engine

(setup (:package ox-gfm)
  (add-to-list 'org-modules 'ox-gfm))

ox-hugo

Hugo Markdown Back-End for Org Export Engine https://ox-hugo.scripter.co

(setup (:package ox-hugo))

Treesit-based major modes

Generate settings by evaluating the following org-babel source block within Emacs:

(let (ts-modes)
  (cl-do-all-symbols (sym)
    (when (and (commandp sym)
               (string-suffix-p "-ts-mode" (symbol-name sym)))
      (push sym ts-modes)))
  `(when (treesit-available-p)
     (let ((alist ',(mapcar (lambda (ts-mode)
                              (cons (intern
                                     (concat (thread-last
                                               (symbol-name ts-mode)
                                               (string-remove-suffix "-ts-mode"))
                                             "-mode"))
                                    ts-mode))
                            ts-modes)))
       (if major-mode-remap-alist
           (dolist (x alist)
             (add-to-list 'major-mode-remap-alist x))
         (setq major-mode-remap-alist alist)))
     (with-eval-after-load 'org
       (dolist (x ',(mapcar (lambda (ts-mode)
                              (let ((name (symbol-name ts-mode)))
                                (cons (string-remove-suffix "-ts-mode" name)
                                      (intern (string-remove-suffix "-mode" name)))))
                            ts-modes))
         (add-to-list 'org-src-lang-modes x)))))

The generated remappings do have limitations, but it is possible to work around manually by adding extra entries in the following subsections.

astro-ts-mode

Major mode for editing Astro templates

(setup (:package astro-ts-mode)
  (:file-match "\\.astro\\'"))

dockerfile-ts-mode

(setup dockerfile-ts-mode
  (:file-match "Dockerfile\\'" "\\.dockerfile\\'"))

elixir-ts-mode

Major mode for Elixir with tree-sitter support https://github.com/wkirschbaum/elixir-ts-mode

(setup elixir-ts-mode
  (:file-match "\\.exs?\\'")
  (:mode-project-roots "mix.exs")
  (:mode-repl akirak/iex-dwim)

  (:reformatters
   (mix-format :program "mix"
               :args (list "format" "--stdin-filename" (buffer-file-name) "-")))

  (:huan
    ("def" "defp"))

  (:keymap "C-c C-e" #'akirak-sgml-close-tag)

  (:auto-insert
   ("/config/config\\.exs\\'"
    . (> "use Mix.Config\n\n"
         _))
   ("/lib/.+\\.ex\\'"
    . (> "defmodule " (akirak-elixir-module-name-from-file) " do\n"
         "  " _ n
         "end\n"))
   ("/test/.+_test\\.exs\\'"
    . (> "defmodule " (akirak-elixir-module-name-from-file) " do\n"
         "  use ExUnit.Case\n\n"
         "  alias " (string-remove-suffix
                     "Test" (akirak-elixir-module-name-from-file))
         "\n"
         "  doctest " (string-remove-suffix
                       "Test" (akirak-elixir-module-name-from-file))
         "\n"
         "  " _
         "\nend\n")))

  (:when-loaded
    (define-abbrev elixir-ts-mode-abbrev-table
      "case" "" (define-skeleton akirak-elixir-case
                  "Insert case"
                  ""
                  > "case " - " do" n
                  > @ _ n
                  > -2 "end"))

    (define-abbrev elixir-ts-mode-abbrev-table
      "fn" "" (define-skeleton akirak-elixir-fn
                "Insert fn"
                ""
                > "fn " - " ->" n
                > @ _ n
                > -2 "end"))
    (define-abbrev elixir-ts-mode-abbrev-table
      "do" "" (define-skeleton akirak-elixir-do
                "do ... end"
                ""
                > "do" n
                > @ _ n
                > -2 "end"))))

gleam-ts-mode

Major mode for Gleam https://github.com/gleam-lang/gleam-mode

(setup (:package gleam-ts-mode)
  (:file-match "\\.gleam\\'")
  (:mode-repl akirak/gleam-shell)
  ;; Should be fixed in the upstream.
  (autoload 'gleam-ts-mode "gleam-ts-mode")
  (:auto-insert
   ("_test\\.gleam\\'"
    . (> "import gleeunit/should" n
         "import "
         (let ((filename (buffer-file-name)))
           (when (string-match (rx "/test/" (group (+ nonl)) "_test.gleam") filename)
             (match-string 1 filename)))
         n n))))

go-ts-mode

Major mode for the Go programming language

(setup go-ts-mode
  (:file-match "\\.go\\'")
  (:org-src-lang "go")
  (:with-mode go-mod-ts-mode
    (:file-match "/go\\.mod\\'"))
  (:set go-ts-mode-indent-offset 2)

  (:auto-insert
   ("\\.go\\'"
    . (> "package "
         (file-name-base (or buffer-file-name (buffer-name)))
         "\n\nimport (\n"
         ")\n\n"))))

heex-ts-mode

(setup heex-ts-mode
  (:mode-project-roots "mix.exs")
  (:mode-repl akirak/iex-dwim)
  (:local-set electric-pair-pairs '((?% . ?%)))
  (:when-loaded
    ;; These workarounds are only necessary due to upstream inconsistencies.
    ;; Hopefully they will resolve the issues in the mean time.
    (unless (fboundp 'heex-ts-mode-treesit-ready-p)
      (defun heex-ts-mode-treesit-ready-p ()
        (treesit-ready-p 'heex)))
    (unless (boundp 'heex-ts-mode--indent-rules)
      (setq heex-ts-mode--indent-rules
            heex-ts--indent-rules))
    (unless (boundp 'heex-ts-mode--font-lock-settings)
      (setq heex-ts-mode--font-lock-settings
            heex-ts--font-lock-settings))))

java-ts-mode

(setup java-ts-mode
  (:mode-project-roots "pom.xml"))

json-ts-mode

(setup json-ts-mode
  (:file-match "\\.json\\'" "\\.lock\\'")
  (:mode-project-roots "package.json")
  (:hook (defun akirak/json-ts-setup ()
           (add-hook 'eldoc-documentation-functions
                     (defun akirak/json-ts-path-eldoc (cb)
                       (when-let* ((points (cdr (ppss-open-parens (syntax-ppss)))))
                         (funcall cb (mapconcat
                                      (lambda (pos)
                                        (let* ((node (treesit-node-parent
                                                      (treesit-node-at pos)))
                                               (prev-sibling (treesit-node-prev-sibling node)))
                                          (pcase (treesit-node-type prev-sibling)
                                            (":"
                                             (thread-first
                                               prev-sibling
                                               (treesit-node-prev-sibling)
                                               (treesit-node-text)
                                               (substring-no-properties)))
                                            (","
                                             "[]"))))
                                      points
                                      "."))))
                     nil t))))

js-ts-mode

(setup js-ts-mode
  (:org-src-lang "javascript")
  (:file-match "\\.[cm]?js$" "\\.json5\\'")
  (:mode-repl akirak/node-or-bun-repl)
  (:mode-project-roots "package.json"))

lua-ts-mode

(setup lua-ts-mode
  (:file-match "\\.lua\\'"))

nix-ts-mode

Major mode for Nix expressions, powered by tree-sitter

(setup (:package nix-ts-mode)
  (:file-match "\\.nix\\'")
  (:mode-repl nix-repl)
  (:keymap "<remap> <devdocs-lookup>" #'akirak-nix-manix)

  ;; Install alejandra for reformatting.
  (:nixpkgs alejandra)
  (:reformatters
   ;; nixfmt-rfc-style is now recommended, but keep alejandra until I finish
   ;; migration
   (alejandra :program "alejandra")))

rust-ts-mode

(setup rust-ts-mode
  (:file-match "\\.rs\\'")
  (:mode-project-roots "Cargo.toml"))

toml-ts-mode

(setup toml-ts-mode
  (:org-src-lang "toml")
  (:file-match "\\.toml\\'"))

typescript-ts-mode

Major mode for editing typescript http://github.com/ananthakumaran/typescript.el

(setup typescript-ts-mode
  (:file-match "\\.ts\\'" "\\.mts\\'")
  (:mode-repl akirak/node-or-bun-repl)

  ;; (:also-load akirak-typescript)
  (:hook (defun akirak/typescript-setup ()
           (add-to-list (make-local-variable 'electric-pair-pairs)
                        '(?< . ?>))))

  (:with-mode typescript-ts-base-mode
    (:huan
      ("import" "export")
      ("enable" "disable")
      ("const" "let")
      ("true" "false")
      ;; For eslint rules
      ("off" "warn" "error"))
    (:mode-project-roots "package.json")
    (:local-set block-comment-start "/*"
                block-comment-end "*/"))

  (:with-mode tsx-ts-mode
    (:file-match "\\.tsx\\'")
    (:mode-repl akirak/node-or-bun-repl)
    (:org-src-lang "react")
    (:keymap "C-c C-e" #'akirak-treesit-jsx-close-tag)))

yaml-ts-mode

Major mode for editing YAML files https://github.com/yoshiki/yaml-mode

(setup yaml-ts-mode
  (:file-match "\\.ya?ml\\'")
  (:ffap
   (defun akirak/github-actions-ffap-handler (string)
     (when (string-match (rx (group (+ nonl) "/" (+ nonl))
                             "@" (group (+ (any "-" alnum))))
                         string)
       (format "https://github.com/%s/tree/%s"
               (match-string 1 string)
               (match-string 2 string)))))
  (:hook (defun akirak/yaml-setup ()
           "Enable extra settings for YAML."
           (interactive nil (yaml-mode yaml-ts-mode))
           (pcase (buffer-file-name)
             (`nil)
             ((rx "/.github/workflows/")
              (message "YAML: Detected GitHub workflow")
              (when (fboundp 'flymake-actionlint1-enable)
                (flymake-actionlint1-enable)))))))

zig-ts-mode

Tree Sitter support for Zig https://codeberg.org/meow_king/zig-ts-mode

(setup (:package zig-ts-mode)
  ;; .zig and .zon
  (:file-match "\\(?:\\.z\\(?:ig\\|on\\)\\)\\'")
  (:org-src-lang "zig")
  (:when-loaded
    (when (require 'zig-mode nil t)
      (setq auto-mode-alist (cl-remove 'zig-mode auto-mode-alist :key #'cdr :test #'eq))
      (:keymap "C-c C-r" #'zig-run
             "C-c C-b" #'zig-compile
             "C-c C-f" #'zig-format-buffer
             "C-c C-t" #'zig-test-buffer))))

Working with specific services

GitHub

flymake-actionlint1

Another flymake backend for actionlint https://github.com/akirak/flymake-actionlint1

(setup (:package flymake-actionlint1)
  (:nixpkgs "actionlint"))

Syncthing

(defconst akirak/syncthing-conflict-file-regexp
  (rx ".sync-conflict-" (+ (any "-" alnum))))

(defun akirak/syncthing-ediff (&optional filename)
  "Given a Syncthing conflict file, compare it with the current version."
  (interactive)
  (let* ((file (or filename (buffer-file-name)))
         (another (replace-regexp-in-string akirak/syncthing-conflict-file-regexp
                                            ""
                                            file)))
    (if (equal file another)
        (user-error "The current file is not a Syncthing conflict file")
      (ediff file another))))

(add-hook 'find-file-hook
          (defun akirak/syncthing-maybe-ediff ()
            (let ((filename (buffer-file-name)))
              (when (and (string-match-p akirak/syncthing-conflict-file-regexp filename)
                         (yes-or-no-p (format-message "Open ediff session for %s? "
                                                      (file-name-nondirectory filename))))
                (akirak/syncthing-ediff filename)))))

User package (akirak-*.el)

This is a collection of various utilities to enhance the experience.

(setup (:package akirak)
  (:global-keymap "C-x d" #'akirak-consult-dir
           "<f12> j" #'akirak-scratch-japanese)

  (with-eval-after-load 'embark
    (require 'akirak-embark)
    (add-to-list 'embark-keymap-alist
                 '(directory . akirak-embark-directory-map))
    (add-to-list 'embark-keymap-alist
                 '(project-root . akirak-embark-project-root-map))
    ;; Since I am not using package.el, it is better to override the default
    ;; embark map.
    (add-to-list 'embark-keymap-alist
                 '(package . akirak-embark-package-map)))

  ;; These settings are specific to my environment.
  (:status personal
    (:defer 1 #'akirak-files-ensure-abbrev-list)))

akirak-ai-prompt

(setup akirak-ai-prompt
  (:global-keymap "C-c a" #'akirak-ai-prompt-transient))

akirak-avy

(setup akirak-avy
  (:global-keymap "C-;" #'akirak-avy-insert-symbol
                  "M-g `" #'akirak-avy-org-block))

akirak-capture

(setup akirak-capture
  (:global-keymap "C-c c" #'akirak-capture)

  ;; Integrate with gptel-menu
  (with-eval-after-load 'gptel-transient
    (transient-append-suffix 'gptel-menu '(-1 0)
      '("o" "org-capture" akirak-capture-gptel))))

akirak-comment

(setup akirak-comment
  (:set comment-region-function #'akirak-comment-region-1
        uncomment-region-function #'akirak-uncomment-region-1)
  (:global-keymap "M-;" #'akirak-comment-toggle))

akirak-compile

(setup akirak-compile
  (:global-keymap "C-x c" #'akirak-compile)

  (with-eval-after-load 'compile
    (akirak-compile-auto-error-mode t)))

akirak-consult

(setup akirak-consult
  (:status opinionated
    (:global-keymap "<remap> <consult-imenu-multi>" #'akirak-consult-imenu-multi)
    (:with-map ctl-x-map
      (:keymap "p" #'akirak-consult-project-file))))

akirak-consult-edit

(setup akirak-consult-edit
  (keymap-set ctl-x-r-map "/" #'akirak-consult-edit))

akirak-consult-elisp

(setup akirak-consult-elisp
  (:global-keymap "<remap> <finder-by-keyword>" #'akirak-consult-elisp-package))

akirak-consult-org

(setup akirak-consult-org
  (:global-keymap "M-s M-j" #'akirak-consult-org-clock-history))

akirak-disk

(setup akirak-disk
  (:global-keymap "<f12> d m" #'akirak-disk-findmnt
           "<f12> d b" #'akirak-disk-insert-blkid))

akirak-effect-ts

(setup akirak-effect-ts
  (:keymap "C-, y" #'akirak-effect-ts-insert-yield
           "C-, g" #'akirak-effect-ts-insert-gen)
  (:org-template "software/npm/effect.org"))

akirak-eldoc

(setup akirak-eldoc
  (:global-keymap "C-c e" #'akirak-eldoc-show-buffer))

akirak-elec-pair

(setup akirak-elec-pair
  (:status opinionated
    (:global-keymap "M-i" nil
             "M-i y" #'akirak-elec-pair-wrap-post-yank
             "M-i #" #'akirak-elec-pair-self-insert
             "M-i $" #'akirak-elec-pair-self-insert
             "M-i %" #'akirak-elec-pair-self-insert
             "M-i {" #'akirak-elec-pair-self-insert
             "M-i [" #'akirak-elec-pair-self-insert
             "M-i (" #'akirak-elec-pair-self-insert)))

I once used embrace.el, but it had dependency on expand-region I wanted to get rid of, so I implemented a simpler alternative.

akirak-elisp

(setup akirak-elisp
  (:with-map emacs-lisp-mode-map
    (:keymap "C-c t l" #'akirak-elisp-let-exp)
    (:keymap "C-c t (" #'akirak-elisp-wrap-exp)))

akirak-expand-region

(setup akirak-expand-region
  (:global-keymap "C-M-SPC" #'akirak-expand-region-default))

akirak-git

(setup akirak-git
  (:global "<f12> g r" #'akirak-git-list-remote-pages))

akirak-git-commit

(setup akirak-git-commit
  (add-hook 'after-init-hook #'akirak-git-commit-log-to-org-clock-mode))

akirak-github

(setup akirak-github
  (:global-keymap "<f12> g i" #'akirak-github-browse-issues-web
                  "<f12> g p" #'akirak-github-browse-prs-web
                  "<f12> g l" #'akirak-github-workflow-run-transient))

akirak-header-line

(setup akirak-header-line
  (:hook-into after-init-hook))

akirak-image

(setup akirak-image
  (:nixpkgs "librsvg")
  (:embark embark-url-map "s"
    ("d" akirak-image-insert-offline-link akirak/embark-org-insert-image))
  (:embark embark-file-map nil
    ("C-c i" akirak-image-import-file akirak/embark-import-image-url))
  (add-hook 'org-ctrl-c-ctrl-c-hook #'akirak-image-org-update))

akirak-import

(setup akirak-import
  (:global-keymap "C-c i" #'akirak-import-thing-at-pt))

akirak-insert

(setup akirak-insert)

akirak-log

(setup akirak-log
  (let ((file (locate-user-emacs-file "log/latest.org")))
    (when (file-readable-p file)
      (:set akirak-log-private-file file)
      (with-eval-after-load 'org-agenda
        (add-to-list 'org-agenda-files akirak-log-private-file)))))

akirak-magit

(setup akirak-magit
  (:status personal
    (:set akirak-magit-worktree-category-function
          (defun akirak-git-worktree-category ()
            (or (akirak-git-clone--clock-category)
                (progn
                  (require 'oahu)
                  (pcase oahu-last-view
                    (`(Project ,pr . ,_)
                     (thread-last
                       (project-root pr)
                       (string-remove-suffix "/")
                       (file-name-directory)
                       (string-remove-suffix "/")
                       (file-name-nondirectory)))
                    (`(Org ,x . ,_)
                     (when-let* ((file (seq-find #'stringp x)))
                       (thread-last
                         (file-name-base file)
                         (string-remove-suffix "-dev"))))
                    (`(OrgBookmark . ,bookmark)
                     nil)
                    (_
                     (message "Unsupported type: %s"
                              oahu-last-view)
                     nil))))))))

akirak-narrow

(setup akirak-narrow
  (:global-keymap "C-x n" #'akirak-narrow-or-widen-dwim)
  (advice-add 'org-defkey
          :before-while
          (defun akirak/ad-org-defkey-skip (_keymap key _def)
            (not (equal (kbd "C-x n")
                        (seq-take key 2)))))
  (with-eval-after-load 'org
    (keymap-set org-mode-map "C-x n" #'akirak-narrow-or-widen-dwim)))

akirak-nix

(setup akirak-nix
  (:global-keymap "<f12> n p" #'akirak-nix-search-nixpkgs))

akirak-org

(setup akirak-org
  (:with-feature org
    (:with-map org-mode-map
      (:keymap "<remap> <point-to-register>" #'akirak-org-point-to-register)))

  (:when-loaded
    ;; Alternative to the default implementation provided as
    ;; `org-enforce-todo-dependencies' option.
    (add-hook 'org-blocker-hook #'akirak-org-block-done-by-descendants))

  (advice-add #'org-insert-heading-respect-content
              :around #'akirak-org-ad-around-insert-heading)
  (advice-add #'org-insert-todo-heading-respect-content
              :around #'akirak-org-ad-around-insert-heading)
  (advice-add 'org-return
              :around #'akirak-org-ad-around-org-return)
  (advice-add 'org-meta-return
              :around #'akirak-org-meta-return-split-block-advice))

akirak-org-capture

(setup akirak-org-capture
  (:global-keymap "M-s M-h" #'akirak-org-capture-history))

akirak-org-clock

(setup akirak-org-clock
  (when (and (daemonp)
             ;; Don't enable the mode when troubleshooting.
             (or (getenv "WAYLAND_DISPLAY")
                 (getenv "DISPLAY")))
    (:hook-into emacs-startup-hook))
  (:hook akirak-log-mode)
  ;; (add-hook 'akirak-org-clock-pre-exit-hook
  ;;           (defun akirak/org-clock-save-wconf ()
  ;;             (if (and (require 'burly nil t)
  ;;                      (fboundp 'akirak-burly-clock-push))
  ;;                 (akirak-burly-clock-push)
  ;;               (message "Burly is not available, so the window configuration won't be saved"))))

  (advice-add 'save-buffers-kill-terminal
              :before
              (defun akirak/snooze-before-kill (&rest _)
                (when (bound-and-true-p akirak-org-clock-mode)
                  (akirak-org-clock-snooze 20))))

  (:global-keymap "M-g M-j" #'akirak-org-clock-goto)

  (with-eval-after-load 'org-keys
    (keymap-set org-mode-map "<remap> <org-clock-in>" #'akirak-org-clock-in))

  (keymap-set akirak/c-z-map "o" #'akirak-org-clock-open)
  (keymap-set akirak/c-z-map "p" #'akirak-org-clock-in-to-project)
  (keymap-set akirak/c-z-map "c" #'akirak-org-clock-reclock-commit-entry)
  (keymap-set akirak/c-z-map "g" #'akirak-org-clock-display-commit-entry)
  ;; (keymap-set akirak/c-z-map "I" #'akirak-org-clock-in-dwim)
  ;; (keymap-set akirak/c-z-map "C-i" #'akirak-org-clock-in-dwim)
  (keymap-set akirak/c-z-map "S" #'akirak-org-clock-snooze)
  (keymap-set akirak/c-z-map "C-s" #'akirak-org-clock-snooze)

  (keymap-set akirak/c-z-map "O" #'akirak-org-clock-out)
  (keymap-set akirak/c-z-map "C-o" #'akirak-org-clock-out)
  (keymap-set akirak/c-z-map "d" #'akirak-org-clock-done)
  (keymap-set akirak/c-z-map "r" #'akirak-org-clock-set-review))

akirak-org-log

(setup akirak-org-log
  (:status personal
    (keymap-set help-map "w" #'akirak-org-log-goto-week-entry)))

akirak-org-reg

(setup akirak-org-reg
  (:global-keymap "C-c j" #'akirak-org-reg-transient))

akirak-org-shell

(setup akirak-org-shell
  (:with-feature org
    (:with-map org-mode-map
      (:bind "C-c C-x $" #'akirak-org-shell-transient))))

akirak-org-special

(setup akirak-org-special
  (with-eval-after-load 'org
    (add-hook 'org-ctrl-c-ctrl-c-hook #'akirak-org-special-prompt-send)))

akirak-pandoc

(setup akirak-pandoc
  (:nixpkgs "pandoc"))

akirak-paren

(setup akirak-paren
  (defun akirak/turn-on-paren-jump-mode ()
    (unless (derived-mode-p 'elixir-ts-mode 'heex-ts-mode)
      (akirak-paren-jump-mode t)))

  (:with-mode akirak/turn-on-paren-jump-mode
    ;; Don't turn on the mode in special modes, e.g. vterm.
    (:hook-into prog-mode-hook text-mode-hook))
  (add-hook 'akirak-paren-match-hook #'akirak-paren-syntax-table-match)
  (add-hook 'org-mode-hook
            (defun akirak/setup-org-pair-match ()
              (add-hook 'akirak-paren-match-hook 'akirak-org-matching-pair-location
                        nil t)))

  (:status opinionated
    (:global-keymap "M-i c" #'akirak-paren-replace
             "M-i d" #'akirak-paren-delete
             "M-i SPC" #'akirak-paren-select-inner
             "M-i M-SPC" #'akirak-paren-select-outer)))

akirak-passage

(setup akirak-passage
  (:global-keymap "<f12> S" #'akirak-passage)
  (:when-loaded
    (when (require 'exec-path-from-shell nil t)
      ;; Prevent from evaluating a remote shell
      (akirak-passage-configure-from-shell)))
  (with-eval-after-load 'auth-source
    (add-hook 'auth-source-backend-parser-functions #'akirak-passage-auth-source-parse)
    (add-hook 'auth-sources 'passage)))

akirak-project

(setup akirak-project
  (run-with-idle-timer 70 nil #'akirak-project-remember-this)
  (run-with-idle-timer 180 nil #'akirak-project-rescan)
  (with-eval-after-load 'magit
    (add-hook 'kill-emacs-hook #'akirak-project-import-from-magit))

  (with-eval-after-load 'eglot
    (require 'akirak-project))
  (with-eval-after-load 'project
    (add-hook 'project-find-functions
              ;; This should precede `project-try-vc' entry.
              (defun akirak/project-find-eglot-root (dir)
                "Return the project root specific to LSP (eglot)."
                (when (bound-and-true-p eglot-lsp-context)
                  (or (vc-file-getprop dir 'eglot-vc)
                      (when-let* ((dir (akirak-project-mode-root-directory dir)))
                        (let ((res (list 'eglot dir)))
                          (and res (vc-file-setprop dir 'eglot-vc res))
                          res))))))
    (cl-defmethod project-root ((project (head eglot)))
      (cadr project)))

  (with-eval-after-load "bindings"
    ;; (keymap-set ctl-x-x-map "p" #'akirak-project-switch-to-recent-buffer)
    ;; (keymap-set ctl-x-x-map "o" #'akirak-project-switch-between-impl-and-test)
    ;; (keymap-set ctl-x-x-map "C" #'akirak-project-find-css)
    ;; (keymap-set ctl-x-x-map "T" #'akirak-project-find-test)
    ;; (keymap-set ctl-x-x-map "S" #'akirak-project-find-stories)
    ))

akirak-quick-thing

(setup akirak-quick-thing
  (:global-keymap "M-SPC" #'akirak-quick-thing))

akirak-repl

(setup akirak-repl
  (:global-keymap "C-M-<return>" #'akirak-repl))

akirak-scratch

(keymap-global-set "C-c x" #'akirak-scratch-from-selection)

akirak-shell

(setup akirak-shell
  (:global-keymap "C-c t" #'akirak-shell))

akirak-shr

(setup akirak-shr
  (:hook-into nov-mode-hook))

akirak-systemctl

(setup akirak-systemctl
  (:global-keymap "<f12> s s" #'akirak-systemctl-toggle-unit
           "<f12> s d" #'akirak-systemctl-daemon-reload))

akirak-treesit

(setup akirak-treesit
  (:keymap "<remap> <akirak-expand-region-default>" #'akirak-treesit-expand-region)
  (add-hook 'after-change-major-mode-hook
            (defun akirak/enable-treesit-mode ()
              (when (or (string-suffix-p "-ts-mode" (symbol-name major-mode))
                        (memq major-mode '(neocaml-mode
                                           neocamli-mode)))
                (akirak-treesit-mode t)))))

akirak-twist

(setup akirak-twist
  (with-eval-after-load 'embark
    (keymap-set embark-library-map "f" #'akirak-twist-find-git-source))
  (:global-keymap "<f12> e u" #'akirak-twist-update-emacs-inputs))

akirak-url

Complete a URL from the clipboard and the kill ring and insert as a link

(setup akirak-url
  (:global-keymap "C-c w" #'akirak-url-insert-dwim)
  (:embark embark-url-map "s"
    ("m" akirak-url-insert-as-markdown akirak/embark-markdown-insert-link)
    ("c" akirak-capture-url akirak/embark-capture-url)
    ("g" akirak-git-clone akirak/embark-git-clone-from-url))
  (:embark embark-file-map "s"
    ("C-l" akirak-org-store-link-to-file akirak/embark-org-store-file-link)))

akirak-visual-scroll

(setup akirak-visual-scroll
  (:hook-into org-mode-hook shr-mode-hook))

akirak-wayshot

(when (getenv "WAYLAND_DISPLAY")
  (keymap-global-set "<f12> c s w" #'akirak-wayshot))

akirak-wf-recorder

(when (getenv "WAYLAND_DISPLAY")
  (keymap-global-set "<f12> c r w" #'akirak-wf-recorder))

akirak-window

This is an extra functions for window management.

(setup akirak-window
  (cl-macrolet
      ((major-modes (&rest modes)
         `'(or ,@(mapcar (lambda (mode)
                           (cons 'major-mode mode))
                         modes)))
       (reuse-mode-window (modes function &rest alist)
         `(lambda (buffer alist)
            (or (display-buffer-reuse-mode-window buffer '((mode . ,modes)))
                (,function buffer ',alist)))))
    (dolist (entry `((,(major-modes help-mode devdocs-mode eldoc-mode)
                      ,(reuse-mode-window
                        (help-mode devdocs-mode eldoc-mode)
                        akirak-window-display-document-buffer))
                     ("^\\*aider-"
                      akirak-window-display-as-right-sidebar
                      (window-width . 80))
                     ((or ,(major-modes vterm-mode)
                          "^\\*Nix-REPL\\*"
                          ;; Pop up eat windows if and only if it follows a
                          ;; certain buffer naming convention.
                          "^\\*popup-")
                      ,(reuse-mode-window
                        (vterm-mode nix-repl-mode)
                        akirak-window-display-buffer-split-below
                        (dedicated . t)))
                     (,(major-modes nov-mode pdf-view-mode Info-mode)
                      akirak-window-display-document-buffer)
                     ((major-mode . org-agenda-mode)
                      akirak-window-display-org-agenda-buffer
                      (mode org-agenda-mode))
                     ("^\\*Embark Export"
                      akirak-window-display-as-left-sidebar)
                     ("^\\*Org-Babel Error Output*"
                      display-buffer-no-window
                      (allow-no-window . t))
                     ("^\\*envrc"
                      display-buffer-no-window
                      (allow-no-window . t))
                     ("\\*edit-indirect"
                      akirak-window-display-buffer-split-below)
                     ("^CAPTURE-"
                      akirak-window-display-org-capture-buffer)
                     ("^org-dog header"
                      akirak-window-display-buffer-split-1)
                     ((major-mode . org-mode)
                      akirak-window-display-org-buffer-other-window)
                     ("^\\*deadgrep"
                      display-buffer-use-least-recent-window)
                     ("^\\*Async Shell Command\\*"
                      display-buffer-no-window)
                     ((or ,(major-modes compilation-mode)
                          "-install\\*")
                      ,(reuse-mode-window
                        (compilation-mode comint-mode)
                        display-buffer-use-some-window))))
      (if-let* ((cell (assoc (car entry) display-buffer-alist)))
          (setcdr cell (cdr entry))
        (setq display-buffer-alist (append display-buffer-alist (list entry))))))

  (:status opinionated
    (:with-map ctl-x-map
      ;; I don't need kill-buffer when I have consult-buffer
      (:keymap "k" #'akirak-window-kill-this-buffer))
    (:global-keymap "C-2" #'akirak-window-split-vertically
                    "C-3" #'akirak-window-split-and-select
                    "C-4" #'akirak-window-setup-columns
                    "C-x o" #'akirak-window-cycle-two-windows
                    "C-x M-o" #'akirak-window-swap-two-windows
                    "C-x `" #'akirak-window-column-prefix
                    "C-c v" #'akirak-window-open-in-new-tab
                    "M-o" #'akirak-window-moderate-1
                    "S-<end>" #'akirak-window-display-buffer-ends
                    "S-<home>" #'akirak-window-display-buffer-starts
                    "<remap> <delete-window>" #'akirak-window-delete-window
                    "<remap> <abort-recursive-edit>" #'akirak-window-cleanup)))

akirak-wordnet

(setup akirak-wordnet
  (:nixpkgs "sqlite"))

akirak-worktree

(setup akirak-worktree
  (add-hook 'after-init-hook #'akirak-worktree-global-mode))

Packages

A bunch of useful packages are configured here.

academic-phrases

Bypass that mental block when writing your papers.

(setup (:package academic-phrases))

aggressive-indent

Minor mode to aggressively keep your code always indented https://github.com/Malabarba/aggressive-indent-mode

(setup (:package aggressive-indent)
  (:hook-into emacs-lisp-mode-hook
              dune-mode-hook))

anzu

Show number of matches in mode-line while searching

(setup (:package anzu)
  (:with-mode global-anzu-mode
    (:hook-into after-init-hook))

  (:global-keymap "<remap> <query-replace>" #'anzu-query-replace
           "<remap> <query-replace-regexp>" #'anzu-query-replace-regexp))

apheleia

Reformat buffer stably

(setup (:package apheleia)
  (:when-loaded
    ;; This is loaded by default, but just in case
    (require 'apheleia-formatters)
    (add-to-list 'apheleia-formatters '(eslint . akirak/apheleia-eslint-fix-buffer))
    (cl-defun akirak/apheleia-eslint-fix-buffer (&key buffer scratch callback &allow-other-keys)
      "Format a buffer using eslint --fix."
      (with-current-buffer scratch
        ;; direnv requires true names to inherit the permission
        (let* ((default-directory (file-truename (locate-dominating-file default-directory "package.json")))
               (target-file (file-truename (buffer-local-value 'buffer-file-name buffer)))
               (eslint (expand-file-name "node_modules/.bin/eslint" default-directory)))
          (apply #'call-process-region (point-min) (point-max)
                 (append (if (locate-dominating-file default-directory ".envrc")
                             (list "direnv"
                                   ;; FIXME: Error messages are discarded.
                                   t (list t nil) nil
                                   "exec"
                                   eslint)
                           (list eslint
                                 t (list t nil) nil))
                         (list "--fix-dry-run" "-f" "json"
                               "--stdin"
                               "--stdin-filename"
                               (file-relative-name target-file))))
          (goto-char (point-min))
          (let ((output (thread-last
                          (condition-case err
                              (json-parse-buffer :object-type 'alist :array-type 'list)
                            (error (message "Parsing JSON failed: %s\n%s"
                                            err (buffer-string))))
                          (car)
                          (alist-get 'output))))
            (unless output
              (error "Null output from eslint"))
            (delete-region (point-min) (point-max))
            (insert output)
            (funcall callback)))))))

My preferred way to use apheleia is to set the apheleia-formatter local variable and enable apheleia-mode in individual buffers. For simpler use cases, I prefer reformatter, so I don’t turn on apheleia-global-mode.

auto-minor-mode

Enable minor modes by file name and contents https://github.com/joewreschnig/auto-minor-mode

(setup (:package auto-minor-mode)
  (:require))

auto-yasnippet

Quickly create disposable yasnippets https://github.com/abo-abo/auto-yasnippet

(setup (:package auto-yasnippet)
  (:global-keymap "C-x r e" #'aya-expand
           "C-x r M-e" #'aya-expand-from-history
           "C-x r a" #'aya-create))

avy

Jump to arbitrary positions in visible text and select text quickly. https://github.com/abo-abo/avy

(setup (:package avy)
  (:set avy-style 'pre
        avy-styles-alist '((avy-goto-char . at)
                           (avy-goto-char-timer . at-full))
        avy-all-windows t)
  (:global-keymap "C-\"" #'avy-goto-char-timer
                  "C-'" #'avy-goto-char-in-line))

I only use this package via my custom wrappers defined in lisp/akirak-avy.el and other files.

beancount

A major mode to edit Beancount input files.

(setup (:package beancount)
  (:nixpkgs "beancount")

  ;; I don't like the default keybindings on C-c, so change the prefix.
  (:set beancount-mode-map-prefix (kbd akirak/mode-prefix-key))

  (:reformatters
   (bean-format :program "bean-format"))

  (:with-mode beancount-mode
    (:file-match "\\.beancount\\'" "\\.bean\\'")
    (:hook bean-format-on-save-mode
           flymake-bean-check-enable)

    (:when-loaded
      (:keymap "C-c C-o" #'akirak-beancount-locate-account-transactions)
      (keymap-set beancount-mode-map
                  (format "%s d" beancount-mode-map-prefix)
                  #'akirak-beancount-insert-date)

      (:hook
       (defun akirak/beancount-turn-on-outline-mode ()
         (outline-minor-mode t))))))

blamer

Show git blame info about current line https://github.com/artawower/blamer.el

(setup (:package blamer)
  (:set blamer-max-lines 50
        blamer-max-commit-message-length 50)

  (keymap-set ctl-x-x-map "b" #'blamer-mode)
  (keymap-set help-map "M-g" #'blamer-show-commit-info))

bookmark-frecency

Sort bookmarks by frecency https://github.com/akirak/bookmark-frecency.el

(setup (:package bookmark-frecency)
  (:hook-into after-init-hook))

browse-at-remote

Open github/gitlab/bitbucket/stash/gist/phab/sourcehut page from Emacs

(setup (:package browse-at-remote)
  (:global-keymap "<f12> g g" #'browse-at-remote
           "<f12> g w" #'browse-at-remote-kill))

burly

Save and restore frame/window configurations with buffers https://github.com/alphapapa/burly.el

(setup (:package burly))

buttercup

Behavior-Driven Emacs Lisp Testing https://github.com/jorgenschaefer/emacs-buttercup

(setup (:package buttercup)
  (:with-hook emacs-lisp-mode-hook
    (:hook (defun akirak/buttercup-setup ()
             (when (and (buffer-file-name)
                        (string-match-p (rx (any "-/") "test" (?  "s") ".el" eol)
                                        (buffer-file-name)))
               (buttercup-minor-mode t)))))

  (:when-loaded
    ;; Work around the duplicate lines issue.
    ;; See https://github.com/jorgenschaefer/emacs-buttercup/issues/181
    ;; (advice-add #'buttercup-reporter-interactive
    ;;             :before-while
    ;;             (defun akirak/ad-bf-reporter-interactive (event arg)
    ;;               (not (eq event `spec-started))))

    ;; (advice-add #'buttercup-colorize :filter-return #'xterm-color-filter)
    ))

cape

Completion At Point Extensions https://github.com/minad/cape

(setup (:package cape)
  ;; This is a custom convention. You need to create a words file in the
  ;; directory for yourself.
  (:when-loaded
    (require 'xdg)
    (:set cape-dict-file (expand-file-name "dict/words" (xdg-data-home))))

  (:global-keymap "C-x r M-f" #'cape-file
           "C-x r M-l" #'cape-line
           "C-M-/" #'cape-dabbrev))

casual

Transient user interfaces for various modes https://github.com/kickingvegas/casual

(setup (:package casual)
  (:nixpkgs graphicsmagick-imagemagick-compat
            ;; Implicitly required for some commands of casual-image
            file)
  (:with-feature image-mode
    (:also-load casual-image)
    (:keymap "C-," #'casual-image-tmenu))
  (:with-feature dired
    (:keymap "C-," #'casual-dired-tmenu))
  (:with-feature calc
    (:keymap "C-," #'casual-calc-tmenu)))

consult

Consulting completing-read https://github.com/minad/consult

(setup (:package consult)
  (:with-mode consult-preview-at-point-mode
    (:hook completion-list-mode))

  ;; (advice-add #'completing-read-multiple :override #'consult-completing-read-multiple)

  (:set consult-narrow-key "<"
        consult-project-root-function (defun akirak/consult-project-root ()
                                        (when-let* ((project (project-current)))
                                          (project-root project))))

  (advice-add 'consult--buffer-action
              :filter-args
              (defun akirak/ad-switch-to-buffer (args)
                (let ((buffer (car args)))
                  (cons (or (get-buffer buffer)
                            (cl-flet
                                ((pred (ent)
                                   (when (string-match-p (car ent) buffer)
                                     (pcase ent
                                       (`(,_ ,func ,_)
                                        func)
                                       (`(,_ . ,func)
                                        func)))))
                              (with-current-buffer (generate-new-buffer buffer)
                                (when-let* ((mode (seq-some #'pred auto-mode-alist)))
                                  (set-auto-mode-0 mode))
                                (current-buffer))))
                        (cdr args)))))

  (:when-loaded
    (:set consult-buffer-sources `(consult--source-project-buffer
                                   consult--source-project-recent-file
                                   ,@(when (require 'akirak-consult nil t)
                                       '(akirak-consult-source-help-buffer
                                         akirak-consult-source-indirect-or-org-src-buffer
                                         akirak-consult-source-narrowed-buffer
                                         akirak-consult-source-org-agenda-buffer
                                         akirak-consult-source-modified-buffer))
                                   akirak-consult-source-tab-bar-tab
                                   consult--source-buffer
                                   consult--source-recent-file)
          ;; Use only relevant bookmark groups.
          consult-bookmark-narrow '((?f "File or directory" bookmark-default-handler)
                                    (?h "Help" help-bookmark-jump)
                                    (?i "Info" Info-bookmark-jump)
                                    ;; (?p "Picture" image-bookmark-jump)
                                    ;; (?d "Docview" doc-view-bookmark-jump)
                                    ;; (?m "Man" Man-bookmark-jump)
                                    (?w "Woman" woman-bookmark-jump)
                                    ;; (?g "Gnus" gnus-summary-bookmark-jump)
                                    ;; (?s "Eshell" eshell-bookmark-jump)
                                    (?e "Eww" eww-bookmark-jump)
                                    ;; (?v "VC Directory" vc-dir-bookmark-jump)

                                    ;; Non-default
                                    (?o "Org" org-bookmark-heading-jump)
                                    (?v "Org Placeholder" org-rooted-view))
          consult-ripgrep-args (concat (eval (car (get 'consult-ripgrep-args 'standard-value)) t)
                                       ;; Show files in .github directory, for example.
                                       " --hidden --ignore-file=.gitignore --iglob=!.git")))

  (:global-keymap "<remap> <switch-to-buffer>" #'consult-buffer
                  "<remap> <bookmark-jump>" #'consult-bookmark
                  "<remap> <yank-pop>" #'consult-yank-pop
                  "M-s o" #'consult-outline
                  "C-S-s" #'consult-line
                  "M-s l" #'consult-focus-lines
                  "C-x /" #'consult-ripgrep)

  (:with-feature consult-imenu
    (:global-keymap "M-s i" #'consult-imenu
                    "<remap> <imenu>" #'consult-imenu
                    "M-s M-i" #'consult-imenu-multi))

  ;; (:with-feature consult-flymake
  ;;   (:global-keymap "M-s f" #'consult-flymake))

  (:with-feature consult-xref
    (:set xref-show-xrefs-function #'consult-xref
          xref-show-definitions-function #'consult-xref)))

consult-ls-git

Consult integration for git https://github.com/rcj/consult-ls-git

(setup (:package consult-ls-git)
  (with-eval-after-load 'embark
    (add-to-list 'embark-keymap-alist
                 '(consult-ls-git-status . akirak-embark-git-file-map))))

consult-recoll

Recoll queries using consult

(setup (:package consult-recoll)
  (:global-keymap "M-s M-c" #'consult-recoll)
  (:set consult-recoll-open-fn
        (defun akirak/consult-recoll-open-file (file &optional _page)
          (org-open-file file))

        consult-recoll-format-candidate
        (defun akirak/consult-recoll-format-candidate (title urln _mime)
          (concat title
                  (propertize (format " (%s)"
                                      (thread-last
                                        urln
                                        (file-name-directory)
                                        (string-remove-prefix "file://")
                                        (abbreviate-file-name)))
                              'face 'font-lock-doc-face)))))

copilot

An unofficial Copilot plugin https://github.com/copilot-emacs/copilot.el

(setup (:package copilot)
  (:nixpkgs copilot-language-server)

  (:keymap "<remap> <expand-abbrev>" #'akirak-copilot-abbrev-or-complete
           ;; Remap repl-toggle in the minor mode map.
           "M-RET" #'akirak-copilot-accept-dwim
           "C-M-n" #'copilot-next-completion
           "C-M-p" #'copilot-previous-completion
           "M-F" #'copilot-accept-completion-by-word
           "M-E" #'copilot-accept-completion-by-line)
  (:when-loaded
    ;; Look up the command bound in global-map and use it as the fallback
    ;; command.
    (when-let* ((keys (where-is-internal #'akirak-copilot-accept-dwim
                                         copilot-mode-map))
                (command (lookup-key global-map (car keys))))
      (setq akirak-copilot-accept-fallback command))))

corfu

COmpletion in Region FUnction https://github.com/minad/corfu

(setup (:package corfu)
  (:with-mode (prog-mode text-mode comint-mode)
    (:hook corfu-mode))

  (:hook corfu-popupinfo-mode)
  (:set corfu-popupinfo-delay '(1.5 . 1.0))

  (:with-hook minibuffer-setup-hook
    (:hook
     (defun corfu-enable-in-minibuffer ()
       "Enable Corfu in the minibuffer if `completion-at-point' is bound."
       (when (where-is-internal #'completion-at-point (list (current-local-map)))
         (corfu-mode 1)))))

  (:with-mode (prog-mode text-mode)
    (:keymap "M-/" #'completion-at-point))
  (:with-feature comint
    (:keymap "M-/" #'completion-at-point)))

cosmetic-transient

A transient for cosmetics on source code https://github.com/akirak/cosmetic-transient.el

(setup (:package cosmetic-transient)
  (:global-keymap "C-c m" #'cosmetic-transient))

csv-mode

Major mode for editing comma/char separated values

(setup (:package csv-mode)
  (:file-match "\\.csv\\'"))

cue-mode

Major mode for CUE language files https://github.com/russell/cue-mode

(setup (:package cue-mode)
  (:file-match "\\.cue\\'"))

d2-mode

Major mode for working with d2 graphs https://github.com/andorsk/d2-mode

(setup (:package d2-mode)
  ;; d2-format is a custom wrapper for `d2 fmt` available from
  ;; https://github.com/akirak/flake-pins
  (:nixpkgs d2 customPackages.d2-format)
  (:file-match "\\.d2\\'")
  (:hook d2-format-on-save-mode)
  (:reformatters
   (d2-format :program "d2-format"))
  (:keymap "C-c C-w" #'akirak/d2-watch-file)
  (defun akirak/d2-watch-file ()
    "Watch the current file."
    (interactive nil d2-mode)
    (compile (format "d2 -w %s" (shell-quote-argument (or (buffer-file-name)
                                                          (user-error "Not visiting a file")))))))

daemons

UI for managing init system daemons (services) https://github.com/cbowdon/daemons.el

(setup (:package daemons)
  (:global-keymap "<f12> x d" #'daemons))

dashboard

A startup screen extracted from Spacemacs https://github.com/emacs-dashboard/emacs-dashboard

(setup (:package dashboard)
  (:set dashboard-center-content t
        dashboard-show-shortcuts t
        dashboard-set-init-info nil
        dashboard-set-footer nil
        dashboard-banner-logo-title nil
        dashboard-display-icons-p #'ignore
        dashboard-projects-backend 'project-el
        dashboard-item-shortcuts '((recents . "r")
                                   (bookmarks . "m")
                                   ;; Don't use p
                                   (projects . "j")
                                   (org-clock . "c")
                                   (custom-agenda . "a")
                                   ;; Unused
                                   (agenda . "a")
                                   (registers . "e"))
        dashboard-items '((custom-agenda . 10)
                          (org-clock . 7)
                          (projects . 8)
                          (bookmarks . 10)
                          (recents . 15)))
  (:when-loaded
    (require 'akirak-dashboard)
    (add-to-list 'dashboard-item-generators
                 (cons 'org-clock 'akirak-dashboard-org-clock-insert))
    (add-to-list 'dashboard-item-generators
                 (cons 'custom-agenda 'akirak-dashboard-insert-agenda)))

  ;; I'm no longer an evil user. Prefer n/p over j/k.
  (:keymap "n" #'dashboard-next-line
           "p" #'dashboard-previous-line)
  (:keymap-unset "j" "k")

  (:global-keymap "C-z b" #'dashboard-open)

  (defun akirak/dashboard-init-on-startup ()
    (require 'dashboard)
    (dashboard-insert-startupify-lists)
    (add-hook 'server-after-make-frame-hook
              (defun akirak/server-dashboard-initialize ()
                (unless (seq-find
                         (lambda (buf)
                           (buffer-local-value 'server-buffer-clients buf))
                         (buffer-list))
                  (dashboard-initialize))))))

deadgrep

fast, friendly searching with ripgrep https://github.com/Wilfred/deadgrep

(setup (:package deadgrep)
  (:set deadgrep-display-buffer-function #'pop-to-buffer
        ;; Show hidden files as well
        deadgrep-extra-arguments '("--no-config"
                                   ;; Show files in .github directory, for example.
                                   "--hidden"
                                   "--ignore-file=.gitignore"
                                   "--iglob=!.git")))

devdocs

Emacs viewer for DevDocs https://github.com/astoff/devdocs.el

(setup (:package devdocs)
  (keymap-set help-map "d" #'devdocs-lookup))

diff-hl

Highlight uncommitted changes using VC https://github.com/dgutov/diff-hl

(setup (:package diff-hl)
  ;; Only enable diff-hl-mode in certain directories.
  ;; See edit dir-locals class in the files section.
  ;; (add-hook 'after-init-hook #'global-diff-hl-mode)

  (add-hook 'akirak-worktree-file-mode-hook #'diff-hl-mode)

  (add-hook 'dired-mode-hook #'diff-hl-dired-mode)
  (:set diff-hl-command-prefix (kbd "C-c g")
        diff-hl-show-staged-changes t
        ;; https://github.com/magit/magit/discussions/5167
        diff-hl-update-async nil)

  ;; Prevent dispatch of repeat-mode.
  (defalias 'akirak/diff-hl-next-hunk #'diff-hl-next-hunk)
  (defalias 'akirak/diff-hl-previous-hunk #'diff-hl-previous-hunk)

  (:global-keymap "M-g j" #'akirak/diff-hl-next-hunk
           "M-g k" #'akirak/diff-hl-previous-hunk)

  (:when-loaded
    (keymap-set diff-hl-command-map "c" #'magit-commit)
    (defun akirak/diff-hl-after-navigation (orig &rest args)
      ;; (when (buffer-narrowed-p)
      ;;   (widen))
      (let ((pos (point)))
        (prog1 (apply orig args)
          (unless (eq pos (point))
            (when (derived-mode-p 'org-mode)
              (if (org-at-heading-p)
                  (org-fold-show-entry)
                (org-fold-show-context)))))))

    (advice-add 'diff-hl-next-hunk
                :around #'akirak/diff-hl-after-navigation)
    (advice-add 'diff-hl-previous-hunk
                :around #'akirak/diff-hl-after-navigation)))

dired-collapse

Collapse unique nested paths in dired listing https://github.com/Fuco1/dired-hacks

(setup (:package dired-collapse))

I will manually turn on dired-collapse-mode when necessary.

dired-filter

Ibuffer-like filtering for dired https://github.com/Fuco1/dired-hacks

(setup (:package dired-filter)
  (:hook-into dired-mode-hook)
  (:hook dired-filter-group-mode)

  (:set dired-omit-extensions nil)
  (:when-loaded
    (:set dired-filter-group-saved-groups
          `(("default" ,@(akirak-dired-filter-build-default-groups))))))

dired-hacks-utils

Utilities and helpers for dired-hacks collection https://github.com/Fuco1/dired-hacks

(setup (:package dired-hacks-utils)
  (:with-map dired-mode-map
    ;; Remap 'n' and 'p'
    "n" 'dired-hacks-next-file
    "p" 'dired-hacks-previous-file))

dired-open-with

And “Open with” dialog for Dired https://github.com/FrostyX/dired-open-with

(setup (:package dired-open-with))

dired-x

(setup dired-x
  (:with-map dired-mode-map
    (:keymap-unset "C-x M-o")))

docco

A framework for editing documentation comments https://github.com/akirak/docco.el

(setup (:package docco))

docker

Interface to Docker https://github.com/Silex/docker.el

(setup (:package docker)
  (:global-keymap "<f12> k k" #'docker-containers
           "<f12> k i" #'docker-images
           "<f12> k v" #'docker-volumes
           "<f12> k n" #'docker-networks))

docopt

A Docopt implementation in Elisp

(setup (:package docopt))

dotenv-mode

Major mode for .env files https://github.com/preetpalS/emacs-dotenv-mode

(setup (:package dotenv-mode)
  (:file-match "\\.env\\(?:\\.[a-z]+\\)?\\'"))

duckduckgo

Run DuckDuckGo search https://github.com/akirak/duckduckgo.el

(setup (:package duckduckgo)
  ;; Replace `eww-search-words'
  (:global-keymap "M-s M-w" #'duckduckgo))

dumb-jump

Jump to definition for 50+ languages without configuration https://github.com/jacktasia/dumb-jump

(setup (:package dumb-jump)
  (:set dumb-jump-selector #'completing-read)

  ;; NOTE: The activation function should be added to the end
  ;; of the backend function. Is this really sufficient?
  (add-hook 'xref-backend-functions #'dumb-jump-xref-activate)

  (add-hook 'emacs-lisp-mode-hook
            ;; Make dumb-jump take precedence over the builtin backend,
            ;; to search the project code whenever possible.
            (defun akirak/elisp-setup-dumb-jump ()
              (add-hook 'xref-backend-functions
                        #'dumb-jump-xref-activate
                        80 'local))))

dune

Integration with the dune build system https://github.com/ocaml/dune

(setup (:package dune)
  (:mode-repl akirak/utop-project))

eat

Emulate A Terminal, in a region, in a buffer and in Eshell

(setup (:package eat)
  (:set eat-kill-buffer-on-exit t)
  (:with-map eat-semi-char-mode-map
    (:keymap "S-<prior>" #'View-scroll-page-backward
             "S-<next>" #'View-scroll-page-forward)
    (:keymap-unset "M-:" "M-g" "M-s" "C-z" "M-o" "M-'"
                   "M-0" "M-1" "M-2" "M-3" "M-4" "M-5" "M-6" "M-7" "M-8" "M-9"))

  ;; Switch to line-mode automatically.
  (:hook (defun akirak/eat-setup ()
           (add-hook 'post-command-hook #'akirak/eat-auto-line-mode 90 'local)))
  (defvar-local akirak/eat-previous-mode nil)
  (defun akirak/eat-record-mode ()
    (setq akirak/eat-previous-mode
          (cl-case (seq-find #'symbol-value '(eat--semi-char-mode
                                              eat--char-mode
                                              eat--line-mode))
            (eat--semi-char-mode 'eat-semi-char-mode)
            (eat--char-mode 'eat-char-mode)
            (eat--line-mode 'eat-line-mode))))
  (defun akirak/eat-restore-mode ()
    (when akirak/eat-previous-mode
      (funcall akirak/eat-previous-mode)
      (setq akirak/eat-previous-mode nil)))
  (defun akirak/eat-auto-line-mode ()
    (cl-case this-command
      (avy-goto-char-timer
       (akirak/eat-record-mode)
       (eat-line-mode))
      (kill-ring-save
       (akirak/eat-restore-mode)))))

ediprolog

Emacs Does Interactive Prolog

(setup (:package ediprolog)
  ;; Set `ediprolog-system' and `ediprolog-program' depending on the system

  (:with-feature prolog
    ;; In other modes, this key is bound to repl.
    (:keymap "C-<return>" #'ediprolog-dwim)))

scryer-prolog is the bleeding-edge implementation of Prolog (like GHC to Haskell), and it is installed with this package.

eglot

Client for Language Server Protocol (LSP) servers https://github.com/joaotavora/eglot

(setup eglot

  (:set eglot-confirm-server-initiated-edits nil
        eglot-autoshutdown t
        eglot-code-action-indications nil
        eglot-extend-to-xref t)

  (:keymap akirak/mode-prefix-key #'akirak/eglot-prefix-map)

  (defun akirak/eglot-ensure ()
    (when (buffer-file-name)
      (eglot-ensure)))

  (defun akirak/eglot-ensure-with-formatter ()
    (add-hook 'eglot-managed-mode-hook #'akirak/eglot-setup-buffer nil t)
    (akirak/eglot-ensure))

  (defun akirak/eglot-setup-buffer ()
    (if (eglot-managed-p)
        (add-hook 'before-save-hook #'eglot-format-buffer nil t)
      (remove-hook 'before-save-hook #'eglot-format-buffer t)))

  (defun akirak/eglot-rename-dwim ()
    (interactive)
    (or (akirak-treesit-maybe-rename-tag)
        (call-interactively #'eglot-rename)))

  (:with-feature typescript-ts-mode
    (:with-map tsx-ts-mode-map
      (:keymap "<remap> <eglot-rename>" #'akirak/eglot-rename-dwim)))

  (:when-loaded
    (define-prefix-command 'akirak/eglot-prefix-map)
    (:with-map akirak/eglot-prefix-map
      (:keymap "a" #'eglot-code-actions
               "i" #'eglot-code-action-inline
               "q" #'eglot-code-action-quickfix
               "o" #'eglot-code-action-organize-imports
               "R" #'eglot-reconnect
               "r" #'eglot-rename))

    ;; (add-to-list 'eglot-server-programs
    ;;              `(((js-mode :language-id "javascript")
    ;;                 (js-ts-mode :language-id "javascript")
    ;;                 (tsx-ts-mode :language-id "typescriptreact")
    ;;                 (typescript-ts-mode :language-id "typescript")
    ;;                 (typescript-mode :language-id "typescript"))
    ;;                . ,(eglot-alternatives
    ;;                    '(("typescript-language-server" "--stdio")
    ;;                      ("deno" "lsp")))))
    (add-to-list 'eglot-server-programs
                 `((nix-ts-mode nix-mode) . ("nil")))
    (add-to-list 'eglot-server-programs
                 '(just-mode . ("just-lsp")))
    (add-to-list 'eglot-server-programs
                 '(lean4-mode . ("lake" "serve")))
    (add-to-list 'eglot-server-programs
                 '(svelte-mode . ("svelteserver" "--stdio")))
    (add-to-list 'eglot-server-programs
                 '(hcl-mode . ("terraform-lsp" "--stdio")))
    (add-to-list 'eglot-server-programs
                 '((neocaml-mode :language-id "ocaml") . ("ocamllsp")))
    (add-to-list 'eglot-server-programs
                 '((neocamli-mode :language-id "ocamli") . ("ocamllsp")))
    (add-to-list 'eglot-server-programs
                 '(coq-mode . ("coq-lsp")))
    (add-to-list 'eglot-server-programs
                 '(gleam-ts-mode . ("gleam" "lsp")))
    (add-to-list 'eglot-server-programs
                 '(zig-ts-mode . ("zls")))
    ;; I won't use the eglot-fsharp package which seems involved too much. Just
    ;; install fsautocomplete (e.g. via Nix) and don't rely on automatic
    ;; installation.
    (add-to-list 'eglot-server-programs
                 '(fsharp-mode . ("fsautocomplete" "--adaptive-lsp-server-enabled")))
    (add-to-list 'eglot-server-programs
                 `((elixir-ts-mode heex-ts-mode elixir-mode) .
                   ,(eglot-alternatives
                     '(("lexical")
                       ("nextls" "--stdio=true"
                        :initializationOptions
                        (:experimental (:completions (:enable t))))
                       ("elixir-ls")))))
    (add-to-list 'eglot-server-programs
                 '(astro-ts-mode
                   . ("astro-ls" "--stdio"
                      :initializationOptions
                      (:typescript (:tsdk "./node_modules/typescript/lib")))))

    (put 'tsx-mode 'eglot-language-id "typescriptreact")
    (put 'lean4-mode 'eglot-language-id "lean")))

ocaml-eglot

An OCaml companion for Eglot https://github.com/tarides/ocaml-eglot

(setup (:package ocaml-eglot)
  (add-hook 'ocaml-eglot-hook #'eglot-ensure))

eglot-booster

Boost eglot using lsp-booster

(setup (:package eglot-booster)
  (:nixpkgs emacs-lsp-booster)
  (:set eglot-booster-no-remote-boost t)
  (with-eval-after-load 'eglot
    (eglot-booster-mode)))

eldoc-eval

Enable eldoc support when minibuffer is in use.

(setup (:package eldoc-eval)
  (:with-mode eldoc-in-minibuffer-mode
    (:hook-into after-init-hook)))

I use this package mostly because it uses pp-eval-expression for printing the result, but it also has some other nice features, and it works flawlessly.

elx

Extract information from Emacs Lisp libraries

(setup (:package elx))

elysium

Automatically apply LLM-created code-suggestions https://github.com/lanceberge/elysium/

(setup (:package elysium)
  (:when-loaded
    (add-hook 'elysium-apply-changes-hook #'smerge-start-session))
  (with-eval-after-load 'gptel-transient
    (transient-append-suffix 'gptel-menu '(-1 0)
      '("q" "Elysium" elysium-query))))

embark

Conveniently act on minibuffer completions https://github.com/oantolin/embark

(setup (:package embark)
  (:global-keymap "C-." #'embark-act
                  "C->" #'embark-act-all)

  (keymap-set minibuffer-mode-map "C-," #'embark-become)
  (keymap-set minibuffer-mode-map "C-SPC" #'embark-select)

  (add-hook 'embark-after-export-hook
            (defun akirak/embark-after-export ()
              (when (derived-mode-p 'dired-mode)
                (dired-hide-details-mode 1))))

  (:when-loaded
    (when (require 'akirak-embark nil t)
      (akirak-embark-setup))))

Some notes:

embark-next/previous-symbol could replace symbol-overlay package.
embark-export can be a useful alternative to tabulated-list.
Binding sudo-find-file command may be useful, but I haven’t done it yet.

The following resources are useful:

Fifteen ways to use Embark | Karthinks

embark-consult

Consult integration for Embark https://github.com/oantolin/embark

(setup (:package embark-consult)

  (with-eval-after-load 'consult
    (require 'embark-consult))
  (with-eval-after-load 'embark
    (require 'embark-consult))

  (:with-mode embark-collect-mode
    (:hook consult-preview-at-point-mode)))

embark-org

(setup embark-org
  (with-eval-after-load 'org
    (when (require 'akirak-embark nil t)
      (akirak-embark-setup-org))))

envrc

Support for `direnv’ that operates buffer-locally

(setup (:package envrc)
  (defun akirak/turn-on-envrc-mode ()
    (unless (minibufferp)
      (envrc-mode 1)))
  (add-hook 'akirak-worktree-mode-hook #'akirak/turn-on-envrc-mode))

epkg

Browse the Emacsmirror package database

(setup (:package epkg)
  (:set epkg-database-connector 'sqlite-builtin))

epkg-marginalia

Show Epkg information in completion annotations

(setup (:package epkg-marginalia)
  (with-eval-after-load 'marginalia
    (cl-pushnew 'epkg-marginalia-annotate-package
                (alist-get 'package marginalia-annotator-registry))))

erlang

Major modes for editing and running Erlang

(setup (:package erlang))

exec-path-from-shell

Get environment variables such as $PATH from the shell https://github.com/purcell/exec-path-from-shell

(setup (:package exec-path-from-shell)
  (when (or window-system
            (daemonp))
    (require 'exec-path-from-shell)
    (when (equal akirak/os-id "nixos")
      (setq exec-path-from-shell-variables nil))
    (unless (or (eq system-type 'darwin)
                (equal akirak/os-id "nixos"))
      (add-to-list 'exec-path-from-shell-variables "XDG_CONFIG_HOME")
      (add-to-list 'exec-path-from-shell-variables "XDG_CACHE_HOME")
      (add-to-list 'exec-path-from-shell-variables "XDG_DATA_HOME"))
    (when exec-path-from-shell-variables
      (exec-path-from-shell-initialize))))

flymake-eslint

A Flymake backend for Javascript using eslint https://github.com/orzechowskid/flymake-eslint

(setup (:package flymake-eslint)
  (:set flymake-eslint-defer-binary-check t))

flymake-shellcheck

A bash/sh Flymake backend powered by ShellCheck

(setup (:package flymake-shellcheck)
  (:nixpkgs "shellcheck"))

flymake-sqlfluff

A flymake plugin for SQL files using sqlfluff https://github.com/erickgnavar/flymake-sqlfluff

(setup (:package flymake-sqlfluff)
  (:nixpkgs sqlfluff)
  (add-hook 'sql-mode-hook
            (defun akirak/flymake-sqlfluff-setup ()
              (flymake-sqlfluff-load)
              (flymake-mode)))

  ;; Also define the formatter
  (:reformatters
   (sqlfluff-format
    :program "sqlfluff"
    ;; Use the same dialect as flymake-sqlfluff
    :args (list "format" "--dialect" flymake-sqlfluff-dialect "-"))))

fsharp-mode

Support for the F# programming language

(setup (:package fsharp-mode)
  (:project-roots "*.fsproj" "*.sln")
  (:when-loaded
    (fset 'fsharp-mode-project-root #'ignore)))

fwb-cmds

misc frame, window and buffer commands

(setup (:package fwb-cmds))

I need this package for fwb-toggle-window-split command.

git-attr

Git attributes of buffer file https://github.com/arnested/emacs-git-attr

Make vendored and generated files read only.

(setup (:package git-attr)
  (add-hook 'find-file-hook #'git-attr-linguist))

git-auto-commit-mode

Emacs Minor mode to automatically commit and push https://github.com/ryuslash/git-auto-commit-mode

(setup (:package git-auto-commit-mode)
  (:set gac-silent-message-p t
        gac-default-message #'akirak/git-auto-commit-message)

  (defun akirak/git-auto-commit-message (filename)
    (when-let* ((pr (project-current nil (file-name-directory filename)))
                (root (project-root pr)))
      (thread-last
        (if (org-clocking-p)
            (let* ((clocking-file (buffer-file-name (org-base-buffer
                                                     (marker-buffer
                                                      org-clock-marker))))
                   (category (file-name-base clocking-file)))
              (cond
               ((string-prefix-p "~/work/" root)
                (org-link-display-format org-clock-current-task))
               ((string-prefix-p "~/work2/" root)
                (org-link-display-format org-clock-current-task))
               ((string-prefix-p (expand-file-name root)
                                 clocking-file)
                (format "%s: %s\n\n%s"
                        category
                        (org-link-display-format org-clock-current-task)
                        ;; By using the link format of Org, it will enable the
                        ;; user to navigate to the referenced entry.
                        (org-link-make-string
                         (concat "id:"
                                 (with-current-buffer (marker-buffer org-clock-marker)
                                   (org-with-wide-buffer
                                    (goto-char org-clock-marker)
                                    (org-id-get-create)))))))
               (t
                "!Working on a task in another repository")))
          (concat "Modified " (file-relative-name filename root)))
        ;; Add a prefix to indicate it is a machine commit
        (concat "(auto) "))))

  (with-eval-after-load 'org-clock
    (add-hook 'org-clock-out-hook
              (defun akirak/gac-org-clock-out ()
                "Create an auto commit after `org-clock-out'."
                (when (and (bound-and-true-p git-auto-commit-mode)
                           ;; If the entry has at least one auto commit
                           (> (org-clock-sum-current-item
                               (- (float-time)
                                  gac-debounce-interval
                                  60))
                              0))
                  ;; I often refile the clocked entry immediately after clocking
                  ;; out from it, so rather than instantly creating a commit,
                  ;; defer it.
                  (when-let* ((pr (project-current))
                              (root (project-root pr)))
                    (if (file-directory-p root)
                        (run-with-timer
                         20 nil
                         `(lambda ()
                            (let ((default-directory ,root))
                              (save-some-buffers t (save-some-buffers-root))
                              (unless (zerop (call-process "git" nil nil nil
                                                           ;; Reuse the message
                                                           "commit" "-C" "HEAD"
                                                           "-a"))
                                (message "Git auto commit failed in %s"
                                         default-directory)))))
                      (message "Directory %s does not exist" root))))))))

A recommended way to turn on automatic commits is to define local variables in .dir-locals.el, e.g.:

((org-mode . ((gac-debounce-interval . 180)
              (eval . (git-auto-commit-mode t)))))

git-commit

Edit Git commit messages

(setup git-commit
  ;; Use `add-hook' to control the depth.
  (add-hook 'git-commit-mode-hook
            (defun akirak/git-commit-auto-insert ()
              (when (and (bolp) (eolp))
                (let ((this-command 'auto-insert))
                  (auto-insert))))
            80)

  (:auto-insert
   ("\\.git/COMMIT_EDITMSG\\'"
    . (> _ (when-let* ((marker (and (featurep 'org-clock)
                                    (org-clocking-p)
                                    (or org-clock-hd-marker
                                        org-clock-marker)))
                       (heading (org-entry-get marker "ITEM")))
             (with-temp-buffer
               (insert heading)
               (goto-char (point-min))
               (when (looking-at (rx (+ (any word punct)) ": "))
                 (delete-region (point) (match-end 0)))
               (buffer-string)))))))

github-linguist

Run GitHub Linguist on projects to collect information https://github.com/akirak/github-linguist.el

(setup (:package github-linguist)
  (:nixpkgs "customPackages.github-linguist")
  (:set github-linguist-executable "github-linguist"))

git-identity

Identity management for (ma)git https://github.com/akirak/git-identity.el

(setup (:package git-identity)
  (:with-feature magit
    (:when-loaded
      ;; (git-identity-magit-mode 1)
      (:with-map magit-status-mode-map
        (:keymap "I" #'git-identity-info))))

  (cl-defmacro akirak/git-identity-add (address &rest args)
    "Add a new entry to the identity list, avoiding duplicates.

This macro should be used in extra init files which should be kept private."
    (declare (indent 1))
    `(let ((cell (assoc ,address git-identity-list)))
       (if cell
           (setcdr cell (quote ,args))
         (push (cons ,address (quote ,args))
               git-identity-list)))))

git-modes

Major modes for editing Git configuration files

(setup (:package git-modes)
  (:with-mode gitattributes-mode)
  (:with-mode gitconfig-mode)
  (:with-mode gitignore-mode
    (:file-match "/\\.dockerignore\\'")))

go-translate

Translation framework, configurable and scalable https://github.com/lorniu/go-translate

(setup (:package go-translate)
  (:set gt-langs '(en ja))
  (:when-loaded
    gt-default-translator (gt-translator :engines (gt-google-engine))))

gptel

Interact with ChatGPT or other LLMs https://github.com/karthink/gptel

(setup (:package gptel)
  (:set gptel-crowdsourced-prompts-file
        (locate-user-emacs-file "gptel-crowdsourced-prompts.csv"))

  (:global-keymap "C-c p" #'gptel-menu)
  (autoload #'gptel-org-set-topic "gptel-org" nil '(org-mode))
  (:with-feature org
    (:keymap "C-c C-x =" #'gptel-org-set-topic))

  (with-eval-after-load 'embark
    (keymap-set embark-region-map "!" #'gptel-rewrite-menu))

  (defun akirak/gptel-insert-model-id (&optional arg)
    (interactive "P")
    (require 'gptel)
    (let* ((provider (if arg
                         (completing-read "Provider: " gptel--known-backends
                                          nil t)
                       "OpenRouter"))
           (models (gptel-backend-models (gptel-get-backend provider)))
           (result (completing-read-multiple "Model: " models
                                             nil nil nil nil
                                             (symbol-name gptel-model)))
           (text (if (listp result)
                     (string-join result "\n")
                   result)))
      (cl-case (derived-mode-p 'eat-mode)
        (eat-mode
         (eat-term-send-string-as-yank eat-terminal text))
        (otherwise
         (insert text)))))

  (:when-loaded
    (fset 'gptel--update-header-line #'ignore)

    (:set gptel-backend (gptel-make-openai "OpenRouter"
                          :host "openrouter.ai"
                          :key (lambda () (gptel-api-key-from-auth-source "openrouter.ai"))
                          :endpoint "/api/v1/chat/completions"
                          :stream t
                          ;; For perplexity, use the native provider.
                          :models '(openai/gpt-4.1
                                    openai/gpt-4.1-mini
                                    openai/o4-mini
                                    openai/codex-mini
                                    openai/gpt-4o-mini-search-preview
                                    microsoft/phi-4-reasoning-plus:free
                                    anthropic/claude-3.5-sonnet
                                    anthropic/claude-opus-4
                                    anthropic/claude-sonnet-4
                                    google/gemini-2.5-flash-preview
                                    google/gemini-2.5-pro-preview))
          gptel-model 'google/gemini-2.5-flash-preview)

    (gptel-make-gh-copilot "Copilot")

    (gptel-make-perplexity "Perplexity"
      :key (lambda ()
             (gptel-api-key-from-auth-source "api.perplexity.ai"))
      :stream t)

    (gptel-make-ollama "Ollama"
      :host "localhost:11434"
      :stream t)))

graphql-mode

Major mode for editing GraphQL schemas

(setup (:package graphql-mode))

This is simply installed as a dependency for ob-graphql. However, I will use graphql-ts-mode for actually editing Org source blocks of GraphQL.

graphql-ts-mode

Tree-sitter support for GraphQL https://sr.ht/~joram/graphql-ts-mode/

(setup (:package graphql-ts-mode)
  (:org-src-lang "graphql")
  (:file-match "\\.graphql\\'" "\\.gql\\'"))

hcl-mode

Major mode for Hashicorp https://github.com/purcell/emacs-hcl-mode

(setup (:package hcl-mode)
  (:file-match "\\.tf\\'"
               "\\.prisma\\'"
               "\\.hcl\\'")
  (:reformatters
   (terraform-fmt :program "terraform"
                  :args (list "fmt" "--write=false" "-"))))

highlight-indent-guides

Minor mode to highlight indentation https://github.com/DarthFennec/highlight-indent-guides

(setup (:package highlight-indent-guides)
  (:hook-into python-mode-hook
              yaml-mode-hook))

This is helpful in programming languages that depend on indentation levels.

hl-todo

Highlight TODO and similar keywords

(setup (:package hl-todo)
  (:status opinionated
    (:global-keymap "M-i t" #'hl-todo-insert)))

huan

Replace things with predefined alternatives

(setup (:package huan)
  (:global-keymap "C-=" #'huan-symbol)
  (with-eval-after-load 'embark
    (keymap-set embark-defun-map "`" #'huan-defun)
    (keymap-set embark-identifier-map "`" #'huan-symbol)))

iedit

Edit multiple regions in the same way simultaneously.

(setup (:package iedit))

indent-bars

Highlight indentation with bars

(setup (:package indent-bars))

jinx

Enchanted Spell Checker https://github.com/minad/jinx

(setup (:package jinx)
  (:hook-into markdown-mode
              ;; For org-mode, set up hooks in .dir-locals.el of individual
              ;; projects
              git-commit-mode-hook
              vc-git-log-edit-mode-hook)
  (:keymap "C-M-;" #'jinx-correct-nearest))

just-mode

Justfile editing mode https://github.com/leon-barrett/just-mode.el

(setup (:package just-mode)
  (:file-match "/justfile\\'"))

kind-icon

Completion kind icons https://github.com/jdtsmith/kind-icon

(setup (:package kind-icon)
  (:set kind-icon-default-face 'corfu-default)

  (with-eval-after-load 'corfu
    (require 'kind-icon)
    (add-to-list 'corfu-margin-formatters #'kind-icon-margin-formatter)))

language-detection

Automatic language detection from code snippets https://github.com/andreasjansson/language-detection.el

(setup (:package language-detection))

license-templates

Create LICENSE using GitHub API https://github.com/jcs-elpa/license-templates

(setup (:package license-templates))

link-hint

Use avy to open, copy, etc. visible links https://github.com/noctuid/link-hint.el

(setup (:package link-hint)
  (:global-keymap "M-g f" #'link-hint-open-link)

  (defvar akirak/link-hint-current-window nil
    "Window selected just before `link-hint-open-link' is run.")

  (advice-add 'link-hint-open-link
              :before
              (defun akirak/link-hint-save-window (&rest _)
                (setq akirak/link-hint-current-window (selected-window))))

  (:when-loaded
    (put 'link-hint-deadgrep :open
         (defun akirak/link-hint-deadgrep-open ()
           (interactive)
           (let ((dir default-directory))
             (deadgrep--visit-result
              `(lambda (file)
                 (let ((file (expand-file-name file ,dir)))
                   (cl-flet
                       ((showing-the-file (w)
                          (when-let* ((other-file (buffer-file-name (window-buffer w))))
                            (file-equal-p file other-file))))
                     (let* ((currentw akirak/link-hint-current-window)
                            (window (or (and currentw
                                             (showing-the-file currentw)
                                             currentw)
                                        (seq-find #'showing-the-file (window-list)))))
                       (if window
                           (progn
                             (select-window window)
                             (find-file file))
                         (find-file-other-window file)))))))
             (when (fboundp 'pulse-momentary-highlight-one-line)
               (pulse-momentary-highlight-one-line))))))

  ;; Extra bindings for particular modes
  (:with-feature info
    (:when-loaded
      (:with-map Info-mode-map
        (:keymap "f" #'link-hint-open-link)))))

lispy

vi-like Paredit. https://github.com/abo-abo/lispy

For Emacs Lisp, I use lispy.

(setup (:package lispy)
  (:hook
   (defun akirak/lispy-invert-puni-mode ()
     "Turn off `puni-mode' when `lispy-mode' is on."
     (when (featurep 'puni)
       (puni-mode (not lispy-mode)))))

  ;; I have removed lispy-occur.el from the package, so disable the command.
  (fset 'lispy-occur #'ignore)
  ;; Undefine this command because I am not using it and it adds ace-window
  ;; dependency.
  (fset 'lispy-eval-other-window #'ignore)

  (advice-add 'lispy-kill :around
              (defun akirak/ad-around-lispy-kill (orig &rest args)
                (save-restriction
                  (apply orig args))))

  ;; Don't override the default command with lispy-goto-symbol.
  ;; This is especially important to enable the dumb-jump integration.
  (:keymap-unset "M-.")

  ;; Adoption of lispy is opinionated.
  (:status opinionated
    (:set lispy-key-theme '(special lispy))

    (:hook-into lisp-mode
                dune-mode
                emacs-lisp-mode
                lisp-data-mode
                lisp-interaction-mode
                ielm-mode
                eval-expression-minibuffer-setup)

    (:keymap-unset "M-i")

    (:with-map lispy-mode-map-special
      (:keymap-unset "p"                      ; lispy-eval-other-window
               "y"                      ;lispy-occur
               "O"))

    (:with-map lispy-mode-map-lispy
      ;; Prevent conflicts with other custom keybindings
      (:keymap-unset "C-,"
               "M-<left>"
               "M-<right>"
               "M-m"
               "M-o"
               "C-<return>"
               "M-<return>"
               "M-<RET>"))))

Lispy is not turned on by default. Its configuration is about my habits, so it is put in compat.el.

lsp-mode (stub)

LSP mode https://github.com/emacs-lsp/lsp-mode

(put 'lsp-defun 'lisp-indent-function 'defun)
(put 'lsp-with-current-buffer 'lisp-indent-function 1)
(put 'lsp-save-restriction-and-excursion 'lisp-indent-function 0)
(put 'lsp-define-conditional-key 'lisp-indent-function 'defun)
(put 'lsp-with-filename 'lisp-indent-function 1)

magit

A Git porcelain inside Emacs

(setup (:package magit)
  (:nixpkgs git)

  (:set magit-save-repository-buffers 'dontask)

  ;; Twist allows me to get the git version of any package if necessary, so
  ;; there is no point in making this IO-intensive function run.
  (advice-add 'magit-version :override #'ignore)

  (:with-map (magit-status-mode-map magit-log-mode-map)
    (:keymap "^" (defun akirak/magit-up-directory ()
                   "Visit the parent repository using magit, or visit the parent directory using dired."
                   (interactive)
                   (let ((parent-dir (thread-last
                                       default-directory
                                       (string-remove-suffix "/")
                                       (file-name-directory))))
                     (if-let* ((root (magit-toplevel parent-dir)))
                         (magit-status root)
                       (dired parent-dir))))))

  ;; Replace the binding to compose-message
  (keymap-set ctl-x-map "m" #'magit-dispatch)
  (keymap-set ctl-x-map "j" #'magit-status)
  (keymap-set ctl-x-x-map "e"
              (defun akirak/edit-source-file ()
                "Visit a corresponding file in a Git repository."
                (interactive)
                (cond
                 ((and buffer-file-name
                       (file-in-directory-p buffer-file-name "/nix/store/"))
                  (call-interactively #'akirak-twist-find-git-source))
                 ((and (derived-mode-p 'org-mode)
                       (featurep 'org-transclusion)
                       (org-transclusion-within-transclusion-p))
                  (same-window-prefix)
                  (org-transclusion-open-source t))
                 (t
                  (magit-blob-visit-file)))))
  (keymap-set ctl-x-x-map "m" #'magit-file-dispatch)
  (keymap-set ctl-x-x-map "s"
              (defun akirak-magit-stage-file-and-commit ()
                (interactive)
                (unless (buffer-file-name)
                  (user-error "Not in a file buffer"))
                (when (save-window-excursion
                        (magit-diff-buffer-file)
                        (yes-or-no-p "Stage all changes in this file?"))
                  (magit-stage-file (buffer-file-name))
                  (magit-commit))))

  (:status opinionated
    (:set magit-display-buffer-function
          ;; Based on 'magit-display-buffer-same-window-except-diff-v1
          (defun akirak/magit-display-buffer (buffer)
            (let ((action (with-current-buffer buffer
                            (cond
                             ((derived-mode-p 'magit-diff-mode)
                              '(nil (inhibit-same-window . t)))
                             ((and (derived-mode-p 'magit-process-mode)
                                   (fboundp 'akirak-window-display-buffer-prefer-other-pane))
                              '(akirak-window-display-buffer-prefer-other-pane))
                             (t
                              '(display-buffer-same-window))))))
              (prog1 (display-buffer buffer action)
                (with-current-buffer buffer
                  (when (derived-mode-p 'magit-process-mode)
                    (goto-char (point-max))
                    (recenter-top-bottom -1))))))))

  (:status personal
    (:when-loaded
      (transient-remove-suffix 'magit-branch
        'magit-worktree-checkout)
      (transient-replace-suffix 'magit-branch
        'magit-worktree-branch
        '("w" "new worktree" akirak-magit-worktree-new-branch))
      (transient-append-suffix 'magit-worktree
        'magit-worktree-branch
        '("d" "worktree in default location" akirak-magit-worktree-checkout)))

    (:set magit-repository-directories '(("~/" . 1)
                                         ("~/.config" . 1)
                                         ("~/work" . 3)
                                         ("~/work2" . 3)
                                         ("~/archives/oss/" . 4)))

    (:when-loaded
      ;; Run the following commands to set up SSH_AUTH_SOCK environment
      ;; from GPG:
      ;;
      ;; gpg-connect-agent /bye
      ;; export SSH_AUTH_SOCK=$(gpgconf --list-dirs agent-ssh-socket)
      (condition-case-unless-debug err
          (progn
            (with-temp-buffer
              (unless (= 0 (call-process "gpg-connect-agent"
                                         nil nil nil "/bye"))
                (error "gpg-connect-agent failed")))
            (let ((sock (car (process-lines "gpgconf" "--list-dirs" "agent-ssh-socket"))))
              (if (and sock (file-exists-p sock))
                  (progn
                    (setenv "SSH_AUTH_SOCK" sock)
                    (message "SSH_AUTH_SOCK set to %s" sock))
                (error "Socket is nil or does not exist: %s" sock))))
        (error (message "Failed to initialize SSH_AUTH_SOCK: %s" err))))))

Squash commits

(setup squasher
  ;; https://github.com/akirak/squasher
  (:nixpkgs "customPackages.squasher")

  (defun akirak/squasher-from-revision-at-point ()
    (interactive)
    (if-let* ((commit (magit-rev-parse
                       (magit-thing-at-point 'git-revision t))))
        (when (zerop (with-temp-buffer
                       (prog1 (call-process "squasher"
                                            nil t nil
                                            "--base" commit)
                         (message (buffer-string)))))
          (revert-buffer))
      (user-error "No commit at point"))))

magit-delta

Use Delta when displaying diffs in Magit https://github.com/dandavison/magit-delta

(setup (:package magit-delta)
  (:nixpkgs "delta")
  (:hook-into magit-mode-hook)

  (setq magit-delta-default-dark-theme "base16")

  (:when-loaded
    (unless (member "magit-delta" magit-delta-delta-args)
      (setq magit-delta-delta-args
            (append magit-delta-delta-args
                    '("--features" "magit-delta"))))))

magit-section

Sections for read-only buffers

(setup (:package magit-section)
  (:with-map magit-section-mode-map
    (:keymap "C-c =" (defun akirak/magit-show-section-at-point ()
                       (interactive)
                       (let ((section (magit-current-section)))
                         (message "(%s) %s"
                                  (oref section type)
                                  (prin1-to-string (oref section value))))))
    ;; I don't want to override global bindings on these keys.
    (:keymap-unset "M-1" "M-2" "M-3" "M-4"
                   "C-<tab>" "M-<tab>")))

marginalia

Enrich existing commands with completion annotations https://github.com/minad/marginalia

(setup (:package marginalia)
  (:hook-into after-init-hook)

  (:with-map minibuffer-local-map
    (:keymap "M-a" #'marginalia-cycle))

  (:when-loaded
    (add-to-list 'marginalia-annotator-registry
                 '(project-root akirak-project-root-annotator builtin none))
    (add-to-list 'marginalia-annotator-registry
                 '(directory marginalia-annotate-file builtin none))))

markdown-mode

Major mode for Markdown-formatted text https://jblevins.org/projects/markdown-mode/

(setup (:package markdown-mode)
  (:file-match "\\.md\\'" "\\.markdown\\'"
               "\\.mdoc\\'" "\\.mdx\\'"
               "\\.livemd\\'")
  (:with-mode gfm-mode
    (:file-match "README.md\\'"))

  (:keymap "C-c '" #'markdown-edit-code-block))

mastodon

Client for Mastodon, a federated social network

(setup (:package mastodon))

mcp

Model Context Protocol https://github.com/lizqwerscott/mcp.el

(setup (:package mcp)
  (:global "<f12> a m" #'mcp-hub)
  (:set mcp-hub-servers
        `(("playwright-headless"
           ;; Use the pre-downloaded Nix package. An alternative is
           ;; `nix run github:akirak/nix-playwright-mcp --`.
           :command "mcp-server-playwright"
           :args ("--headless")))))

mermaid-mode

major mode for working with mermaid graphs https://github.com/abrochard/mermaid-mode

(setup (:package mermaid-mode)
  (:nixpkgs "mermaid-cli")

  (:file-match "\\.mmd\\'"))

mini-modeline

Display modeline in minibuffer https://github.com/kiennq/emacs-mini-modeline

(setup (:package mini-modeline)
  (:set mini-modeline-enhance-visual nil
        mini-modeline-echo-duration 3
        ;; If this option is set to t, it seems to suppress header lines, so I
        ;; will set it to nil.
        mini-modeline-display-gui-line nil
        mini-modeline-l-format '((mode-line-modified mode-line-modified)
                                 (mode-line-mule-info mode-line-mule-info)
                                 " "
                                 (:eval (akirak-mode-line-directory))
                                 "%b"
                                 "%n %p (%l,%c) "
                                 (:eval (string-trim (format-mode-line mode-line-modes)))
                                 (vc-mode vc-mode))
        mini-modeline-r-format '("%e"
                                 (mode-line-process ("  " mode-line-process))
                                 (current-input-method-title
                                  (current-input-method-title " "))
                                 ;; I'll show mode-line-misc-info in the header line,
                                 ;; as it contains information for eglot, which-func, etc.
                                 ;; which are specific to buffers.
                                 ;; (mode-line-misc-info mode-line-misc-info)

                                 ;; However, global-mode-string, which is part
                                 ;; of mode-line-misc-info by default, should be
                                 ;; included here. See also bindings.
                                 (global-mode-string global-mode-string)
                                 (mode-line-client mode-line-client)
                                 (:eval (format-time-string " %b %d %a W%U %H:%M"))))
  (:hook-into emacs-startup-hook)

  (defvar-local akirak/mode-line-directory-memo nil
    "Cons cell of (TIME . DIR).")

  (defun akirak-mode-line-directory ()
    (let ((base (buffer-base-buffer)))
      (if-let* ((filename (buffer-file-name base)))
          (if (and akirak/mode-line-directory-memo
                   (< (- (float-time) (car akirak/mode-line-directory-memo))
                      3))
              (cdr akirak/mode-line-directory-memo)
            (let* ((dir (abbreviate-file-name (file-name-directory filename)))
                   (value (concat (if-let* ((pr (when (require 'akirak-header-line nil t)
                                                  (akirak-header-line--project))))
                                      (let ((root (thread-last
                                                    (project-root pr)
                                                    (string-remove-suffix "/"))))
                                        (concat (file-name-directory root)
                                                (propertize (file-name-nondirectory root)
                                                            'face 'font-lock-constant-face)
                                                (propertize (string-remove-prefix root dir)
                                                            'face 'font-lock-string-face)))
                                    (propertize dir 'face 'font-lock-string-face))
                                  (if base
                                      (concat (file-name-nondirectory filename)
                                              " -> [indirect]")
                                    ""))))
              (setq akirak/mode-line-directory-memo (cons (float-time) value))
              value))
        ""))))

move-dup

Eclipse-like moving and duplicating lines or rectangles https://github.com/wyuenho/move-dup

(setup (:package move-dup)
  (:keymap "M-P" #'move-dup-move-lines-up
         "M-N" #'move-dup-move-lines-down)

  (defun akirak/turn-on-move-dup-mode ()
    (unless (or (minibufferp)
                (derived-mode-p 'org-mode 'markdown-mode 'special-mode))
      (move-dup-mode 1)))

  ;; Based on `global-move-dup-mode', but add some extra exclusion rules.
  (define-globalized-minor-mode akirak/global-move-dup-mode
    move-dup-mode akirak/turn-on-move-dup-mode)

  (add-hook 'after-init-hook #'akirak/global-move-dup-mode))

mpv

control mpv for easy note-taking https://github.com/kljohann/mpv.el

(setup (:package mpv)
  (with-eval-after-load 'mailcap
    (add-to-list 'mailcap-user-mime-data
                 `((viewer . mpv-play)
                   (test . (or (getenv "DISPLAY")
                               (getenv "WAYLAND_DISPLAY")))
                   (type . ,(rx (or "audio" "video")
                                "/" (+ anything)))))))

neocaml

Major mode for OCaml code http://github.com/bbatsov/neocaml

(setup (:package neocaml)
  (:file-match "\\.ml\\(?:\\.[^z-a]+\\)?\\'")
  (:with-mode (neocaml-mode neocamli-mode)
    (:mode-repl akirak/utop-project)
    (:org-src-lang "ocaml")
    (:mode-project-roots "dune-project")
    (:local-set treesit-font-lock-level 4)
    (:set neocaml-use-prettify-symbols nil)

    ;; Load abbreviations
    (:also-load akirak-ocaml)
    (:local-set local-abbrev-table akirak-ocaml-abbrev-table))

  (:reformatters
   (ocamlformat :program "ocamlformat"
                :args (list "--name" (buffer-file-name) "-"))))

nix3

Frontend to experimental commands of Nix https://github.com/emacs-twist/nix3.el

(setup (:package nix3)
  (:set nix3-flake-remote-wait 20
        nix3-registry-list-completion-options (list :add-to-registry t
                                                    :require-match nil))

  (defun akirak/nix3-flake-maybe-update-from-pins ()
    "Generate flake.lock from the pins."
    (when (not (file-exists-p "flake.lock"))
      (akirak/nix3-flake-update-from-pins)))

  (defun akirak/nix3-flake-update-from-pins ()
    (interactive)
    (if (file-exists-p "flake.nix")
        (make-process :buffer "*nix flake update*"
                      :name "nix-flake-update"
                      :command
                      (list "nix" "flake" "update" "--flake" "."
                            "--commit-lock-file"
                            "--inputs-from" "github:akirak/flake-pins")
                      :sentinel
                      (lambda (proc event)
                        (if (string= event "finished\n")
                            (message "Successfully updated flake.lock")
                          (when (> (process-exit-status proc)
                                   0)
                            (message "Failed to update flake.lock: %s"
                                     (with-current-buffer "*nix flake update*"
                                       (buffer-string)))))))
      (user-error "There is no flake.nix in default-directory")))

  (:when-loaded
    (add-hook 'nix3-flake-new-hook #'akirak/nix3-flake-maybe-update-from-pins
              90)
    (add-hook 'nix3-flake-init-hook #'akirak/nix3-flake-maybe-update-from-pins
              90))

  (:global-keymap "C-c n" #'nix3-transient
                  "M-g M-f" #'nix3-flake-edit
                  "<f12> n l" #'nix3-registry-list
                  "<f12> n n" #'nix3-flake-show-url))

magit-nix3

Nix3.el integration for Magit https://github.com/emacs-twist/nix3.el

(setup (:package magit-nix3)
  (with-eval-after-load 'magit-diff
    (magit-nix3-flake-lock-mode t)))

nixfmt

Reformat Nix using nixfmt https://github.com/purcell/emacs-nixfmt

(setup (:package nixfmt)
  (:nixpkgs nixfmt-rfc-style))

nix-mode

Major mode for editing .nix files

;; Install nix-mode for nix-repl.
(setup (:package nix-mode))

;; (setup (:package nix-mode)
;;   (:file-match "\\.nix\\'")
;;   (:mode-repl nix-repl)
;;   (:keymap "<remap> <devdocs-lookup>" #'akirak-nix-manix)
;;   (:reformatters
;;    (alejandra :program "alejandra")))

nix-update

Update “fetch” blocks in .nix expressions https://github.com/jwiegley/nix-update-el

(setup (:package nix-update))

noman

Read command line help without a man page https://github.com/andykuszyk/noman.el

(setup (:package noman))

nov

Featureful EPUB reader mode https://depp.brause.cc/nov.el

(setup (:package nov)
  ;; unzip is required for opening EPUB
  (:nixpkgs unzip)
  (:file-match "\\.epub\\'")
  (:set nov-text-width akirak/default-body-width)
  (:keymap "i" #'imenu
           ;; consult-imenu doesn't work, so remap it to imenu
           "<remap> <consult-imenu>" #'imenu)

  (:hook (defun akirak/nov-setup ()
           (when (require 'olivetti nil t)
             (olivetti-mode 1)
             (setq-local nov-text-width nil)
             ;; Re-render as olivetti changes the window width.
             (add-hook 'olivetti-expand-hook
                       #'nov-render-document
                       nil t)))))

ocp-indent

automatic indentation with ocp-indent http://www.typerex.org/ocp-indent.html

(setup (:package ocp-indent)
  (defun akirak/ocp-indent-maybe-setup ()
    (when (executable-find "ocp-indent")
      (ocp-setup-indent)))
  (add-hook 'tuareg-mode-hook #'akirak/ocp-indent-maybe-setup)
  (add-hook 'neocaml-mode-hook #'akirak/ocp-indent-maybe-setup))

olivetti

Minor mode to automatically balance window margins https://github.com/rnkn/olivetti

(setup (:package olivetti)
  (:set olivetti-body-width akirak/default-body-width)

  ;; Also hooked into nov-mode. See the package setting
  (:hook-into org-mode-hook
              org-memento-timeline-mode-hook)

  ;; Implement `olivetti-set-width-hook' without tweaking the upstream code.
  (advice-add 'olivetti-expand
              :after
              (lambda (&rest _args)
                (run-hooks 'olivetti-expand-hook))))

orderless

Completion style for matching regexps in any order https://github.com/oantolin/orderless

(setup (:package orderless)
  (:set completion-styles '(orderless)))

Resources:

https://github.com/minad/vertico#configuration

It is also possible to use Helm as a completion style. See https://github.com/oantolin/orderless#ivy-and-helm. I will use orderless primarily because it is smaller than Helm.

orgit

Support for Org links to Magit buffers

(setup (:package orgit))

package-lint

A linting library for elisp package authors https://github.com/purcell/package-lint

(setup (:package package-lint))

page-break-lines

Display ^L page breaks as tidy horizontal lines https://github.com/purcell/page-break-lines

(setup (:package page-break-lines)
  (:hook-into doc-mode-hook
              help-mode-hook
              magit-mode-hook
              compilation-mode-hook
              haskell-mode-hook))

pinyin

Convert Hanzi to Pinyin (汉字转拼音)

(setup (:package pinyin))

plz

HTTP library https://github.com/alphapapa/plz.el

(setup (:package plz)
  (:nixpkgs "curl")
  (:when-loaded
    (add-to-list 'plz-curl-default-args "--http1.1")))

popper

Summon and dismiss buffers as popups https://github.com/karthink/popper

(setup (:package popper)
  (:set popper-window-height 0.33
        popper-display-function #'popper-select-popup-at-bottom
        akirak/display-popup-window-function popper-display-function
        ;; You may have to re-enable popper-mode after updating this variable
        popper-reference-buffers `("\\*Messages\\*$"
                                   "\\*Backtrace\\*"
                                   "^\\*Warnings\\*"
                                   "^\\*envrc-debug\\*"
                                   "\\*Org-Dog-Context\\*"
                                   "^\\*Org Note\\*"
                                   "^\\*Compile-Log\\*"
                                   "^\\*Scratch-Input-Method"
                                   "^ \\*Agenda Commands\\*"
                                   "^\\*Register Preview\\*"
                                   "^\\*Shell Command Output\\*"
                                   "^\\*EGLOT connections*"
                                   "^\\*edit string\\*"
                                   "^\\*bean-query"
                                   "^\\*scratch from selection\\*"
                                   "^\\*[[:word:]]+ errors\\*"
                                   "^\\*Async Shell Command\\*"
                                   ;; "^\\*eldoc"
                                   "^\\*Select Link\\*"
                                   "^\\*Flymake diagnostics"
                                   "^\\*hoogle\\*"
                                   inferior-haskell-mode))

  (:hook-into after-init-hook)
  (:hook popper-echo-mode)

  (advice-add 'popper-select-popup-at-bottom
              :before
              (defun akirak/popper-store-current-window (&rest _)
                (setq akirak-window-last-non-popup-window (selected-window))))

  (defun akirak/popper-restart ()
    (interactive)
    (when (bound-and-true-p popper-mode)
      (popper-mode -1))
    (popper-mode))

  (add-hook 'popper-open-popup-hook
            (defun akirak/popper-recenter ()
              (goto-char (point-max))
              (recenter -1 t)))

  (:keymap "M-\"" #'popper-cycle
           "M-' RET" #'popper-toggle-type
           "M-' M-'" #'popper-toggle
           "M-' a" (defun akirak/display-async-shell-command ()
                     (interactive)
                     (display-buffer "*Async Shell Command*"))
           "M-' e" #'flymake-show-buffer-diagnostics
           "M-' s" #'scratch-buffer
           "M-' w" (defun akirak/revisit-eww-buffer ()
                     (interactive)
                     (pop-to-buffer "*eww*"))))

posframe

Pop a posframe (just a frame) at point https://github.com/tumashu/posframe

(setup (:package posframe))

prodigy

Manage external services http://github.com/rejeep/prodigy.el

(setup (:package prodigy)
  (:global-keymap "<f12> x p" #'prodigy))

puni

Parentheses Universalistic

puni will replace smartparens, expand-region, and paredit (which I didn’t adopt in favour of lispy).

(setup (:package puni)
  (:hook-into nix-mode
              erlang-mode
              tuareg-mode
              svelte-mode
              web-mode
              sql-mode
              d2-mode
              nxml-mode)


  ;; TODO: Bind commands
  ;;
  ;; Marking commands
  ;; Sexp manipulating commands

  (:keymap-unset "C-M-a" "C-M-e" "C-w" "M-d" "C-M-f"))

The following types of commands don’t have pre-defined keybindings in puni-mode, so I have to manually bind them:

Marking commnads
Sexp manipulating commands

For auto-pairing, you can use electric-pair-mode along with puni.

akirak-puni

(setup akirak-puni
  (add-hook 'puni-mode-hook #'akirak-puni-mode-setup))

This contains workarounds for puni-mode, like mode-specific soft deletion.

rainbow-csv

Highlight CSV and TSV files in different rainbow colors https://github.com/emacs-vs/rainbow-csv

(setup (:package rainbow-csv)
  (:hook-into csv-mode-hook tsv-mode-hook))

rainbow-delimiters

Highlight brackets according to their depth

(setup (:package rainbow-delimiters)
  (:hook-into emacs-lisp-mode))

rainbow-mode

Colorize color names in buffers

(setup (:package rainbow-mode)
  (:hook-into prog-mode))

reason-mode

A major mode for editing ReasonML https://github.com/reasonml-editor/reason-mode

(setup (:package reason-mode)
  (:file-match "\\.re\\'"))

reformatter

Define commands which run reformatters on the current buffer

(setup (:package reformatter)
  (:reformatters
   ;; If you use prettier, you need to install its executable separately.
   (prettier
    :program "prettier"
    :args (list (concat "--plugin-search-dir="
                        (expand-file-name
                         (locate-dominating-file default-directory "package.json")))
                "--stdin-filepath" (buffer-file-name)))
   (treefmt
    :program "treefmt"
    :args (list "--stdin" (buffer-file-name)))

   (yamlfmt
    :program "yamlfmt"
    :args (list "-"))

   (jq-format
    :program "jq"
    :args (list "."))

   (biome-format
    :program
    (cond
     ((executable-find "bunx")
      "bunx"))
    :args (append (cond
                   ((executable-find "bunx")
                    nil))
                  (list "@biomejs/biome" "format" (buffer-file-name)
                        (concat "--stdin-file-path=" (buffer-file-name)))))))

repl-toggle

Switch to/from repl buffer for current major-mode

(setup (:package repl-toggle)
  (:set rtog/fullscreen nil
        rtog/goto-buffer-fun akirak/display-popup-window-function)

  ;; Unbind the default key
  (:keymap-unset "C-c C-z")
  (:global-keymap "C-<return>" #'rtog/toggle-repl))

For configuration, see ~tomterl/repl-toggle - sourcehut git.

restclient

An interactive HTTP client for Emacs

(setup (:package restclient)
  (:file-match "\\.restclient\\'"))

rfc-mode

RFC document browser and viewer https://github.com/galdor/rfc-mode

(setup (:package rfc-mode)
  (:set rfc-mode-directory (locate-user-emacs-file "rfc/")))

riben

A dumb Japanese input method https://github.com/akirak/emacs-dumb-japanese

(setup (:package riben)
  (:set riben-google-timeout 5)
  (:keymap "C-j" #'riben-dispatch
           "C-S-j" #'riben-inc-counter
           "q" #'riben-mode-disable
           "@" #'riben-switch-to-english-mode
           "_" (defun akirak/insert-zero-width-space ()
                 (interactive)
                 ;; zero-width space
                 (insert "")))

  (set-language-info "Japanese" 'input-method 'japanese-riben)

  ;; Workaround for commands in `org-mode-map' and other maps.
  (:when-loaded
    (dolist (char (mapcar #'car riben-decode-punctuation-alist))
      (keymap-set riben-mode-map (char-to-string char) #'riben-self-insert-command))))

avy-riben

Jump to Japanese text using avy https://github.com/akirak/emacs-dumb-japanese

(setup (:package avy-riben))

riben-english

(setup riben-english
  (:keymap "C-j" #'riben-english-to-japanese
         "C-S-j" #'riben-english-confirm))

separedit

Edit comment/string/docstring/code block in separate buffer https://github.com/twlz0ne/separedit.el

(setup (:package separedit)
  (:set separedit-default-mode 'markdown-mode)
  (:global-keymap "C-c '" #'separedit))

shfmt

Reformat shell scripts using shfmt https://github.com/purcell/emacs-shfmt

(setup (:package shfmt)
  (:nixpkgs "shfmt")
  ;; My default preferences for formatting bash. Can be overridden for
  ;; individual projects that are not owned by me. For details, see "shfmt
  ;; --help".
  (:set shfmt-arguments '("-i" "2"
                          "--case-indent"
                          "--binary-next-line")))

show-font

Show font features in a buffer https://github.com/protesilaos/show-font

(setup (:package show-font))

shr-tag-pre-highlight

Syntax highlighting code block in HTML https://github.com/xuchunyang/shr-tag-pre-highlight.el

(setup (:package shr-tag-pre-highlight)
  (:when-loaded
    (:set shr-tag-pre-highlight-lang-modes
          (append '(("elixir" . elixir))
                  shr-tag-pre-highlight-lang-modes)))
  (with-eval-after-load 'shr
    (add-to-list 'shr-external-rendering-functions
                 '(pre . shr-tag-pre-highlight))))

sqlformat

Reformat SQL using sqlformat or pgformatter https://github.com/purcell/sqlformat

(setup (:package sqlformat)
  (:nixpkgs "pgformatter")
  ;; Override the formatter settings when necessary
  (:set sqlformat-command 'pgformatter
        sqlformat-args '("-s2" "-g")))

ssh-config-mode

Mode for fontification of ~/.ssh/config https://github.com/peterhoeg/ssh-config-mode-el

(setup (:package ssh-config-mode)
  (:file-match "/\\.ssh/config\\'" "/sshd?_config\\'"))

string-inflection

underscore -> UPCASE -> CamelCase -> lowerCamelCase conversion of names

(setup (:package string-inflection))

super-save

Auto-save buffers, based on your activity. https://github.com/bbatsov/super-save

(setup (:package super-save)
  (:hook-into emacs-startup-hook)
  (:set super-save-auto-save-when-idle t
        super-save-idle-duration 120
        super-save-remote-files nil
        super-save-triggers '(consult-buffer
                              tab-next
                              tab-previous
                              tab-new
                              tab-close
                              find-file
                              org-dog-find-file
                              akirak-consult-project-file
                              akirak-consult-dir))
  (:when-loaded
    (add-hook 'super-save-predicates
              (defun akirak/super-save-not-org-crypt-p ()
                (and (boundp 'org-crypt-key)
                     (buffer-local-value 'org-crypt-key (current-buffer)))))))

super-save-mode can be annoying when you use org-crypt. Follow an instruction at super-save disable when file header is present. · Issue #10 · bbatsov/super-save · GitHub

svelte-mode

Emacs major mode for Svelte

(setup (:package svelte-mode)
  (:file-match "\\.svelte\\'")
  (:set svelte-display-submode-name t)
  (:auto-insert
   ("\\.svelte\\'"
    . (> "<script lang=\"ts\">\n</script>\n\n"
         _ "\n\n<style>\n\n</style>\n"))))

svg-lib

SVG tags, progress bars & icons https://github.com/rougier/svg-lib

(setup (:package svg-lib))

symbol-overlay

Highlight symbols with keymap-enabled overlays https://github.com/wolray/symbol-overlay/

(setup (:package symbol-overlay)
  (:global-keymap "C-c s" #'symbol-overlay-put
           "M-g s" #'akirak-symbol-overlay-goto)

  (add-hook 'symbol-overlay-jump-hook
            (defun akirak/symbol-overlay-org-show-entry ()
              (when (derived-mode-p 'org-mode)
                (org-show-entry)))))

embark can substitute for most of the functionalities of the package, but I am used to this package.

casual-symbol-overlay

Transient UI for Symbol Overlay https://github.com/kickingvegas/casual-symbol-overlay

(setup (:package casual-symbol-overlay)
  (:global-keymap "C-c S" #'casual-symbol-overlay-tmenu))

systemd

Major mode for editing systemd units

(setup (:package systemd)
  (defun akirak/systemd-suspend ()
    "Suspend the system via systemd."
    (interactive)
    (if (and (eq system-type 'gnu/linux)
             (executable-find "systemctl")
             (not (akirak/wsl-p)))
        (progn
          (akirak/system-leave-hook)
          (run-with-timer
           1 nil
           (lambda ()
             (call-process "systemctl" nil nil nil "suspend"))))
      (user-error "This system doesn’t support session control using systemd"))))

tab-bookmark

Tab bookmarks

(setup (:package tab-bookmark))

tagedit

Some paredit-like features for html-mode

(setup (:package tagedit)
  ;; The upstream lacks this autoload
  (autoload 'tagedit-mode "tagedit"))

taxy

Programmable taxonomical grouping for arbitrary objects https://github.com/alphapapa/taxy.el

(setup (:package taxy))

taxy-magit-section

View Taxy structs in a Magit Section buffer https://github.com/alphapapa/taxy.el

(setup (:package taxy-magit-section))

titlecase

Title-case phrases https://codeberg.org/acdw/titlecase.el

(setup (:package titlecase))

The readme of this package contains helpful links on capitalization.

treesit-fold

Code folding using treesit https://github.com/emacs-tree-sitter/treesit-fold

(setup (:package treesit-fold)
  (:hook akirak/turn-on-treesit-fold-indicators-mode)
  ;; `treesit-fold-mode' is disabled if it doesn't support the major mode, which
  ;; triggers `treesit-fold-mode-hook'. Thus each function added to the hook
  ;; must check the actual state of the mode.
  (defun akirak/turn-on-treesit-fold-indicators-mode ()
    (when treesit-fold-mode
      (treesit-fold-indicators-mode 1)))
  ;; `treesit' doesn't have a built-in keymap for its enabled modes, so I will
  ;; use `akirak-treesit-mode'. Actually, `treesit-fold' has nothing to do with
  ;; the mode.
  (:hook-into akirak-treesit-mode-hook)
  (defvar-keymap treesit-fold-mode-map
    :doc "Keymap for `treesit-fold-mode'.")
  (:keymap "C-c TAB" #'akirak-treesit-fold-dwim))

twind

Complete Tailwind classes using the Cheatsheet data https://github.com/akirak/twind.el

(setup (:package twind)
  (:with-mode twind-css-mode
    (:hook-into css-mode css-ts-mode)
    (:keymap "C-, t" #'twind-insert-css-from-cheatsheet))
  (:with-mode twind-class-mode
    (:hook-into web-mode tsx-ts-mode heex-ts-mode gleam-ts-mode elixir-ts-mode)
    (:keymap "C-, t" #'twind-insert-class-from-cheatsheet))
  (with-eval-after-load 'embark
    (defvar-keymap twind-css-rule-embark-map
      :parent embark-general-map
      :doc "Embark keymap for twind CSS."
      "d" #'twind-reference-tailwind
      "m" #'twind-reference-mdn-css)
    (add-to-list 'embark-keymap-alist '(twind-css-rule . twind-css-rule-embark-map))))

twist

Hot-reload packages with twist https://github.com/emacs-twist/twist.el

(setup (:package twist)
  (:status personal
    (add-hook 'emacs-startup-hook #'twist-watch-mode)
    (:global-keymap "<f12> e R" #'twist-update)))

unfill

Do the opposite of fill-paragraph or fill-region

(setup (:package unfill))

use-package

I don’t use use-package, but I only need indentation:

(put 'use-package 'lisp-indent-function 1)

valign

Visually align tables https://github.com/casouri/valign

This package provides visual alignment for Org Mode, Markdown and table.el tables on GUI Emacs. It can properly align tables containing variable-pitch font, CJK characters and images.

(setup (:package valign)
  (:hook-into org-mode))

vertico

VERTical Interactive COmpletion https://github.com/minad/vertico

(setup (:package vertico)
  (:hook-into after-init-hook)
  (:set vertico-resize t)
  (:with-map vertico-map
    (:keymap "C-r" #'previous-matching-history-element
           "C-s" #'next-matching-history-element
           "C-o" #'vertico-next-group
           "C-S-o" #'vertico-previous-group)))

For more tips, see Home · minad/vertico Wiki · GitHub.

An alternative is icomplete (or icomplete-vertical). See the following comment for differences:

In contrast to Vertico, Icomplete rotates the candidates such that the current candidate always appears at the top. From my perspective, candidate rotation feels a bit less intuitive than the UI of Vertico or Selectrum.

visual-fill-column

fill-column for visual-line-mode https://codeberg.org/joostkremers/visual-fill-column

(setup (:package visual-fill-column)
  (:set visual-fill-column-center-text t
        visual-fill-column-width 100))

vue-mode

Major mode for vue component based on mmm-mode https://github.com/AdamNiederer/vue-mode

(setup (:package vue-mode)
  (:file-match "\\.vue\\'"))

web-mode

major mode for editing web templates https://web-mode.org

(setup (:package web-mode)
  (:set web-mode-enable-front-matter-block t)
  (:org-src-lang "html")
  (:file-match "\\.mdx\\'"
               "\\.html?\\'"
               "\\.sface\\'")

  (:keymap "C-c /" #'akirak-web-mode-surround
           "<remap> <end-of-defun>" #'web-mode-forward-sexp
           "<remap> <down-list>" #'web-mode-element-child
           "<remap> <backward-up-list>" #'web-mode-element-parent
           "<remap> <forward-sexp>"
           (defun akirak/web-mode-forward-tag-or-sexp ()
             (interactive)
             (if-let* ((tag-end (and (looking-at "<")
                                     (web-mode-tag-end-position))))
                 (goto-char (1+ tag-end))
               (forward-sexp))))

  (:auto-insert
   ("\\.astro\\'" . (> "---\n" _ "\n---\n"))))

whole-line-or-region

Operate on current line if region undefined

(setup (:package whole-line-or-region)
  (defun akirak/anzu-query-replace-on-line (arg)
    (interactive "P")
    (require 'anzu)
    (require 'whole-line-or-region)
    (whole-line-or-region-wrap-modified-region #'anzu-query-replace-regexp
                                               (if (numberp arg)
                                                   arg
                                                 1)
                                               arg))

  (:global-keymap "C-c r" #'akirak/anzu-query-replace-on-line)

  ;; whole-line-or-region version of indent-rigidly. Useful for editing YAML.
  (defun akirak/indent-rigidly-line-or-region (&optional arg)
    (interactive "P")
    (require 'whole-line-or-region)
    (whole-line-or-region-wrap-beg-end #'indent-rigidly
                                       1
                                       (if (numberp arg)
                                           arg
                                         tab-width)))
  (defun akirak/indent-rigidly-left-line-or-region (arg)
    (interactive "P")
    (require 'whole-line-or-region)
    (whole-line-or-region-wrap-beg-end #'indent-rigidly
                                       1
                                       (if (numberp arg)
                                           (- arg)
                                         (- tab-width))))

  (defvar akirak/indent-rigidly-map
    (make-sparse-keymap))
  (put 'akirak/indent-rigidly-line-or-region 'repeat-map 'akirak/indent-rigidly-map)
  (put 'akirak/indent-rigidly-left-line-or-region 'repeat-map 'akirak/indent-rigidly-map)
  (keymap-global-set "C-x TAB" #'akirak/indent-rigidly-line-or-region)
  (keymap-global-set "C-x <backtab>" #'akirak/indent-rigidly-left-line-or-region)
  (keymap-set akirak/indent-rigidly-map "TAB"
              #'akirak/indent-rigidly-line-or-region)
  (keymap-set akirak/indent-rigidly-map "<backtab>"
              #'akirak/indent-rigidly-left-line-or-region))

windswap

Like windmove, but swaps buffers while moving point

(setup (:package windswap)
  (:status opinionated
    (:global-keymap "C-S-<left>" #'windswap-left
                    "C-S-<right>" #'windswap-right
                    "C-S-<up>" #'windswap-up
                    "C-S-<down>" #'windswap-down

                    ;; There are corresponding keybindings for windmove.
                    "C-c {" #'windswap-left
                    "C-c }" #'windswap-right)

    ;; These keys are bound by default in org-mode, so unbind them.
    (:with-feature org
      (:keymap-unset
       "C-S-<left>"
       "C-S-<right>"
       "C-S-<up>"
       "C-S-<down>"))
    (:with-feature org-agenda
      (:keymap-unset
       "C-S-<left>"
       "C-S-<right>"
       "C-S-<up>"
       "C-S-<down>"))))

xterm-color

ANSI, XTERM 256 and Truecolor support https://github.com/atomontage/xterm-color

(setup (:package xterm-color))

This package is required by the configuration for buttercup now.

zig-mode

A major mode for the Zig programming language https://github.com/zig-lang/zig-mode

(setup (:package zig-mode))

I prefer zig-ts-mode, but I still use zig-mode for its extra commands supporting development workflows.

Software package management

Cargo (Rust)

(setup cargo
  (:package-files "Cargo.toml"))

Gleam

(setup gleam
  (:package-files "gleam.toml")
  (:org-src-lang "gleam")

  (defun akirak/gleam-browse-docs ()
    (interactive)
    (if-let* ((root (locate-dominating-file default-directory "gleam.toml")))
        (let* ((dir (expand-file-name "build/dev/docs/" root))
               (subdirs (if (file-directory-p dir)
                            (directory-files dir t "^[[:alpha:]]")
                          (user-error "Documentation hasn't been generated. Run gleam docs build")))
               (subdir (pcase (length subdirs)
                         (0
                          (user-error "Please run gleam docs build to regenerate the documentation"))
                         (1
                          (car subdirs))
                         (_
                          (completing-read "Package documentation: "
                                           subdirs nil t))))
               (file (expand-file-name "index.html" subdir)))
          (akirak-open-default file))
      (user-error "gleam.toml is not found")))

  (defun akirak/gleam-shell ()
    (interactive)
    (if-let* ((root (locate-dominating-file default-directory "gleam.toml")))
        (akirak-shell-exec-in-project
            '("gleam" "shell")
          :root root :name "gleam-shell")
      (user-error "Not in a Gleam project"))))

Haskell

(setup hpack
  (:package-files "package.yaml"))

Mix (Elixir)

(setup mix
  (:package-files "mix.exs")

  (defun akirak/mix-browse-ex-docs ()
    (interactive)
    (let* ((root (locate-dominating-file default-directory "mix.exs"))
           (file (expand-file-name "doc/index.html" root)))
      (unless root
        (user-error "mix.exs is not found"))
      (unless (file-readable-p file)
        (user-error "Documentation hasn't been generated. Run mix docs"))
      (akirak-open-default file)))

  (defun akirak/iex-dwim ()
    (interactive)
    (if-let* ((root (locate-dominating-file default-directory "mix.exs")))
        (akirak-shell-exec-in-project '("iex" "-S" "mix")
          :root root)
      (akirak-shell-exec-in-project "iex"))))

Node.js and Bun

(setup npm
  (:package-files "package.json")

  (defun akirak/node-or-bun-repl ()
    (interactive)
    (akirak-shell-exec-in-project
        (cond
         ((executable-find "node")
          (list "node"))
         ((executable-find "bun")
          (list "bun" "repl"))
         (t
          (user-error "Neither node or bun is found in the exec-path")))
      :name "javascript-repl"
      :root default-directory)))

OCaml (opam and dune)

(setup dune
  (:package-files "dune" "dune-project")

  (defun akirak/dune-browse-doc ()
    "Browse package documentation for the project."
    (interactive)
    (let ((root (locate-dominating-file default-directory "dune-project")))
      (if root
          (akirak-open-file-externally
           (expand-file-name "_build/default/_doc/_html/index.html" root))
        (user-error "dune-project is not found"))))

  (defun akirak/utop-project ()
    (interactive)
    (let* ((root (locate-dominating-file default-directory "dune-project"))
           (project-path (when root (file-relative-name root))))
      (akirak-shell-exec-in-project
          (cond
           ((and project-path (executable-find "dune"))
            (list "dune" "utop" project-path))
           ((and project-path (executable-find "opam"))
            (list "opam" "exec" "--" "dune" "utop" project-path))
           ((executable-find "utop")
            '("utop"))
           ((executable-find "opam")
            '("opam" nil "exec" "--" "utop"))
           (t
            (user-error "Neither dune nor opam is available")))
        :name "utop"
        :root default-directory))))

Python (uv)

(setup uv
  (:package-files "pyproject.toml")

  (defun akirak/euporie-project ()
    (interactive)
    (let* ((root (locate-dominating-file default-directory "pyproject.toml")))
      (akirak-shell-exec-in-project (list "uv" "run" "euporie-console")
        :name "euporie-console"
        :root root))))

rebar3 (Erlang)

(setup rebar3
  (:package-files "rebar.config"))

Workarounds

Org mode

Define how Org entries are displayed by certain commands.

(add-hook 'org-follow-link-hook
          (defun akirak/org-follow-link-reveal ()
            (when-let* ((buffer (window-buffer (selected-window)))
                        (marker (and (eq 'org-mode (buffer-local-value 'major-mode buffer))
                                     (or (looking-at org-heading-regexp)
                                         (when-let* ((uri (cadr (get-char-property (point) 'htmlize-link))))
                                           (string-match-p "^id:" uri)))
                                     (not (and (thing-at-point-looking-at org-link-any-re)
                                               (match-string 1)))
                                     (point-marker)))
                        (indirect-buffer (and (fboundp 'org-dog-indirect-buffer)
                                              (org-with-point-at marker
                                                (org-dog-indirect-buffer)))))
              (set-window-configuration org-window-config-before-follow-link)
              (let ((switch-to-buffer-obey-display-actions nil))
                (switch-to-buffer indirect-buffer nil t))
              (with-current-buffer indirect-buffer
                (goto-char marker)
                (when org-dog-new-indirect-buffer-p
                  (org-show-context)
                  (org-show-entry)
                  (org-show-children))))))

(add-hook 'org-agenda-after-show-hook
          (defun akirak/org-agenda-show-entry ()
            (let ((switch-to-buffer-obey-display-actions nil))
              (switch-to-buffer (org-dog-indirect-buffer) nil t))))

(defun akirak/org-goto-indirect-hook ()
  (when (fboundp 'org-dog-indirect-buffer)
    (let ((buffer (org-dog-indirect-buffer))
          (switch-to-buffer-obey-display-actions nil))
      (switch-to-buffer buffer nil t)
      (when org-dog-new-indirect-buffer-p
        (with-current-buffer buffer
          (org-show-context)
          (org-show-entry)
          (org-show-children)
          (akirak/org-recenter-toplevel-at-top))))))

(add-hook 'org-pivot-search-entry-display-hook
          (defun akirak/org-pivot-search-after-display ()
            (org-show-context)
            (org-show-entry)
            (org-show-children)
            (if (buffer-narrowed-p)
                (akirak/org-recenter-toplevel-at-top)
              (recenter))))
(setq org-rooted-find-hook #'akirak/org-goto-indirect-hook)

(defun akirak/org-recenter-toplevel-at-top ()
  (unless (org-before-first-heading-p)
    ;; (save-excursion
    ;;   (let ((regexp (rx bol "*" blank)))
    ;;     (when (or (looking-at regexp)
    ;;               (re-search-backward regexp nil t))
    ;;       (recenter-top-bottom 0))))
    (recenter-top-bottom 0)))

(setq akirak-org-clock-open-hook '(org-show-entry
                                   org-show-children))

(setq akirak-org-log-week-entry-hook
      '(org-fold-hide-subtree
        org-fold-show-children
        (lambda () (org-fold-show-entry t))))

Advices and el-patches

Org frequently calls delete-other-windows, some of which I find annoying. They are built into big functions in the library, so I use el-patch to remove them.

;; A function advice to prevent the default behavior which run
;; `delete-other-windows' to show a completion window.
(setup window
  (:status opinionated
    (advice-add 'delete-other-windows
                :before-while
                (defun akirak/org-allow-delete-other-windows-p (&rest _args)
                  (not (memq this-command '(org-todo
                                            org-agenda-todo
                                            org-agenda)))))))

(setup org
  (:status opinionated
    (:el-patch
      (el-patch-defun org-fast-todo-selection (&optional current-state)
        "Fast TODO keyword selection with single keys.
Returns the new TODO keyword, or nil if no state change should occur.
When CURRENT-STATE is given and selection letters are not unique globally,
prefer a state in the current sequence over on in another sequence."
        (let* ((fulltable org-todo-key-alist)
               (head (org-get-todo-sequence-head current-state))
               (done-keywords org-done-keywords) ;; needed for the faces.
               (maxlen (apply 'max (mapcar
                                    (lambda (x)
                                      (if (stringp (car x)) (string-width (car x)) 0))
                                    fulltable)))
               (expert (equal org-use-fast-todo-selection 'expert))
               (prompt "")
               (fwidth (+ maxlen 3 1 3))
               (ncol (/ (- (window-width) 4) fwidth))
               tg cnt e c tbl subtable
               groups ingroup in-current-sequence)
          (save-excursion
            (save-window-excursion
              (if expert
                  (set-buffer (get-buffer-create " *Org todo*"))
                (el-patch-remove (delete-other-windows))
                (set-window-buffer (split-window-vertically) (get-buffer-create " *Org todo*"))
                (org-switch-to-buffer-other-window " *Org todo*")
                (el-patch-add (fit-window-to-buffer)))
              (erase-buffer)
              (setq-local org-done-keywords done-keywords)
              (setq tbl fulltable cnt 0)
              (while (setq e (pop tbl))
                (cond
                 ((equal e '(:startgroup))
                  (push '() groups) (setq ingroup t)
                  (unless (= cnt 0)
                    (setq cnt 0)
                    (insert "\n"))
                  (setq prompt (concat prompt "{"))
                  (insert "{ "))
                 ((equal e '(:endgroup))
                  (setq ingroup nil cnt 0 in-current-sequence nil)
                  (setq prompt (concat prompt "}"))
                  (insert "}\n"))
                 ((equal e '(:newline))
                  (unless (= cnt 0)
                    (setq cnt 0)
                    (insert "\n")
                    (setq e (car tbl))
                    (while (equal (car tbl) '(:newline))
                      (insert "\n")
                      (setq tbl (cdr tbl)))))
                 (t
                  (setq tg (car e) c (cdr e))
                  (if (equal tg head) (setq in-current-sequence t))
                  (when ingroup (push tg (car groups)))
                  (when in-current-sequence (push e subtable))
                  (setq tg (org-add-props tg nil 'face
                                          (org-get-todo-face tg)))
                  (when (and (= cnt 0) (not ingroup)) (insert "  "))
                  (setq prompt (concat prompt "[" (char-to-string c) "] " tg " "))
                  (insert "[" c "] " tg (make-string
                                         (- fwidth 4 (length tg)) ?\ ))
                  (when (and (= (setq cnt (1+ cnt)) ncol)
                             ;; Avoid lines with just a closing delimiter.
                             (not (equal (car tbl) '(:endgroup))))
                    (insert "\n")
                    (when ingroup (insert "  "))
                    (setq cnt 0)))))
              (insert "\n")
              (goto-char (point-min))
              (unless expert (org-fit-window-to-buffer))
              (message (concat "[a-z..]:Set [SPC]:clear"
                               (if expert (concat "\n" prompt) "")))
              (setq c (let ((inhibit-quit t)) (read-char-exclusive)))
              (setq subtable (nreverse subtable))
              (cond
               ((or (= c ?\C-g)
                    (and (= c ?q) (not (rassoc c fulltable))))
                (setq quit-flag t))
               ((= c ?\ ) nil)
               ((setq e (or (rassoc c subtable) (rassoc c fulltable))
                      tg (car e))
                tg)
               (t (setq quit-flag t)))))))

      (el-patch-defun org-add-log-note (&optional _purpose)
        "Pop up a window for taking a note, and add this note later."
        (remove-hook 'post-command-hook 'org-add-log-note)
        (setq org-log-setup nil)
        (setq org-log-note-window-configuration (current-window-configuration))
        (el-patch-remove (delete-other-windows))
        (move-marker org-log-note-return-to (point))
        (pop-to-buffer-same-window (marker-buffer org-log-note-marker))
        (goto-char org-log-note-marker)
        (org-switch-to-buffer-other-window "*Org Note*")
        (erase-buffer)
        (if (memq org-log-note-how '(time state))
            (org-store-log-note)
          (let ((org-inhibit-startup t)) (org-mode))
          (insert (format "# Insert note for %s.
# Finish with C-c C-c, or cancel with C-c C-k.\n\n"
                          (cl-case org-log-note-purpose
                            (clock-out "stopped clock")
                            (done "closed todo item")
                            (reschedule "rescheduling")
                            (delschedule "no longer scheduled")
                            (redeadline "changing deadline")
                            (deldeadline "removing deadline")
                            (refile "refiling")
                            (note "this entry")
                            (state
                             (format "state change from \"%s\" to \"%s\""
                                     (or org-log-note-previous-state "")
                                     (or org-log-note-state "")))
                            (t (error "This should not happen")))))
          (when org-log-note-extra (insert org-log-note-extra))
          (setq-local org-finish-function 'org-store-log-note)
          (run-hooks 'org-log-buffer-setup-hook)))

      (el-patch-defun org-insert-structure-template (type)
        "Insert a block structure of the type #+begin_foo/#+end_foo.
Select a block from `org-structure-template-alist' then type
either RET, TAB or SPC to write the block type.  With an active
region, wrap the region in the block.  Otherwise, insert an empty
block.

When foo is written as FOO, upcase the #+BEGIN/END as well."
        (interactive
         (list (pcase (org--insert-structure-template-mks)
	         (`("\t" . ,_)
                  (let ((type (read-string "Structure type: ")))
                    (when (string-empty-p type) (user-error "Empty structure type"))
                    type))
	         (`(,_ ,choice . ,_) choice))))
        (when (or (not (stringp type)) (string-empty-p type))
          (error "Invalid structure type: %S" type))
        (let* ((case-fold-search t) ; Make sure that matches are case-insensitive.
               (region? (use-region-p))
	       (region-start (and region? (region-beginning)))
	       (region-end (and region? (copy-marker (region-end))))
	       (extended? (string-match-p (el-patch-swap "\\`\\(src\\|export\\)\\'"
                                                         "\\`\\(src\\|export\\|aside\\)\\'")
                                          type))
	       (verbatim? (string-match-p
		           (concat "\\`" (regexp-opt '("example" "export"
                                                       "src" "comment")))
		           type))
               (upcase? (string= (car (split-string type))
                                 (upcase (car (split-string type))))))
          (when region? (goto-char region-start))
          (let ((column (current-indentation)))
            (if (save-excursion (skip-chars-backward " \t") (bolp))
	        (forward-line 0)
	      (insert "\n"))
            (save-excursion
	      (indent-to column)
	      (insert (format "#+%s_%s%s\n" (if upcase? "BEGIN" "begin") type (if extended? " " "")))
	      (when region?
	        (when verbatim? (org-escape-code-in-region (point) region-end))
	        (goto-char region-end)
	        ;; Ignore empty lines at the end of the region.
	        (skip-chars-backward " \r\t\n")
	        (end-of-line))
	      (unless (bolp) (insert "\n"))
	      (indent-to column)
	      (insert (format "#+%s_%s" (if upcase? "END" "end") (car (split-string type))))
	      (if (looking-at "[ \t]*$") (replace-match "")
	        (insert "\n"))
	      (when (and (eobp) (not (bolp))) (insert "\n")))
            (if extended? (end-of-line)
	      (forward-line)
	      (skip-chars-forward " \t")))))

      (el-patch-defun org-offer-links-in-entry (buffer marker &optional nth zero)
        "Offer links in the current entry and return the selected link.
If there is only one link, return it.
If NTH is an integer, return the NTH link found.
If ZERO is a string, check also this string for a link, and if
there is one, return it."
        (with-current-buffer buffer
          (org-with-wide-buffer
           (goto-char marker)
           (let ((cnt ?0)
                 have-zero end links link c)
             (when (and (stringp zero) (string-match org-link-bracket-re zero))
               (push (match-string 0 zero) links)
               (setq cnt (1- cnt) have-zero t))
             (save-excursion
               (org-back-to-heading t)
               (setq end (save-excursion (outline-next-heading) (point)))
               (while (re-search-forward org-link-any-re end t)
                 ;; Only consider valid links or links openable via
                 ;; `org-open-at-point'.
                 (when (memq (org-element-type (org-element-context)) '(link comment comment-block node-property keyword))
                   (push (match-string 0) links)))
               (setq links (org-uniquify (reverse links)))
               (el-patch-add (narrow-to-region (org-entry-beginning-position)
                                               (org-entry-end-position))))
             (cond
              ((null links)
               (message "No links"))
              ((equal (length links) 1)
               (setq link (car links)))
              ((and (integerp nth) (>= (length links) (if have-zero (1+ nth) nth)))
               (setq link (nth (if have-zero nth (1- nth)) links)))
              (t                        ; we have to select a link
               (save-excursion
                 (save-window-excursion
                   (el-patch-remove (delete-other-windows))
                   (with-output-to-temp-buffer "*Select Link*"
                     (dolist (l links)
                       (cond
                        ((not (string-match org-link-bracket-re l))
                         (princ (format "[%c]  %s\n" (cl-incf cnt)
                                        (org-unbracket-string "<" ">" l))))
                        ((match-end 2)
                         (princ (format "[%c]  %s (%s)\n" (cl-incf cnt)
                                        (match-string 2 l) (match-string 1 l))))
                        (t (princ (format "[%c]  %s\n" (cl-incf cnt)
                                          (match-string 1 l)))))))
                   (org-fit-window-to-buffer (get-buffer-window "*Select Link*"))
                   (message "Select link to open, RET to open all:")
                   (setq c (read-char-exclusive))
                   (and (get-buffer "*Select Link*") (kill-buffer "*Select Link*"))))
               (when (equal c ?q) (user-error "Abort"))
               (if (equal c ?\C-m)
                   (setq link links)
                 (setq nth (- c ?0))
                 (when have-zero (setq nth (1+ nth)))
                 (unless (and (integerp nth) (>= (length links) nth))
                   (user-error "Invalid link selection"))
                 (setq link (nth (1- nth) links)))))
             (cons link end))))))))

(setup org
  (:status opinionated
    (defun akirak/ad-reuse-mode-window (&rest _)
      ;; Assume `switch-to-buffer-obey-display-actions' is t.
      (unless (car-safe display-buffer-overriding-action)
        (display-buffer-override-next-command
         (lambda (buffer alist)
           (let ((alist (append '((inhibit-same-window . t)) alist))
                 window type)
             (if (setq window (display-buffer-reuse-mode-window
                               buffer alist))
                 (setq type 'reuse)
               (setq window (display-buffer-use-some-window buffer alist)
                     type 'reuse))
             (cons window type))))))

    (advice-add 'org-agenda-goto
                :before #'akirak/ad-reuse-mode-window)
    (advice-add 'org-memento-timeline-open-entry
                :before #'akirak/ad-reuse-mode-window)))

(setup org-capture
  (:status opinionated
    (:el-patch
      (el-patch-defun org-capture-place-template (&optional inhibit-wconf-store)
        "Insert the template at the target location, and display the buffer.
When INHIBIT-WCONF-STORE is non-nil, don't store the window configuration, as it
may have been stored before."
        (unless inhibit-wconf-store
          (org-capture-put :return-to-wconf (current-window-configuration)))
        (el-patch-remove (delete-other-windows))
        (org-switch-to-buffer-other-window
         (org-capture-get-indirect-buffer (org-capture-get :buffer) "CAPTURE"))
        (widen)
        (org-show-all)
        (goto-char (org-capture-get :pos))
        (setq-local outline-level 'org-outline-level)
        (pcase (org-capture-get :type)
          ((or `nil `entry) (org-capture-place-entry))
          (`table-line (org-capture-place-table-line))
          (`plain (org-capture-place-plain-text))
          (`item (org-capture-place-item))
          (`checkitem (org-capture-place-item)))
        (setq-local org-capture-current-plist org-capture-plist)
        (org-capture-mode 1)))))

Post init

Load my personal settings after all the things.

(setup init
  (:status personal
    (let ((file "~/org/config.el"))
      (when (file-readable-p file)
        (load-file file)))

    (when (and custom-file (file-readable-p custom-file))
      (load custom-file))))

Notes

How to develop this configuration

This configuration is maintained in Org.

Use org-capture to add an entry to the configuration file. It should contain a source block with a package name.
Add further configuration for the package. Optionally set tags on the heading.
When the buffer is saved, Org entries are automatically sorted by package name. This feature depends on the pre-commit hook of this repository.

Tag statistics

The following source block generates a list of tags in this document. If you have org-ql installed, you can browse matching entries by pressing C-c C-o on a link in the table.

(->> (org-ql-select (current-buffer)
       '(and (level > 2)
             (not (tags "ARCHIVE"))
             (not (tags "noexport")))
       :action '(org-get-tags))
     (--filter (not (member "@note" it)))
     (-flatten-n 1)
     (delete "akirak")
     (-group-by #'identity)
     (-map (pcase-lambda (`(,tag . ,items))
             (cons tag (length items))))
     (-sort (-on #'> #'cdr))
     (-map (pcase-lambda (`(,tag . ,count))
             (list (format "[[org-ql-search:tags:%s][%s]]" tag tag)
                   count))))

Note that the table above is invisible on GitHub. There is a table right before paragraph.

Web development

The following packages (tagged web) are related to web development:

Heading	Todo
graphql-mode
restclient
tagedit

You will want to test web APIs from inside Emacs. You can choose either restclient or verb for this purpose.
I am not sure if Indium or skewer-mode is suitable for modern web development. I have never used any of them.

Syntax support

There are some packages for structured editing:

Heading	Todo
lispy
puni

I like the idea of combobulate, but it looks immature at present. I will consider it in the future.

Readability

I want to care about readability in the following modes:

[ ] nov
[ ] info
[ ] helpful

See examples in nov.el: Major mode for reading EPUBs in Emacs.

Artificial intelligence / LLM

Heading	Todo
copilot
elysium
gptel

For LLM integration, gptel is the generic frontend and backend.

There are several packages for streaming coding workflows. For now, I am only using elysium. I am also trying out other editors for coding, which is not documented here.

Extra dependencies

@extra tag is used to denote packages that requires large dependencies. To use these features, they need to be turned on at build time.

Heading	Todo
orgabilize-playwright
org-bb
org-memento
org-recur
beancount
dune
elx
epkg
epkg-marginalia
flycheck
fstar-mode
lean4-mode
lsp-mode
mcp
mermaid-mode
Coq
tuareg
utop

Links

Heading	Todo
orglink
link-hint
orgit

Window management

Heading	Todo
fullframe
windmove
winner
akirak-window
popper
repl-toggle
windswap

Annotating

You can use org-remark to annotate texts in file buffers.

To annotate EPUB files in nov.el, you can use org-noter. It also supports PDF files (via pdf-tools package), but I won’t use pdf-tools package.

Natural languages

Heading	Todo
fanyi

Grep

affe doesn’t look mature enough, but I will re-evaluate it later.

Sh-emulation keybindings

I rebind the following keys in some keymaps to emulate a typical UNIX shell: C-a, C-e, C-u, C-w, C-h.

License

This repository is licensed under multiple licenses. It follows the conventions of REUSE, and the license files are stored under LICENSES directory. For the license of a specific file, check an SPDX license identifier in the file.

akirak/emacs-config

About

Topics

Resources

Uh oh!

Stars

Watchers

Forks

Releases 27

Packages 0

Uh oh!

Contributors 4

Uh oh!

Languages

Packages