Dotfiles

home directory

echo -n '~'

config directory

echo '~/.config'

document directory

(file-name-concat "~/" "<<laptop-node()>>" "doc")

data directory

realpath "${HOME}/data"

share directory

echo -n '~/.local/share'

media directory

<<media-dir()>>

echo -n '~/.local/share/video'

trash directory

(funcall (if (= full-path 0) #'identity #'expand-file-name)
         "~/.local/share/Trash")

d <<trash-dir(full-path=1)>>/files - - - 1w

log file directory

echo -n '~/.local/state/log'

<<log-dir()>>

Smtp Server Host   crypt

Dummy Smtp Server Host

smtp.dummy.com

My Email Address   crypt

Dummy Email Address

user@dummy.com

Full Name   crypt

Dummy Full Name

taro.yamada

My Login Name

user-login-name

My Domain Name

echo -n "${EMAIL}" | cut -d'@' -f2

Primary Laptop

uname -n

Apt Package Manager

Channels

(list (channel
       (name 'nonguix)
       (url "https://gitlab.com/nonguix/nonguix"))
      (channel
       (name 'guix)
       (url "https://git.savannah.gnu.org/git/guix.git"))
      (channel
       (name 'guix-jp)
       (url "https://gitlab.com/guix-jp/channel")
       (branch "main"))
      (channel
       (name 'p-snow)
       (url "https://github.com/p-snow/guix-channel")
       (introduction
        (make-channel-introduction
         "3a10227fbc2d5e9744aced43f820a0d3bf64add5"
         (openpgp-fingerprint
          "CF56 FC53 3AD6 6A67 6FDC  1D73 0D2B AF0E 8AEF 0306")))))

update-channels

guix pull --channels=$HOME/.config/guix/base-channels.scm \
  && guix describe --format=channels > ~/.config/guix/channels.scm

Profiles

echo -n '~/.guix-extra-profiles'

export GUIX_EXTRA_PROFILES=<<guix/ex-prof()>>

# fill in a variable below like a comment line
# if you'd like to acticate specific profiles under GUIX_EXTRA_PROFILES
ACTIVE_PROFILE_NAMES=()
# ACTIVE_PROFILE_NAMES=(base emacs)

profiles=()
if [ ${#ACTIVE_PROFILE_NAMES[@]} -eq 0 ]; then
  profiles="${GUIX_EXTRA_PROFILES}/*"
else
  for name in ${ACTIVE_PROFILE_NAMES[@]}; do
    profiles+=("${GUIX_EXTRA_PROFILES}/${name}")
  done
fi

for profile in ${profiles[@]}; do
  GUIX_PROFILE="${profile}/$(basename ${profile})"
  if [ -f ${GUIX_PROFILE}/etc/profile ]; then
    . "${GUIX_PROFILE}"/etc/profile
  fi
  if [ -d ${GUIX_PROFILE}/share ]; then
    export XDG_DATA_DIRS=${GUIX_PROFILE}/share${XDG_DATA_DIRS:+:}$XDG_DATA_DIRS
  fi
  if [ -d ${GUIX_PROFILE}/share/man ]; then
    export MANPATH=${GUIX_PROFILE}/share/man${MANPATH:+:}$MANPATH
  fi
done

# export GUIX_PROFILE="$HOME/.guix-profile"
# . "$GUIX_PROFILE/etc/profile"

export GUIX_PROFILE="$HOME/.config/guix/current"
. "$GUIX_PROFILE/etc/profile"


if [ -v GUIX_ENVIRONMENT ]; then
  if [[ $PS1 =~ (.*)"\\$" ]]; then
    PS1="${BASH_REMATCH[1]} [env]\\\$ "
  fi
fi

activate-profiles base emacs

GREEN='\033[1;32m'
RED='\033[1;30m'
NC='\033[0m'
GUIX_EXTRA_PROFILES=$HOME/.guix-extra-profiles

profiles=$*
if [ $# -eq 0 ]; then
  profiles="$HOME/.config/guix/manifests/*.scm";
fi

for profile in $profiles; do
  # Remove the path and file extension, if any
  profileName=$(basename $profile)
  profileName="${profileName%.*}"
  profilePath="$GUIX_EXTRA_PROFILES/$profileName"
  manifestPath=$HOME/.config/guix/manifests/$profileName.scm

  if [ -f $manifestPath ]; then
    echo
    echo -e "${GREEN}Activating profile:" $manifestPath "${NC}"
    echo

    mkdir -p $profilePath
    guix package --manifest=$manifestPath --profile="$profilePath/$profileName"

    # Source the new profile
    GUIX_PROFILE="$profilePath/$profileName"
    if [ -f $GUIX_PROFILE/etc/profile ]; then
      . "$GUIX_PROFILE"/etc/profile
    else
      echo -e "${RED}Couldn't find profile:" $GUIX_PROFILE/etc/profile "${NC}"
    fi
  else
    echo "No profile found at path" $profilePath
  fi
done

• guix base profile
  

  (specifications->manifest
   '("coreutils"
     "diffutils"
     "parallel"
     "gawk"
     "sed"
     "tar"
     "zip"
     "unzip"
     "zstd"
     "p7zip"
     "shadow"
     "sshfs"
     "grep"
     "ripgrep"
     "man-db"
     "less"
     "pwgen"
     "file"
     "nkf"
     "lsof"
     "tree"
     "poppler"
     "stow"
     "pandoc"
     "nss-certs"
     "openssl"
     "glibc"
     "procps"
     "time"
     "htop"
     "net-tools"
     "curl"
     "wget"
     "httrack"
     "ghc-tldr"
     "network-manager"
     "wakelan"
     "speedtest-cli"
     "parted"
     "fdisk"
     "gptfdisk"
     "cryptsetup"
     "smartmontools"
     "ddrescue"
     "sqlite"
     "libarchive"
     "graphicsmagick"
     "pngquant"
     "ffmpeg@6.1.1" ; mpv requires version 6 of FFMPEG
     "dav1d"
     "jq"
     "pup"
     "htmlq"
     "python-feedparser"
     "util-linux"
     "binutils"
     "make"
     "llvm"
     "cmake"
     "libtool"
     "pkgconf"
     "texinfo"
     "shellcheck"
     "global"
     "perl"
     "pfetch"
     "neofetch"
     "python-selenium"
     "gcc-toolchain@13.3.0"
     <<guix-base>>))
  

• guix desktop profile
  

  (specifications->manifest
   '("gparted"
     "gcompris-qt"
     "gnome-disk-utility"
     "kdeconnect"
     "dia"
     "shotwell"
     "vlc"
     <<guix-desktop>>))
  

• guix creative profile   ARCHIVE
  
• guix emacs profile
  

  (specifications->manifest
   '(<<guix-emacs>>
     "sicp"
     "isync"
     "stunnel"
     "wordnet"
     "emacs-transient"
     "emacs-mocker"
     "emacs-compat"))
  

Home Configuration

;; This "home-environment" file can be passed to 'guix home reconfigure'
;; to reproduce the content of your profile.  This is "symbolic": it only
;; specifies package names.  To reproduce the exact same profile, you also
;; need to capture the channels being used, as returned by "guix describe".
;; See the "Replicating Guix" section in the manual.

(use-modules (gnu home)
             (gnu home services)
             (gnu home services shells)
             (gnu home services ssh)
             (gnu home services dotfiles)
             (gnu packages)
             (gnu packages base)
             (gnu packages fonts)
             (gnu packages fontutils)
             (gnu packages gnupg)
             (gnu services)
             (guix gexp))

(home-environment
 ;; Below is the list of packages that will show up in your
 ;; Home profile, under ~/.guix-home/profile.
 (packages (list glibc-locales fontconfig which
                 font-iosevka font-ipa font-ipa-ex font-google-noto font-inconsolata
                 font-adobe-source-han-sans))

 ;; Below is the list of Home services.  To search for available
 ;; services, run 'guix home search KEYWORD' in a terminal.
 (services
  (list
   (simple-service 'basic-env-vars-service
                   home-environment-variables-service-type
                   `(("EMAIL" . "<<email>>")
                     ("VIEWER" . "less")
                     ("EDITOR" . "emacsclient -c -a emacs")))
   (service home-bash-service-type
            (home-bash-configuration
             (guix-defaults? #t)
             (aliases '(<<print-aliases(lang="scheme")>>))
             (bashrc (list (local-file "./.bashrc" "bashrc")))))
   (service home-openssh-service-type
            (home-openssh-configuration
             (hosts
              (list (openssh-host (name "pc02")
                                  (host-name "192.168.100.127"))))))
   (service home-dotfiles-service-type
            (home-dotfiles-configuration
             (layout 'plain)
             (source-directory
              (let ((path "<<ghq-proj-path(name="p-snow/environment")>>"))
                (if (string-prefix? "~" path)
                    (string-append (getenv "HOME") (substring path 1))
                    path)))
             (directories '("home")))))))

(activate-home "cd ~/environment && make")

bashrc

export PATH="${HOME}/bin:${HOME}/.local/bin:${HOME}/.cargo/bin:$PATH"
export PS1="[\u@$(uname -n):\\W]\n\$ "

<<bashrc>>

bash functions   ARCHIVE

Shell Command Aliases

(seq-do-indexed (lambda (alias index)
                  (let ((ali (car alias))
                        (def (replace-regexp-in-string "\\\\vert" "|" (cadr alias)))
                        (param (caddr alias)))
                    (pcase lang
                      ('"plain"
                       (princ (funcall 'string-join `(,ali ,def ,param) " "))
                       (when (< index (1- (length aliases))) (princ "\n")))
                      ('"scheme"
                       (prin1 (funcall 'cons ali def))
                       (princ "\n")))))
                aliases)

systemd-tmpfiles

$ systemd-tmpfiles --user --clean

systemctl --user enable systemd-tmpfiles-clean.timer

d /home/<<login-name()>>/tmp - - - 5d
d /home/<<login-name()>>/Downloads - - - 4w
<<tmpfiles-cleanup>>

btrbk

"btrbk"

• btrbk.conf
  

  btrbk.conf documentation

  timestamp_format long
  incremental yes
  
  snapshot_preserve_min 6h
  snapshot_preserve 36h 3d 3w
  
  # Create snapshots only if the backup disk is attached
  #snapshot_create ondemand
  
  target_preserve_min latest
  
  snapshot_dir snapshots
  volume /mnt/homes
  target /mnt/exbak/<<laptop-node()>>
  
  target_preserve 2w 3m
  subvolume home-mint
  
  target_preserve 8w 6m 2y
  subvolume data
  

• snapshot/backup cron job
  

  */15 * * * * /usr/bin/bash -ci "which btrbk | xargs -I _ pwsudo _ --config ~/.config/btrbk/btrbk.conf run"
  

snapshots management   ARCHIVE

backup to another device   ARCHIVE

xdg-mime

[Added Associations]
inode/directory=io.github.celluloid_player.Celluloid.desktop;nemo.desktop;

[Default Applications]
inode/directory=nemo.desktop

Xremap   ARCHIVE

XKB   ARCHIVE

Interception Tools   ARCHIVE

keyd

sudo systemctl enable keyd
sudo systemctl start keyd

[ids]

*

[global]

oneshot_timeout = 1000

[main]

capslock = oneshot(control)
leftcontrol = oneshot(capslock)
tab = overload(numpad_layer, tab)
rightcontrol = oneshot(app_layer)
space = overload(shift, space)
' = overloadt(apostrophe_layer, ', 250)

leftshift = overload(shift, =)
rightshift = overload(shift, -)

[apostrophe_layer:M]

u = C-u

[numpad_layer:C-M]

m = 1
, = 2
. = 3
j = 4
k = 5
l = 6
u = 7
i = 8
o = 9
space = 0
; = -
/ = .

[app_layer:C-A-M]

Basic Configuration

• early-init.el
  

  Early init file defines fundamental variables used from both normal Emacs session and batch mode.

  • Paths for tangling
    

    Variables that start with "tangle/" and are used during the tangling process are also required for the main Emacs session.

    <<tangle-def()>>
    

    (let ((syms (string)))
      (obarray-map (lambda (sym)
                     (when (string-prefix-p "tangle/" (symbol-name sym))
                       (setq syms
                             (concat syms
                                     (format "(setq %s \"%s\")\n"
                                             sym (symbol-value sym))))))
                   obarray)
      syms)
    

  • package.el
    

    (require 'package)
    
    (setopt package-archives
            '(("gnu" . "https://elpa.gnu.org/packages/")
              ("nongnu" . "https://elpa.nongnu.org/nongnu/")
              ("melpa" . "https://melpa.org/packages/")
              ("p-snow" . "https://p-snow.org/packages/")))
    (setopt package-archive-priorities
            '(("gnu" . 3)
              ("melpa" . 2)
              ("nongnu" . 1)))
    (setopt package-enable-at-startup t)
    
    (require 'package-vc)
    
    (package-initialize)
    

  • load cl-lib
    

    Use 'cl-lib' rather than 'cl' package since it is officially deprecated.

    (require 'cl-lib)
    

  • use-package
    

    Official manual is handy especially when you look up Keywords.

    (require 'use-package)
    (require 'use-package-ensure)
    
    (setopt use-package-compute-statistics t
            use-package-verbose nil)
    (with-eval-after-load 'my-launch-app
      (keymap-set my/invoke-list-command-map (kbd "u")
                  #'use-package-report))
    

    use-package depends on following packages internally

    • diminish
      

      "emacs-diminish"
      

    • delight
      

      "emacs-delight"
      

  • straight.el   ARCHIVE
    
  • safe local eval forms
    

    Following hook statements are likely written in .dir-locals.el at the top level of git repositories.

    (add-to-list 'safe-local-eval-forms
                 '(add-hook 'find-file-hook
                            (lambda () (setq-local buffer-save-without-query t))))
    
    (add-to-list 'safe-local-eval-forms
                 '(remove-hook 'find-file-hook
                               (lambda () (setq-local buffer-save-without-query t))))
    

  • no-littering
    

    "emacs-no-littering"
    

    (setq no-littering-var-directory
          (file-name-concat "<<share-dir()>>" "emacs/var/"))
    
    (require 'no-littering)
    

• loading sequence
  
  • custom file
    

    (setopt custom-file
            (expand-file-name "custom.el" user-emacs-directory))
    
    (when (file-readable-p custom-file)
      (load custom-file))
    

  • init.el
    

    init.el devote itself to call for remaining config files.

    (push (file-name-concat user-emacs-directory "lisp") load-path)
    (push (file-name-concat user-emacs-directory "site-lisp") load-path)
    
    (let ((load-match "\\.el$"))
      (mapc #'load-file
            (append (directory-files (file-name-concat user-emacs-directory "lisp") t load-match)
                    (directory-files (file-name-concat user-emacs-directory "lisp/dedicated") t load-match))))
    

• Themes
  

  The theme of my choice at present

  (with-eval-after-load 'ef-themes
    (load-theme 'ef-bio :no-confirm))
  

  • modus-themes
    

    I love modus-theme which conforms to WCAG AAA. This blog post explains how this package determines colors theoretically and perceptually.

    Following configuration is for version 4 of modus-themes which takes breaking change from previous major version.

    (use-package modus-themes
      :disabled t
      :custom
      (modus-themes-to-toggle '(modus-vivendi
                                modus-vivendi-tinted
                                modus-vivendi-deuteranopia))
      (modus-themes-org-blocks 'tinted-background)
      (modus-themes-bold-constructs t)
      :config
      (customize-set-variable 'modus-themes-common-palette-overrides
                              modus-themes-preset-overrides-faint)
      (bind-keys ("<f6>" . modus-themes-toggle)))
    

  • ef-themes
    

    "emacs-ef-themes"
    

    (use-package ef-themes
      :init
      (setq ef-bio-palette-overrides
            '((cursor "#ffffff")))
      :custom
      (ef-themes-to-toggle ef-themes-dark-themes)
      :config
      (bind-keys ("<f9>" . ef-themes-toggle)))
    

• Basic Preferences
  

  Settings in this section are influenced a great deal by my personal preference. Please be meticulous when you borrow.

  • Modifier Keys
    

    (cond
     ((string= window-system "x")
      (setf x-meta-keysym 'meta
            x-alt-keysym 'meta
            x-super-keysym 'hyper))
     ((string= window-system "ns")
      ;; IME inline patch
      (setf mac-use-input-method-on-system nil)
      (setf mac-control-modifier       'control
            mac-command-modifier       'meta
            mac-option-modifier        'super
            mac-right-option-modifier  'alt
            mac-right-control-modifier 'super
            mac-function-modifier      'hyper)))
    

  • Basic Key Bindings
    

    (keymap-global-set "M-F" #'forward-to-word)
    (keymap-global-set "M-B" #'backward-to-word)
    (keymap-global-set "C-c d" #'duplicate-dwim)
    (keymap-global-set "C-c j" #'join-line)
    (keymap-global-set "C-c M-d" #'copy-from-above-command)
    (keymap-global-set "M-z" #'zap-up-to-char)
    (keymap-global-set "C-z" #'repeat)
    (keymap-global-set "C-x M-t" #'transpose-sentences)
    (keymap-global-set "M-T" #'transpose-paragraphs)
    
    (keymap-global-set "C-c k" #'kill-this-buffer)
    (keymap-global-set "C-x M-r" #'rename-visited-file)
    (keymap-global-set "C-M-<delete>" #'restart-emacs)
    (keymap-global-set "C-M-S-<delete>" #'save-buffers-kill-emacs)
    
    (substitute-key-definition 'upcase-region
                               'upcase-dwim
                               global-map)
    (substitute-key-definition 'downcase-region
                               'downcase-dwim
                               global-map)
    (keymap-global-set "C-x C-c" #'capitalize-dwim)
    

    • Bind for C-x C-b, use ibuffer which has more features than list-buffers based on this advice.

      (substitute-key-definition 'list-buffers
                                 'ibuffer
                                 global-map)
      

    • bind find-functions and finder commands

      (find-function-setup-keys)
      
      (keymap-set ctl-x-map "C" 'finder-commentary)
      

  • Unleash Disabled Commands
    

    (put 'upcase-region 'disabled nil)
    (put 'downcase-region 'disabled nil)
    (put 'narrow-to-region 'disabled nil)
    (put 'set-goal-column 'disabled nil)
    (put 'buffer-save-without-query 'disabled nil)
    (put 'scroll-left 'disabled nil)
    (put 'scroll-right 'disabled nil)
    

  • Language
    

    emacs#Language Environments

    ;; language and locale
    (set-language-environment "Japanese")
    (setq system-time-locale "C")
    
    ;; coding system
    (set-default-coding-systems 'utf-8-unix)
    (prefer-coding-system 'utf-8-unix)
    (set-selection-coding-system 'utf-8-unix)
    
    ;; prefer-coding-system take effect equally to follows
    (set-buffer-file-coding-system 'utf-8-unix)
    (set-file-name-coding-system 'utf-8-unix)
    (set-terminal-coding-system 'utf-8-unix)
    (set-keyboard-coding-system 'utf-8-unix)
    (setq locale-coding-system 'utf-8-unix)
    

  • Fontsets
    

    (create-fontset-from-ascii-font "IPAGothic" nil "default")
    
    (create-fontset-from-ascii-font "IPAexMincho" nil "exmincho")
    (set-fontset-font "fontset-exmincho" 'japanese-jisx0208 "IPAexMincho")
    
    (create-fontset-from-ascii-font "IPAexGothic" nil "exgothic")
    (set-fontset-font "fontset-exgothic" 'japanese-jisx0208 "IPAexGothic")
    
    (create-fontset-from-ascii-font "IPAMincho" nil "mincho")
    (set-fontset-font "fontset-mincho" 'japanese-jisx0208 "IPAMincho")
    (set-fontset-font "fontset-mincho" 'symbol "IPAMincho")
    
    (create-fontset-from-ascii-font "Iosevka" nil "code")
    (set-fontset-font "fontset-code" 'latin (font-spec :family "Iosevka" :weight 'Light :width 'Normal))
    
    ;; foreign fonts for all fontsets
    (set-fontset-font t 'emoji "Noto Color Emoji")
    (set-fontset-font t 'symbol "Noto Sans CJK JP" nil 'append)
    (set-fontset-font t 'symbol "Noto Sans Symbols" nil 'append)
    (set-fontset-font t 'symbol "Noto Sans Symbols2" nil 'append)
    

  • Faces
    

    Caveat: I am visually impaired, so the font size for the default face is extraordinarily large.

    face name	font
    default	IPAGothic
    fixed-pitch	IPAMincho
    fixed-pitch-serif	Iosevka
    variable-pitch	IPAExMincho
    variable-pitch-text	IPAExGothic

    (defvar my/default-pixel-width 2560 "Default display width in pixel.")
    (defmacro my/normalized-font-size (original-size)
      "This macro culculates normalized font size for display resolution at runtime.
    It tries to proportionate ORIGINAL-SIZE in `my/default-pixel-width' in the display at runtime."
      `(truncate (* ,original-size (/ (float (x-display-pixel-width))
                                      ,my/default-pixel-width))))
    
    (set-face-attribute 'default
                        nil
                        :font "fontset-default"
                        :height (my/normalized-font-size 620))
    (set-face-attribute 'fixed-pitch
                        nil
                        :font "fontset-mincho")
    (set-face-attribute 'fixed-pitch-serif
                        nil
                        :font "fontset-code")
    (set-face-attribute 'variable-pitch
                        nil
                        :font "fontset-exmincho")
    (set-face-attribute 'variable-pitch-text
                        nil
                        :font "fontset-exgothic")
    
    (use-package face
      :no-require t
      :hook
      ((eww-mode mastodon-mode nov-mode mu4e-view-mode elfeed-show-mode)
       . (lambda ()
           (buffer-face-set (check-face 'variable-pitch-text))
           (text-scale-set 5.0)))
      ((Info-mode help-mode helpful-mode woman-mode devdocs-mode)
       . (lambda ()
           (buffer-face-set (check-face 'default))
           (text-scale-set 1.3)))
      ((org-mode text-mode mu4e-compose-mode)
       . (lambda ()
           (buffer-face-set (check-face 'default))))
      ((prog-mode shell-mode term-mode vterm-mode eshell-mode calendar-mode)
       . (lambda ()
           (buffer-face-set (check-face 'fixed-pitch-serif))
           (text-scale-set -1.2)))
      ((dired-mode mu4e-headers-mode elfeed-search-update)
       . (lambda ()
           (buffer-face-set (check-face 'fixed-pitch)))))
    

  • Performance Tuning
    

    (setq auto-window-vscroll nil)
    (setq-default bidi-display-reordering nil)
    (setq bidi-inhibit-bpa t)
    

• Custom Variables
  

  Entries in this section represnets Customization Groups hierarchy.

  • Files
    

    (setopt create-lockfiles nil
            remote-file-name-inhibit-locks t)
    

    • Auto Revert
      

      Auto Revert: Keeping buffers automatically up-to-date.

      (use-package autorevert
        :diminish (global-auto-revert-mode auto-revert-mode)
        :custom
        (auto-revert-verbose nil)
        (global-auto-revert-non-file-buffers t)
        (auto-revert-interval 3)
        (auto-revert-check-vc-info t)
        (global-auto-revert-mode t))
      

    • Auto Save
      

      Auto Save mode saves the file you are editing periodically, whereas auto-save-visited-mode saves all open buffers in Emacs session.

      (setopt auto-save-default t
              auto-save-interval 200
              auto-save-timeout 25
              auto-save-file-name-transforms
              `((".*" ,(no-littering-expand-var-file-name "auto-save/files") t))
              delete-auto-save-files t
              kill-buffer-delete-auto-save-files t
              auto-save-no-message t)
      
      (setopt auto-save-visited-mode t
              auto-save-visited-interval 10)
      (put 'auto-save-visited-mode 'disabled nil)
      
      (setopt delete-by-moving-to-trash t)
      (setopt save-some-buffers-default-predicate 'save-some-buffers-root)
      

    • Uniquify
      

      Uniquify shows buffer name easy to distinguish.

      (use-package uniquify
        :custom
        (uniquify-buffer-name-style 'post-forward))
      

    • Recentf
      

      emacs#File Conveniences

      (use-package recentf
        :hook (after-init . recentf-mode)
        :custom
        (recentf-exclude '(".gz" ".xz" ".zip" ".gpg"))
        (recentf-max-saved-items 500)
        ;; clean-up when idle time reaches 7 minutes
        (recentf-auto-cleanup (* 7 60)))
      

    • Tramp
      

      (use-package tramp
        :defer t
        :custom
        (tramp-default-method "ssh")
        :config
        (add-to-list 'tramp-remote-path 'tramp-own-remote-path)
        (add-to-list 'tramp-remote-path "~/bin"))
      

    • Find File
      

      (setopt large-file-warning-threshold 30000000)
      (setopt revert-buffer-quick-short-answers t)
      

    • Backup
      

      I no longer use backup functionality. Even if I reinstate it, backing up by copying must be rational.

      (setopt make-backup-files nil
              backup-by-copying t
              backup-directory-alist
              `(("." . ,(no-littering-expand-var-file-name "backup"))))
      

  • Environment
    
    • Initialization
      

      (setopt initial-scratch-message "")
      (setopt inhibit-startup-screen t)
      

    • Frames
      

      (tool-bar-mode -1)
      (menu-bar-mode -1)
      (scroll-bar-mode -1)
      

      • Fringe
        

        (set-fringe-mode 15)
        (setq-default indicate-buffer-boundaries 'left)
        

      • Two Column
        

        (use-package two-column
          :commands (2C-two-columns 2C-split 2C-associate-buffer)
          :custom
          (2C-window-width 25))
        

      • Desktop
        

        Info manual for Saving Emacs Sessions describes how to set up desktop-save-mode. '–no-desktop' option for emacs command will disable forcibly desktop-save-mode .

        (use-package desktop
          :commands (desktop-save)
          :custom
          (desktop-restore-frames t)
          (desktop-restore-eager 1)
          (desktop-lazy-idle-delay 5)
          :config
          (desktop-change-dir (expand-file-name "desktop" user-emacs-directory))
          (desktop-save-mode 1))
        

      • Cursor
        

        (setopt blink-cursor-blinks 15
                blink-cursor-delay 0.7
                blink-cursor-interval 0.35
                blink-cursor-mode t)
        

      • Scrolling
        

        (setopt fast-but-imprecise-scrolling t)
        

    • Display
      

      ;; do not use visual bell
      (setopt visible-bell nil)
      
      (setopt text-scale-mode-step 1.0625
              highlight-nonselected-windows t
              truncate-lines t
              x-underline-at-descent-line nil)
      ;; avoid to break at whitespace in Japanese
      (setopt word-wrap-by-category t)
      ;; suppress curved quotes in docstring (for emacs25)
      (setopt text-quoting-style 'straight)
      ;; resize frame size responding to font size
      (setopt global-text-scale-adjust-resizes-frames t)
      

    • Windows
      

      This blog post is must-read when you tweak display-buffer facilities or something related to display settings.

      (setopt scroll-step 1
              scroll-conservatively 101
              next-screen-context-lines 2
              scroll-preserve-screen-position t)
      ;; display buffer
      (setopt display-buffer-base-action
              '((display-buffer-same-window
                 display-buffer-reuse-window
                 display-buffer-reuse-mode-window
                 display-buffer-in-previous-window)))
      
      (bind-keys :map other-window-repeat-map
                 ("0" . delete-window)
                 ("1" . delete-other-windows))
      

      • Winner
        

        Triple Escape (M-ESC ESC) has got to reset window layout by tweaking buffer-quit-function.

        (use-package winner
          :bind (("H-z" . winner-undo)
                 ("H-M-z" . winner-redo))
          :custom
          (winner-mode t)
          :config
          (setq buffer-quit-function 'winner-undo))
        

      • Windmove
        

        You can now switch windows with your shift key by pressing S-<left>, S-<right>, S-<up>, S-<down>.

        (use-package windmove
          :bind (("C-x C-<left>"    . windmove-left)
                 ("C-x C-<right>"   . windmove-right)
                 ("C-x C-<up>"      . windmove-up)
                 ("C-x C-<down>"    . windmove-down)
                 ("C-x C-S-<left>"  . windmove-swap-states-left)
                 ("C-x C-S-<right>" . windmove-swap-states-right)
                 ("C-x C-S-<up>"    . windmove-swap-states-up)
                 ("C-x C-S-<down>"  . windmove-swap-states-down)
                 ("C-x C-M-<left>"  . windmove-delete-left)
                 ("C-x C-M-<right>" . windmove-delete-right)
                 ("C-x C-M-<up>"    . windmove-delete-up)
                 ("C-x C-M-<down>"  . windmove-delete-down))
          :custom
          (windmove-mode t)
          (windmove-wrap-around t)
          :config
          (defvar-keymap my/windmove-repeat-map
            :doc "Keymap to repeat windmove commands."
            :repeat (:enter (windmove-left
                             windmove-right
                             windmove-up
                             windmove-down
                             windmove-swap-states-left
                             windmove-swap-states-right
                             windmove-swap-states-up
                             windmove-swap-states-down
                             windmove-delete-left
                             windmove-delete-right
                             windmove-delete-up
                             windmove-delete-down))
            "<left>"  #'windmove-left
            "<right>" #'windmove-right
            "<up>"    #'windmove-up
            "<down>"  #'windmove-down
            "S-<left>"  #'windmove-swap-states-left
            "S-<right>" #'windmove-swap-states-right
            "S-<up>"    #'windmove-swap-states-up
            "S-<down>"  #'windmove-swap-states-down
            "M-<left>"  #'windmove-delete-left
            "M-<right>" #'windmove-delete-right
            "M-<up>"    #'windmove-delete-up
            "M-<down>"  #'windmove-delete-down))
        

    • Minibuffer
      

      (setopt history-length 1500)
      (setopt history-delete-duplicates t)
      (setopt enable-recursive-minibuffers t)
      (setopt minibuffer-depth-indicate-mode t)
      (setopt read-file-name-completion-ignore-case t)
      (setopt read-minibuffer-restore-windows t)
      (setopt minibuffer-default-prompt-format " [%s]")
      (setopt completion-cycle-threshold 1)
      (setopt completions-detailed t)
      
      (add-hook 'minibuffer-setup-hook 'my/minibuffer-setup-function)
      (defun my/minibuffer-setup-function ()
        ;; disable input method in mini buffer
        (when current-input-method
          (deactivate-input-method))
        ;; decrease font size to 90% in minibuffer
        (setq-local face-remapping-alist '((default :height 0.9))))
      

      Formerly, I used to bind C-h to backward-delete-char and M-h to backward-kill-word, which was very comfortable. However, I realized that C-h should be a help key, as many Emacs packages are developed with the assumption that "C-h is a help key." That said, in the minibuffer where a help key does not necessarily play a significant role, I decided to bind C-h to backward-delete-char.

      (keymap-set minibuffer-mode-map
                  "C-h" #'delete-backward-char)
      (keymap-set minibuffer-mode-map
                  "M-h" #'backward-kill-word)
      (keymap-set minibuffer-mode-map "TAB" 'minibuffer-complete)
      

      • Savehist
        

        savehist-mode saves minibuffer history and additionals.

        (use-package savehist
          :custom
          (savehist-save-minibuffer-history t)
          (savehist-additional-variables '((kill-ring . 1000)
                                           (compile-command . 1000)))
          (savehist-autosave-interval 180)
          :hook
          (after-init . savehist-mode))
        

    • Menu
      

      This blog post demonstrates for emacsers who have disabled file pickers and dialog boxes to adversely use them temporalily.

      (setopt use-short-answers t)
      (setopt use-file-dialog nil)
      

    • Mode Line
      

      (defvar my/mode-line-buffer-name-length-max 15
        "Fixed length for displaying buffer name in mode line.")
      
      (setopt line-number-mode nil
              column-number-mode nil
              mode-line-compact t)
      (setopt mode-line-format
              '("%e"
                (:eval (my/tab-bar-mode-line-string))
                mode-line-front-space
                (:eval
                 (let ((mode-line-buffer-name
                        (replace-regexp-in-string " %\\([[:ascii:]]\\)" " %%\\1"
                                                  (truncate-string-to-width
                                                   (buffer-name) my/mode-line-buffer-name-length-max nil ? t))))
                   (cond
                    (buffer-read-only
                     (propertize mode-line-buffer-name 'face 'underline))
                    ((buffer-modified-p)
                     (propertize mode-line-buffer-name 'face 'warning))
                    (mode-line-buffer-name))))
                (:eval
                 (cond
                  ((and line-number-mode
                        column-number-mode)
                   mode-line-position-column-line-format)
                  (line-number-mode mode-line-position-line-format)
                  (column-number-mode mode-line-position-column-format)))
                " "
                global-mode-string))
      

      • Display Time
        

        (setopt
         display-time-string-forms
         '((propertize (format-time-string "%H:%M" now) 'face 'mode-line-highlight)))
        (setopt display-time-mode t)
        

    • Mouse
      

      Mouse needs to be unobtrusive in my Emacs experience.

      (use-package mouse
        :custom
        (mouse-1-click-follows-link nil)
        (mouse-highlight nil)
        (mouse-wheel-mode nil))
      
      (use-package pixel-scroll
        :custom
        (pixel-scroll-precision-mode t))
      

      • Tool Tips
        

        (tooltip-mode -1)
        (setq x-gtk-use-system-tooltips nil)
        

    • Hardware
      
      • Battery
        

        (use-package battery
          :after my-launch-app
          :bind (:map my/launch-app-map
                      ("b" . battery)))
        

    • Installation
      

      (use-package tutorial
        :commands help-with-tutorial
        :preface
        (defun my/tutorial--saved-dir ()
          (locate-user-emacs-file
           (no-littering-expand-var-file-name "tutorial/")
           (expand-file-name "tutorial/" user-emacs-directory)))
        :config
        (advice-add #'tutorial--saved-dir :override
                    #'my/tutorial--saved-dir))
      

  • Convenience
    

    subword-mode enables to recognize 'RSS' and 'Feed' are separate words in 'RSSFeed'

    (repeat-mode 1)
    (global-subword-mode 1)
    

    • Abbreviations
      

      (use-package abbrev
        :diminish abbrev-mode
        :custom
        (save-abbrevs t)
        :config
        (setq-default abbrev-mode 1)
        (quietly-read-abbrev-file))
      

    • Hippie Expand
      

      As this blog post mentions, Hippie Expansion is superior to dabbrev, skeleton and company in the field of auto typing.

      (use-package hippie-exp
        :bind ([remap dabbrev-expand] . hippie-expand))
      

    • Hl Line
      

      (use-package hl-line
        :hook (vterm-mode . (lambda () (hl-line-mode -1)))
        :config
        (hl-line-mode 1))
      

    • Visual Line
      

      (use-package visual-line
        :no-require t
        :after adaptive-wrap
        :hook
        ((feed-show-mode eww-after-render help-mode helpful-mode Info-mode woman-mode
                         mu4e-view-mode nov-mode devdocs-mode)
         . visual-line-mode)
        ((feed-show-mode eww-after-render help-mode helpful-mode Info-mode woman-mode
                         mu4e-view-mode nov-mode devdocs-mode)
         . adaptive-wrap-prefix-mode)
        :custom
        (global-visual-line-mode nil))
      

    • Whitespace
      

      emacs#Useless Whitespace

      (use-package whitespace
        :diminish ((global-whitespace-mode . "Ws")
                   (whitespace-mode . "ws"))
        :hook
        ((org-mode prog-mode dired-mode) . whitespace-mode)
        (eww-mode . whitespace-turn-off)
        (before-save . delete-trailing-whitespace)
        :custom
        (whitespace-style
         '(face trailing tabs tab-mark spaces space-mark empty missing-newline-at-eof))
        (whitespace-action '(cleanup auto-cleanup))
        (whitespace-space-regexp "\\(\x3000+\\)")
        (whitespace-trailing-regexp "\\([ \t\u00A0]+\\)$")
        (whitespace-display-mappings
         '((space-mark ?\x3000 [?\u2423])
           (tab-mark   ?\t   [?\u00BB ?\t])))
        (global-whitespace-mode nil))
      

    • So Long
      

      (setopt global-so-long-mode t)
      

    • Tab Bar
      

      (use-package tab-bar
        :custom
        (tab-bar-show 8)
        (tab-bar-history-mode t)
        (tab-bar-tab-hints t)
        (tab-bar-tab-name-function (apply-partially #'my/project-root-path t))
        :preface
        (defun my/tab-bar-mode-line-string ()
          "Return the name for the current tab."
          (format "%s)"
                  (assoc-default 'name
                                 (assoc-default 'current-tab
                                                (funcall tab-bar-tabs-function)))))
        (defun my/project-root-path (&optional base-name)
          "Return an absolute path for `project-current' or base name if BASE-NAME is non-nil."
          (if-let (project (project-current))
              (funcall (if base-name #'file-name-nondirectory #'identity)
                       (directory-file-name (project-root project)))
            (buffer-name)))
        :config
        (with-eval-after-load 'consult
          (bind-keys :map tab-prefix-map
                     ("B" . consult-buffer-other-tab))))
      
      (keymap-global-set "H-t" tab-prefix-map)
      (keymap-set tab-prefix-map "s" #'tab-switcher)
      

    • Ffap
      

      (require 'ffap)
      
      (ffap-bindings)
      

    • Kmacro
      

      The power of keyboard macro is more than repeating editing commands. This post explains fluently.

      (require 'kmacro)
      
      (defalias 'kmacro-insert-macro 'insert-kbd-macro)
      (keymap-set kmacro-keymap "I" #'kmacro-insert-macro)
      

    • Register
      

      (use-package register
        :bind ("H-r" . jump-to-register)
        :custom
        (register-preview-delay nil)
        :config
        (with-eval-after-load 'savehist
          (add-to-list 'savehist-additional-variables
                       'register-alist)))
      

  • Editing
    

    ;; the point will be at the beginning of duplicated lines
    (setopt duplicate-line-final-position 1)
    

    • Indent
      

      See also aggressive-indent-mode

      (setopt tab-always-indent 'complete
              indent-tabs-mode nil
              tab-first-completion 'word-or-paren-or-punct)
      

    • Electricity
      

      (setopt electric-indent-mode nil)
      

    • Fill
      

      (setopt fill-column 80
              sentence-end-double-space nil)
      

    • Killing
      

      The save-interprogram-paste-before-kill variable controls whether clipboard text is moved to the kill-ring when some text is killed in Emacs. This is something I've been longing for!

      (setopt yank-pop-change-selection t)
      (setopt delete-active-region 'kill)
      (setopt kill-do-not-save-duplicates nil)
      (setopt kill-whole-line nil)
      (setopt save-interprogram-paste-before-kill (expt 2 16))
      

    • Undo
      

      The older undo step which exceeds undo-limit in byte is eliminated at garbage collection. The oldest undo step, if undo info exceeds undo-strong-limit in total, is removed instantaneously. No more new undo step than undo-outer-limit could not be registered.

      (setopt undo-limit 320000
              undo-strong-limit 480000
              undo-outer-limit 48000000
              undo-no-redo nil)
      

    • Matching
      
      • Isearch
        

        (use-package isearch
          :custom
          (isearch-allow-motion t)
          (isearch-lazy-count t)
          (isearch-lax-whitespace t)
          (isearch-regexp-lax-whitespace t)
          (search-whitespace-regexp ".*")
          :config
          (bind-keys :map isearch-mode-map
                     ("C-j" . isearch-exit)))
        

      • Bookmark
        

        (use-package bookmark
          :bind ("C-x 5 B" . bookmark-jump-other-frame)
          :custom
          (bookmark-save-flag 1)
          (bookmark-menu-confirm-deletion t)
          (bookmark-watch-bookmark-file 'silent))
        

    • Paragraph
      

      (setopt bidi-paragraph-direction 'left-to-right)
      

  • Multimedia
    
    • Image
      

      This post teaches me how to enable converting external formats (i.e. webp) to internal ones.

      (use-package image
        :custom
        (image-use-external-converter t))
      

  • Programming
    
    • Tools
      
      • Xref
        

        (use-package xref
          :custom
          (xref-show-definitions-function 'xref-show-definitions-completing-read)
          (xref-search-program (cond
                                ((or (executable-find "ripgrep")
                                     (executable-find "rg"))
                                 'ripgrep)
                                ((executable-find "ugrep")
                                 'ugrep)
                                (t
                                 'grep))))
        

      • Ediff
        
        • Ediff Window
          

          (use-package ediff
            :commands ediff-files
            :custom
            (ediff-window-setup-function 'ediff-setup-windows-plain)
            (ediff-split-window-function 'split-window-horizontally))
          

  • Development
    
    • Internal
      
      • Storage Allocation
        

        If GC time at Emacs init is problematic, checking gcs-done and gc-elapsed may help you. Increasing gc-cons-* variables would minimize Emacs init time, but this also cause each GC time which may noticeable as freeze. This presentation advise to increase gc-cons-threshold to 20-80Mb if you have Emacs with slow startup, and to increase consult–gc-percentage to 0.2-1.0 if you have slow and frequent GC.

        (setq gc-cons-threshold (* 30 gc-cons-threshold)
              gc-cons-percentage 0.3)
        

    • Lisp
      
      • Shortdoc
        

        (use-package shortdoc
          :bind ("<help> D" . shortdoc-display-group))
        

      • Re Builder
        

        (use-package re-builder
          :custom
          (reb-re-syntax 'string))
        

      • Comp
        

        For native compilation feature introduced at Emacs 28.1.

        (use-package comp
          :init
          ;; enable asynchronous native compilation
          (setq native-comp-jit-compilation t)
          :custom
          (native-comp-async-report-warnings-errors 'silent)
          (native-comp-async-query-on-exit t)
          (native-comp-verbose 1))
        

      • Eldoc
        

        (use-package eldoc
          :preface
          (setq eldoc-documentation-strategy 'eldoc-documentation-compose-eagerly)
          :custom
          (eldoc-echo-area-prefer-doc-buffer 'maybe)
          :config
          (eldoc-add-command-completions "paredit-"))
        

    • Debug
      

      (setopt message-log-max 10000)
      

    • Development
      
      • Extensions
        
        • Transient
          

          "emacs-transient"
          

          (use-package transient
            :custom
            (transient-save-history t)
            ;; :config
            ;; (mapc (lambda (face) (set-face-attribute face nil
            ;;                                      :font "fontset-code"
            ;;                                      :height (my/normalized-font-size 420)))
            ;;       (seq-filter (lambda (face) (string-match-p "transient-.+" (symbol-name face)))
            ;;                   (face-list)))
            )
          

  • Help
    

    (setopt help-enable-variable-value-editing t)
    (setopt help-enable-symbol-autoload t)
    (setopt describe-bindings-outline t)
    

  • Data
    
    • Save Place
      

      File-related tweaks including Customizing Saving of Files.

      (require 'saveplace)
      
      (setopt save-place-abbreviate-file-names t
              save-place-version-control t
              save-place-mode t)
      

    • Compression
      

      • Jka Compr (auto compression mode)

        (setopt auto-compression-mode t)
        

    • Tar
      

      (require 'tar-mode)
      

    • Archive
      

      (require 'archive-mode)
      

  • Editing Basics
    

    (setopt set-mark-command-repeat-pop t
            mark-ring-max 64
            next-line-add-newlines nil
            cycle-spacing-actions '(delete-all-space just-one-space restore))
    
    ;; delsel
    ;;; inserting Replacing the string in the region with the typed character
    ;;; instead of simply inserting it.
    (setopt delete-selection-mode t)
    
    ;; files
    (setopt mode-require-final-newline 'visit-save
            enable-remote-dir-locals t)
    (setq delete-auto-save-files t)
    

  • External
    
    • EasyPG
      

      (use-package epg
        :defer t
        :custom
        (epg-pinentry-mode 'loopback))
      

      • Epa (EasyPG Assistant)
        

        EasyPG Assistant (epa) enables users to manage their GnuPG keys and exert encryption/sign with them.

        (use-package epa
          :bind (("C-x : l" . epa-list-keys)
                 ("C-x : L" . epa-list-secret-keys)
                 :map dired-mode-map
                 (": E" . my/epa-dired-do-encrypt-armor))
          :preface
          (defun my/epa-dired-do-encrypt-armor ()
            "Encrypt mark files in ASCII armored format."
            (interactive)
            (let ((epa-armor t))
              (epa-dired-do-encrypt)))
          :config
          (setq epa-file-encrypt-to "<<email>>"))
        

    • Server
      

      (use-package server
        :hook (after-init . (lambda () (unless (server-running-p)
                                     (server-start))))
        :custom
        (server-name "server-<<hash-string(seed="server", len=6)>>")
        (server-client-instructions t))
      

    • Processes
      
      • Proced
        

        This blog post explains how to use proced, process monitoring package for emacs.

        (use-package proced
          :commands proced
          :custom
          (proced-auto-update-flag t)
          (proced-auto-update-interval 3)
          (proced-show-remote-processes t)
          (proced-show-remote-processes t))
        

      • Shell
        

        (setopt shell-command-prompt-show-cwd t)
        

    • Browse Url
      

      (use-package browse-url
        :init
        (keymap-global-set "C-c C-o" #'browse-url-at-point)
        :custom
        (browse-url-new-window-flag t)
        (browse-url-browser-function 'eww-browse-url)
        (browse-url-secondary-browser-function 'browse-url-firefox))
      

      • Webjump
        

        (use-package webjump
          :commands webjump
          :custom
          (webjump-use-internal-browser t))
        

    • locate
      

      (use-package locate
        :commands locate
        :custom
        (locate-command "plocate")
        (locate-make-command-line #'my/plocate-make-command-line)
        (locate-fcodes-file (expand-file-name "<<plocate-db()>>"))
        (locate-update-path (expand-file-name "~/")))
      
      (defun my/plocate-make-command-line (search-string)
        (list locate-command "-d" (expand-file-name "<<plocate-db()>>") "--ignore-case" "--existing" "--regexp" search-string))
      

    • With Editor
      

      (use-package with-editor
        :custom
        (shell-command-with-editor-mode t))
      

  • Applications
    
    • Mail
      
      • Smtpmail
        

        (use-package smtpmail
          :after mu4e
          :init
          (setq smtpmail-default-smtp-server "<<smtp-host>>")
          :custom
          (smtpmail-smtp-service 465)
          (smtpmail-smtp-user user-mail-address)
          (smtpmail-stream-type 'ssl)
          (smtpmail-mail-address user-mail-address))
        

      • Message
        
        • Message Mail
          

          (use-package message
            :after (dired mu4e)
            :custom
            (message-send-mail-function 'smtpmail-send-it))
          

      • Mime Security
        

        (use-package mm-encode
          :after mu4e
          :custom
          (mm-sign-option nil))
        
        (use-package mml-sec
          :after (mu4e dired)
          :custom
          (mml-secure-openpgp-sign-with-sender t)
          (mml-default-sign-method 'pgpmime))
        

    • Ispell/FlySpell
      

      (use-package ispell
        :if (executable-find "aspell")
        :custom
        (ispell-program-name "aspell")
        :config
        ;; avoid checking for Japanese characters
        (add-to-list 'ispell-skip-region-alist '("[^\000-\377]+"))
        (setq-default ispell-extra-args '("--sug-mode=ultra"
                                          "--lang=en_US"))
        (let ((arg "--camel-case"))
          (and (string-match-p arg
                               (shell-command-to-string (concat ispell-program-name " --help")))
               (push arg ispell-extra-args))))
      
      (use-package flyspell
        :after ispell
        :hook ((text-mode . (lambda ()
                              (unless (derived-mode-p 'org-mode)
                                (flyspell-mode 1))))
               (prog-mode . flyspell-prog-mode))
        :preface (setq flyspell-mode-map nil)
        :bind (:map flyspell-mode-map
                    :prefix "C-$"
                    :prefix-map my/flyspell-mode-map
                    :prefix-docstring "Keymap for Flyspell"
                    ("n" . flyspell-goto-next-error)
                    ("C-$" . flyspell-auto-correct-word)
                    ("C-" . flyspell-auto-correct-previous-word)
                    ("$" . flyspell-correct-word-before-point))
        :custom
        (flyspell-issue-message-flag nil))
      

    • News
      
      • Gnus
        
        • Auth Source
          

          (use-package auth-source
            :custom
            (auth-source-gpg-encrypt-to `(,user-mail-address))
            :config
            (add-to-list 'auth-sources "~/.netrc.gpg"))
          
          (use-package auth-source-pass
            :config
            (auth-source-pass-enable))
          

    • Calc (The GNU Emacs Calculator)
      

      (use-package calc
        :bind ("<f7>" . calc)
        :commands (calc))
      

    • Calendar
      

      (use-package calendar
        :commands (calendar)
        :hook
        (calendar-today-visible . calendar-mark-today)
        :custom
        (calendar-left-margin 0)
        (calendar-right-margin 0)
        (calendar-intermonth-spacing 1)
        (calendar-mark-holidays-flag t)
        ;; Below is lat/lon for Japna used in sunrise-sunset command
        (calendar-latitude 36.2)
        (calendar-longitude 138.3)
        :custom-face
        (holiday ((t (:foreground "dark orange" :box t)))))
      

      • Midnight
        

        (use-package midnight
          :defer t
          :custom
          (midnight-mode t)
          (midnight-delay "4:00"))
        

      • Appt
        

        (use-package appt
          :custom
          (appt-message-warning-time 60)
          (appt-display-interval 5)
          :config
          (appt-activate 1)
          (with-eval-after-load 'org-agenda
            (org-agenda-to-appt)))
        

    • Package
      

      (use-package package
        :custom
        (package-native-compile t)
        (package-install-upgrade-built-in t)
        (package-quickstart t)
        :config
        (with-eval-after-load 'my-launch-app
          (keymap-set my/invoke-list-command-map (kbd "p")
                      #'list-packages)))
      

    • Eglot
      

      Eglot

      (use-package eglot
        :disabled t
        :hook ((sh-mode ruby-mode python-mode graphviz-dot-mode) . eglot-ensure)
        :custom
        (eglot-extend-to-xref t))
      

  • Text
    
    • View
      

      (use-package view
        :defer t)
      

  • Hypermedia
    
    • Dictionary
      

      dictd dict \
            dict-gcide dict-wn \
            dict-jargon dict-foldoc dict-vera \
            dict-freedict-eng-jpn dict-freedict-jpn-eng
      

      sudo systemctl start dictd
      

      (use-package dictionary
        :commands (dictionary-search dictionary-lookup-definition)
        :custom
        (dictionary-use-single-buffer t)
        (dictionary-server nil)
        :config
        (setq switch-to-buffer-obey-display-actions t)
        (add-to-list 'display-buffer-alist
                     '("^\\*Dictionary\\*"
                       display-buffer-in-tab)))
      

  • Communication
    
    • Net Utils
      

      (use-package net-utils
        :after my-launch-app
        :bind (:map my/launch-app-map
                    ("n d" . run-dig)
                    ("n i" . ifconfig)
                    ("n w" . iwconfig)
                    ("n p" . ping)))
      

• Input Methods
  
  • ddskk
    

    "emacs-ddskk"
    

    ("https://github.com/skk-dev/ddskk/releases.atom" soft_update)
    

    (defvar skk-dir (expand-file-name "skk" "<<share-dir()>>"))
    
    (use-package skk
      :defer t
      :init
      (setopt default-input-method "japanese-skk")
      (defface skk-candidate `((t . (:font "fontset-default"
                                           :height ,(my/normalized-font-size 860))))
        "Default face for ddskk candidates."
        :group 'skk-dcomp)
      (setq skk-get-jisyo-directory "<<skk-jisyo-path()>>")
      :custom
      (skk-user-directory (no-littering-expand-etc-file-name "ddskk"))
      (skk-init-file (expand-file-name "ddskk-init.el" skk-user-directory))
      (skk-byte-compile-init-file t)
      ;; cursor color
      (skk-use-color-cursor t)
      (skk-cursor-hiragana-color "orange")
      (skk-cursor-katakana-color "OrangeRed3")
      (skk-cursor-latin-color "DodgerBlue3")
      (skk-cursor-jisx0201-color "purple3")
      ;; mode line string
      (skk-latin-mode-string "A")
      (skk-hiragana-mode-string "あ")
      (skk-katakana-mode-string "ア")
      (skk-jisx0201-mode-string "ｱ")
      (skk-jisx0208-latin-mode-string "Ａ")
      ;; AZIK
      (skk-use-azik t)
      (skk-azik-keyboard-type 'us101)
      ;; conversion
      (skk-egg-like-newline t)
      (skk-henkan-strict-okuri-precedence t)
      (skk-check-okurigana-on-touroku t)
      ;; annotation
      (skk-show-annotation t)
      (skk-annotation-delay 0.3)
      ;; how candidates behave
      (skk-show-candidates-always-pop-to-buffer t)
      (skk-henkan-number-to-display-candidates 10)
      (skk-show-candidates-nth-henkan-char 3)
      (skk-henkan-show-candidates-keys
       '(?1 ?2 ?3 ?4 ?5 ?6 ?7 ?8 ?9 ?0))
      ;; set face for candidates list
      (skk-treat-candidate-appearance-function
       (lambda (candidate listing-p)
         (cond
          ((string-match ";" candidate)
           (put-text-property 0 (match-beginning 0)
                              'face 'skk-candidate
                              candidate)
           (put-text-property (match-beginning 0)
                              (length candidate) 'face 'shadow candidate))
          (t
           (put-text-property 0 (length candidate)
                              'face 'skk-candidate
                              candidate)))
         candidate))
      ;; bind C-q for hankaku-kana input mode
      (skk-use-jisx0201-input-method t)
      ;; dynamic conversion
      (skk-dcomp-activate nil)
      (skk-dcomp-multiple-activate nil)
      ;; config file
      (skk-record-file (expand-file-name "record" skk-dir))
      (skk-emacs-id-file (expand-file-name "emacs-id" skk-dir))
      ;; jisyo
      (skk-share-private-jisyo t)
      (skk-compare-jisyo-size-when-saving t)
      (skk-save-jisyo-instantly t)
      ;; jisyo file/directory
      (skk-jisyo `(,(no-littering-expand-var-file-name "ddskk/jisyo.txt") . utf-8))
      (skk-backup-jisyo (expand-file-name "jisyo.bak" skk-dir))
      (skk-large-jisyo (expand-file-name "SKK-JISYO.L" skk-get-jisyo-directory))
      (skk-itaiji-jisyo (expand-file-name "SKK-JISYO.itaiji" skk-get-jisyo-directory))
      (skk-extra-jisyo-file-list
       (seq-remove (lambda (dic)
                     (seq-some (lambda (suffix)
                                 (string-suffix-p (symbol-name suffix) dic))
                               '(L itaiji tar)))
                   (append (file-expand-wildcards (expand-file-name "SKK-JISYO.*" skk-get-jisyo-directory))
                           (file-expand-wildcards (expand-file-name "open-jisyo/SKK-JISYO.*" skk-dir)))))
      ;; jisyo server
      ;; (skk-server-host "localhost")
      ;; (skk-server-portnum 1178)
      ;; (skk-server-inhibit-startup-server t)
      ;; study
      (skk-study-file (expand-file-name "study" skk-dir))
      (skk-study-backup-file (expand-file-name "study.bak" skk-dir))
      :config
      ;; ward off activating skk-auto-fill-mode inadvertently
      (bind-keys ("C-x j" . skk-mode)))
    

    • ddskk init file

    ;; -*- mode:emacs-lisp; -*-
    (setq skk-rom-kana-rule-list
          (append skk-rom-kana-rule-list
                  '(("!" nil skk-purge-from-jisyo)
                    ("xka" nil ("ヵ" . "ヵ"))
                    ("xke" nil ("ヶ" . "ヶ"))
                    ("n" nil nil)
                    ("nn" nil ("ナノ" . "なの"))
                    ("nm" nil ("ノミ" . "のみ"))
                    ("ks" nil ("コソ" . "こそ"))
                    ("kna" nil ("カナ" . "かな"))
                    ("kno" nil ("コノ" . "この"))
                    ("ym" nil ("ヤマ" . "やま"))
                    ("yk" nil ("ユキ" . "ゆき"))
                    ("tga" nil ("タガ" . "たが"))
                    ("vj" nil ("ヴン" . "ぶん"))
                    ("hm" nil ("ハマ" . "はま"))
                    ;; followings are for preventing from changing to zenkaku eisu mode by pressing 'L'
                    ("bL" nil ("ボン" . "ぼん"))
                    ("byL" nil ("ビョン" . "びょん"))
                    ("cL" nil ("チョン" . "ちょん"))
                    ("dL" nil ("ドン" . "どん"))
                    ("fL" nil ("フォン" . "ふぉん"))
                    ("gL" nil ("ゴン" . "ごん"))
                    ("gyL" nil ("ギョン" . "ぎょん"))
                    ("hL" nil ("ホン" . "ほん"))
                    ("hgL" nil ("ヒョン" . "ひょん"))
                    ("hyL" nil ("ヒョン" . "ひょん"))
                    ("jL" nil ("ジョン" . "じょん"))
                    ("kL" nil ("コン" . "こん"))
                    ("kgL" nil ("キョン" . "きょん"))
                    ("kyL" nil ("キョン" . "きょん"))
                    ("mL" nil ("モン" . "もん"))
                    ("mgL" nil ("ミョン" . "みょん"))
                    ("myL" nil ("ミョン" . "みょん"))
                    ("nL" nil ("ノン" . "のん"))
                    ("ngL" nil ("ニョン" . "にょん"))
                    ("nyL" nil ("ニョン" . "にょん"))
                    ("pL" nil ("ポン" . "ぽん"))
                    ("pgL" nil ("ピョン" . "ぴょん"))
                    ("pyL" nil ("ピョン" . "ぴょん"))
                    ("rL" nil ("ロン" . "ろん"))
                    ("ryL" nil ("リョン" . "りょん"))
                    ("sL" nil ("ソン" . "そん"))
                    ("syL" nil ("ション" . "しょん"))
                    ("tL" nil ("トン" . "とん"))
                    ("tyL" nil ("チョン" . "ちょん"))
                    ("vL" nil ("ヴォン" . "う゛ぉん"))
                    ("wL" nil ("ウォン" . "うぉん"))
                    ("xL" nil ("ション" . "しょん"))
                    ("xxL" nil ("→" . "→"))
                    ("yL" nil ("ヨン" . "よん"))
                    ("zL" nil ("ゾン" . "ぞん"))
                    ("zyL" nil ("ジョン" . "じょん")))))
    
    (add-hook 'skk-azik-load-hook
              (lambda ()
                (dolist (key '("kA" "kE" "tU" "wA"))
                  (setq skk-rom-kana-rule-list
                        (skk-del-alist key skk-rom-kana-rule-list)))))
    

• Dired
  

  (use-package dired
    :bind (:map global-map
                ("C-x d" . dired-jump)
                :map dired-mode-map
                ("C-j" . dired-find-file)
                ("^" . dired-up-directory)
                ("(" . dired-hide-details-mode)
                (")" . dired-hide-details-mode)
                ("E" . dired-create-empty-file)
                ("Y" . dired-do-relsymlink)
                ("e" . wdired-change-to-wdired-mode)
                ("RET" . dired-open-file)
                ("C-c C-o" . dired-open-file)
                ("C-c C-s" . my/dired-share))
    :hook (dired-mode . dired-hide-details-mode)
    :custom
    (dired-kill-when-opening-new-dired-buffer t)
    (dired-do-revert-buffer t)
    (dired-auto-revert-buffer t)
    (dired-copy-dereference t)
    (dired-recursive-copies 'always)
    (dired-recursive-deletes 'top)
    (dired-listing-switches "-ahgG --time-style=long-iso --group-directories-first")
    (dired-dwim-target 'dired-dwim-target-next)
    (dired-hide-details-hide-information-lines t)
    (dired-hide-details-hide-symlink-targets nil)
    (dired-compress-file-default-suffix ".zst")
    (dired-compress-directory-default-suffix ".7z")
    (dired-isearch-filenames t)
    (dired-open-use-nohup t)
    (dired-open-query-before-exit nil)
    (completion-ignored-extensions nil)
    :config
    (with-eval-after-load 'open-file
      (setq dired-guess-shell-alist-user
            `((,(regexp-opt (append my/open-file-media-extensions
                                    my/open-file-compressed-media-extensions)
                            "\\.\\(")
               "mpv")
              (,(regexp-quote ".kdenlive") "kdenlive")
              (,(regexp-quote ".xcf") "gimp"))))
    (advice-add #'dired-do-delete :around #'my/advice-dired-control-deletion)
    (advice-add #'dired-do-flagged-delete :around #'my/advice-dired-control-deletion)
    (put 'dired-find-alternate-file 'disabled nil))
  
  (use-package dired-x
    :after dired
    :config
    (lambda-key dired-mode-map "."
                (lambda ()
                  "Toggle hiding dotfiles whose name starts with '.'"
                  (interactive)
                  (let ((dired-omit-files (rx (seq string-start
                                                   (or "." ".."
                                                       (seq "." (+? graph)))
                                                   string-end))))
                    (call-interactively #'dired-omit-mode)))))
  
  (use-package dired-aux
    :after dired
    :custom
    ;; Renaming files in Dired reflects their name in VCSs
    (dired-vc-rename-file t)
    :config
    (setq dired-compress-files-alist
          (append dired-compress-files-alist
                  '(("\\.tar\\.7z\\'" . "tar cf - %i | 7z a -si %o")
                    ("\\.7z\\'" . "7z a %o %i"))))
    (add-to-list 'dired-compress-file-suffixes
                 '("\\.tar\\.7z\\'" "" "7z x -so %i | tar xf -"))
    ;; submit "M-s f" to consult-find
    (bind-keys :map dired-mode-map
               ("M-s f" . nil)))
  
  (defun my/advice-dired-control-deletion (oldfun &rest r)
    "Enable file deleting functions to control deleting procedure
  whether files are going to be in trash box."
    (let ((delete-by-moving-to-trash
           (if (equal current-prefix-arg '(4))
               nil t)))
      (apply oldfun (cdr r))))
  
  (defun my/dired-share ()
    "Share file with remote device via KDE Connect."
    (interactive)
    (let ((files (dired-get-marked-files nil nil)))
      (mapc (lambda (file)
              (shell-command
               (mapconcat 'identity
                          (list "kdeconnect-cli" "-d" "a30587ededf4c2d2"
                                "--share" (shell-quote-argument
                                           file)) " ")))
            files)))
  

  • dired-rsync
    

    "emacs-dired-rsync"
    

    (use-package dired-rsync
      :after dired
      :bind (:map dired-mode-map
                  ("C-c C-r" . dired-rsync))
      :custom
      (dired-rsync-options "-auz --info=progress2"))
    

  • dired-single   ARCHIVE
    
  • dired-hacks
    

    "emacs-dired-hacks"
    

    (require 'dired-open)
    
    (use-package dired-subtree
      :after dired
      :bind (:map dired-mode-map
                  ("TAB" . dired-subtree-cycle)))
    
    (use-package dired-narrow
      :after dired
      :bind
      (:map dired-mode-map
            ("z" . dired-narrow))
      (:map dired-narrow-map
            ("C-j" . exit-minibuffer)))
    

  • dired-hide-dotfiles   ARCHIVE
    
  • find-dired
    

    (use-package find-dired
      :bind (:prefix "M-s d"
                     :prefix-map my/find-dired-map
                     :prefix-docstring "Keymap for FInd Dired"
                     ("f" . find-dired)
                     ("F" . find-lisp-find-dired)
                     ("g" . find-grep-dired)
                     ("n" . find-name-dired)
                     ("d" . find-lisp-find-dired-subdirectories)
                     ("!" . find-dired-with-command))
      :custom
      (find-grep-options "-n -H --no-heading -q")
      (find-ls-option '("-print0 | xargs -0 ls -ldN" . "-ldN")))
    

• EWW
  

  (funcall (if (= full-path 0) #'identity #'expand-file-name)
           (file-name-concat no-littering-var-directory "eww/org"))
  

  d <<eww-org-dir(full-path=1)>> - - - 3d
  

  (with-eval-after-load 'shr
    (setopt shr-width 10000)
    (setopt shr-use-fonts nil)
    (setopt shr-image-animate t)
    (setopt shr-use-colors nil)
    (setopt shr-max-image-proportion 0.4)
    ;; never use cookies
    (setopt shr-cookie-policy nil))
  

  The EWW bookmark functionality is an original implementation, separate from the emacs bookmark facility. Although adoption of the facility has been considered, a possible solution to count EWW bookmarks in the source of consult-buffer is showcased at here.

  (use-package eww
    :commands eww
    :after my-launch-app
    :bind (:map my/invoke-list-command-map
                ("B" . eww-list-bookmarks)
                :map my/launch-app-map
                ("W" . eww-switch-to-buffer))
    :custom
    ;; set enough large column number to prevent from inserting line break
    (eww-header-line-format nil)
    (eww-browse-url-new-window-is-tab nil)
    (eww-auto-rename-buffer 'title)
    (eww-buffer-name-length 20)
    :config
    (bind-keys :map eww-mode-map
               ("C" . eww-set-character-encoding)
               ("C-j" . eww-follow-link)
               ("T" . eww-goto-title-heading)
               ("L" . my/eww-goto-heading)
               :map eww-bookmark-mode-map
               ("C-j" . eww-bookmark-browse))
    (with-eval-after-load 'consult
      (defvar consult--source-eww
        (list :name     "Eww"
              :narrow   ?w
              :action   (lambda (bm)
                          (eww-browse-url (get-text-property 0 'url bm)))
              :items    (lambda ()
                          (eww-read-bookmarks)
                          (mapcar (lambda (bm)
                                    (propertize
                                     (format "%s (%s)"
                                             (plist-get bm :url)
                                             (plist-get bm :title))
                                     'url (plist-get bm :url)))
                                  eww-bookmarks))))
      (add-to-list 'consult-buffer-sources 'consult--source-eww 'append)))
  
  (defun eww-headings-dom ()
    "Return heading list as a dom from xml."
    (let ((source (plist-get eww-data :source))
          (dom nil))
      (with-temp-buffer
        (let ((source-file (make-temp-file "source-"))
              (coding-system-for-write 'utf-8-unix))
          (insert source)
          (write-region (point-min) (point-max) source-file nil)
          (erase-buffer)
          (call-process "extract_headings" source-file t)
          (delete-file source-file)
          (libxml-parse-xml-region (point-min) (point-max))))))
  
  (defun eww-goto-title-heading ()
    "Set point to a line which contaings the possible heading."
    (interactive)
    (when-let* ((headings-dom (eww-headings-dom))
                (possible-heading (cl-reduce (lambda (node-a node-b)
                                               (if (not (bound-and-true-p node-a))
                                                   (if (not (bound-and-true-p node-b))
                                                       nil
                                                     node-b)
                                                 (if (>= (string-to-number (dom-attr node-a 'proximity))
                                                         (string-to-number (dom-attr node-b 'proximity)))
                                                     node-a node-b)))
                                             (dom-children headings-dom)
                                             :initial-value nil))
                (possible-text (dom-text possible-heading))
                (match-pos (or (re-search-forward (format "^*?[[:blank:]]*%s[[:blank:]]*$" (regexp-quote possible-text)) nil t 1)
                               (re-search-backward (format "^*?[[:blank:]]*%s[[:blank:]]*$" (regexp-quote possible-text)) nil t 1))))
      (beginning-of-line)
      (recenter-top-bottom 0)))
  
  (defun my/eww-goto-heading ()
    "Go to selected heading line."
    (interactive)
    (setq lexical-binding t)
    (when-let* ((headings-root (eww-headings-dom))
                (cur-buf (current-buffer))
                (heading (completing-read
                          "Heading : "
                          (mapcar (lambda (heading-node)
                                    (when-let* ((heading (dom-text heading-node))
                                                (tag (symbol-name (dom-tag heading-node)))
                                                (match-pos (string-match "h\\([1-6]\\{1\\}\\)" tag))
                                                (indent (- (string-to-number (match-string 1 tag)) 1)))
                                      (format "%s%s"
                                              (apply 'concat (make-list indent "  "))
                                              heading)))
                                  (dom-children headings-root))))
                (match (string-match "\\(?:  \\)*\\(.*\\)" heading))
                (heading (match-string 1 heading))
                (match-pos (or (re-search-forward (build-regex heading) nil t 1)
                               (re-search-backward (build-regex heading) nil t 1))))
      (with-current-buffer cur-buf
        (switch-to-buffer cur-buf)
        (beginning-of-line)
        (recenter-top-bottom 0))))
  
  (defmacro build-regex (str)
    "Return a regexp representation for `STR'."
    `(format "^[[:blank:]SVG Image]*%s[[:blank:]]*$"
             ,str))
  

  • extract_headings
    

    import sys
    import lxml.html as html
    from lxml import etree
    import difflib
    
    if len(sys.argv) == 1:
        INPUT_STR = sys.stdin.read()
        ROOT = html.fromstring(INPUT_STR).getroottree()
    else:
        sys.exit(1)
    
    OUT_ROOT = etree.Element("headings")
    
    # extract title text
    title = ''
    title_text_arr = ROOT.xpath('//title[1]//text()')
    if len(title_text_arr):
        title = title_text_arr[0]
        OUT_ROOT.set("title", title.strip())
    
    htag_text_arr = ROOT.xpath('//*[self::h1 or self::h2 or self::h3 or self::h4 or self::h5 or self::h6]')
    for i in range(len(htag_text_arr)):
        text = ''
        texts = htag_text_arr[i].xpath('.//text()')
        if len(texts) == 1:
            text = texts[0].strip()
        elif len(texts) > 1:
            text = ''.join(map(str.strip, texts))
        else:
            continue
        proximity = difflib.SequenceMatcher(None, title, text).ratio()
        heading = etree.Element(htag_text_arr[i].tag)
        heading.text = text
        heading.set('proximity', str(proximity))
        OUT_ROOT.append(heading)
    
    out_root_str = etree.tostring(OUT_ROOT, encoding='utf-8', method='xml', pretty_print=True)
    if type(out_root_str) is bytes:
        out_root_str = out_root_str.decode()
        print(out_root_str)
    

• Info
  

  (use-package info
    :custom
    (Info-use-header-line nil)
    :config
    (bind-keys :map Info-mode-map ("a" . info-apropos)))
  

• Magit
  

  Magit is git front end for emacs which is outstandingly powerful.

  "emacs-magit"
  

  (use-package magit
    :commands (magit magit-status magit-dispatch)
    :config
    (bind-keys :map magit-status-mode-map
               ("/" . magit-file-checkout)
               (";" . magit-list-repositories)))
  

  • Magit Essentials
    

    (use-package magit-repos
      :after magit
      :custom
      (magit-repository-directories '(("~/git" . 1))))
    

  • Magit Revision
    

    (use-package magit-diff
      :after magit
      :custom
      ;; %GG denotes signature key info botained by --show-signature option in git log command
      (magit-revision-headers-format
       (mapconcat #'identity
                  (list "Author:     %aN <%aE>"
                        "AuthorDate: %ad"
                        "Commit:     %cN <%cE>"
                        "CommitDate: %cd"
                        "%GG")
                  "\n")))
    

  • Magit Log
    

    (use-package magit-log
      :after magit
      :custom
      (magit-log-show-refname-after-summary t))
    

  • Magit Wip
    

    The following excerpt is important when trying finer control for git-wip-*-mode.

    • magit-wip-mode

      For historic reasons this mode is implemented on top of four other 'magit-wip-*' modes, which can also be used individually, if you want finer control over when the wip refs are updated; but that is discouraged.

    (use-package magit-wip
      :after magit
      :custom
      (magit-wip-merge-branch t)
      :config
      (magit-wip-after-save-mode 1))
    

  • forge
    

    "emacs-forge"
    

    (use-package forge
      :after magit)
    

• Mu4e
  

  You might need to issue 'mu init' command before initial usage or after upgrading. The command would presumably looks like the following:

  mu init --maildir=~/data/share/mail --muhome=~/data/share/mu --my-address=jim@example.com --my-address=bob@example.com
  

  "mu"
  

  (use-package mu4e
    :commands (mu4e)
    :hook (emacs-startup . (lambda () (mu4e t)))
    :delight
    (mu4e-main-mode    " MU")
    (mu4e-headers-mode " MU")
    (mu4e-view-mode    " MU")
    (mu4e-compose-mode " MU")
    :custom
    (mail-user-agent 'mu4e-user-agent)
    (mu4e-hide-index-messages t)
    (mu4e-context-policy 'pick-first)
    (mu4e-compose-context-policy 'ask)
    (mu4e-update-interval 300)
    (mu4e-split-view 'single-window)
    (mu4e-headers-date-format "%y%m%d")
    (mu4e-headers-time-format " %R")
    (mu4e-headers-fields
     '((:human-date . 6)
       (:flags      . 3)
       (:from       . 16)
       (:subject)))
    (mu4e-search-results-limit 2000)
    (mu4e-headers-advance-after-mark t)
    (mu4e-change-filenames-when-moving t)
    (mu4e-view-show-images t)
    (mu4e-html2text-command (lambda (msg)
                              (plist-put msg :body-html
                                         (with-temp-buffer
                                           (insert (or (mu4e-message-field msg :body-html) ""))
                                           (shell-command-on-region (point-min) (point-max) "nkf -w -Lu" (current-buffer) t)
                                           (or (buffer-string) "")))
                              (mu4e-shr2text msg)))
    :config
    (bind-keys :map mu4e-headers-mode-map
               ("C-j" . mu4e-headers-view-message)
               :map mu4e-view-mode-map
               ("C-j" . push-button)
               ("C-c C-a" . mu4e-view-attachment-action)
               :map mu4e-compose-mode-map
               ("C-x C-o" . org-mu4e-compose-org-mode))
    (add-to-list 'mu4e-view-actions
                 '("external browser" . mu4e-action-view-in-browser) t)
    (add-to-list 'mu4e-view-actions
                 '("XWidget View" . mu4e-action-view-with-xwidget) t)
    (when (fboundp 'imagemagick-register-types)
      (imagemagick-register-types)))
  

  • mu4e-alert   ARCHIVE
    
  • additional tweaks
    

    • file attachment in dired (source)

      gnus-dired-attach (C-c RET C-a)
      

      (use-package gnus-dired
        :after mu4e-compose
        :hook
        (dired-mode . turn-on-gnus-dired-mode)
        :custom
        (gnus-dired-mail-mode 'mu4e-user-agent))
      

    • use contact info from org-contacts

      (with-eval-after-load 'mu4e
        (add-to-list 'mu4e-headers-actions
                     '("Contact to add" . mu4e-action-add-org-contact) t)
        (add-to-list 'mu4e-view-actions
                     '("Contact to add" . mu4e-action-add-org-contact) t)
        (with-eval-after-load 'org-contacts
          (setq mu4e-org-contacts-file (car org-contacts-files))))
      

• Elfeed
  

  Elfeed is a powerful RSS feed reader with tag capability that is one of core software in my input workflow.

  "emacs-elfeed"
  

  ("https://github.com/skeeto/elfeed/releases.atom" soft_update)
  

  (use-package elfeed
    :delight
    (elfeed-show-mode   " EF")
    (elfeed-search-mode " EF")
    :commands elfeed
    :init
    (defface elfeed-search-unchecked-title-face
      nil
      "Face used in search mode for unchecked entry titles."
      :group 'elfeed)
    (defface elfeed-search-checked-title-face
      nil
      "Face used in search mode for checked entry titles."
      :group 'elfeed)
    :custom-face
    (elfeed-search-title-face ((t (:foreground "#4D4D4D"))))
    (elfeed-search-unchecked-title-face ((t (:foreground "cornflowerblue"))))
    (elfeed-search-checked-title-face ((t (:foreground "darkblue"))))
    :custom
    (elfeed-use-curl t)
    (elfeed-search-date-format '("%Y%m%d" 8 :left))
    (elfeed-search-title-min-width 100)
    (elfeed-search-title-max-width 120)
    (elfeed-search-trailing-width 160)
    (elfeed-sort-order 'ascending)
    (elfeed-enclosure-default-dir "~/Downloads/")
    (elfeed-save-multiple-enclosures-without-asking t)
    :config
    (defalias 'elfeed-search-tag-all-unchecked
      (elfeed-expose #'elfeed-search-tag-all 'unchecked)
      "Add the `unchecked' tag to all selected entries.")
    (defalias 'elfeed-search-untag-all-unchecked
      (elfeed-expose #'elfeed-search-untag-all 'unchecked)
      "Remove the `unchecked' tag from all selected entries.")
    (defalias 'elfeed-search-tag-all-checked
      (elfeed-expose #'elfeed-search-tag-all 'checked)
      "Add the `checked' tag to all selected entries.")
    (defalias 'elfeed-search-untag-all-checked
      (elfeed-expose #'elfeed-search-untag-all 'checked)
      "Remove the `checked' tag from all selected entries.")
    (bind-keys :map elfeed-search-mode-map
               ("C-j" . elfeed-search-show-entry)
               ("M-RET" . elfeed-search-open-url)
               ("C-c C-o" . elfeed-search-open-url)
               ("f" . scroll-up-line)
               ("e" . scroll-down-line)
               ("q" . elfeed-kill-buffer)
               ("Q" . quit-window)
               ("x" . elfeed-search-update--force)
               ("c" . (lambda () (interactive)
                        (elfeed-search-untag-all-unread)
                        (unless (use-region-p) (forward-line -1))
                        (elfeed-search-tag-all-unchecked)))
               ("C" . elfeed-search-untag-all-unchecked)
               ("r" . (lambda () (interactive)
                        (elfeed-search-untag-all-unread)
                        (unless (use-region-p) (forward-line -1))
                        (elfeed-search-untag-all-unchecked)
                        (unless (use-region-p) (forward-line -1))
                        (elfeed-search-tag-all-checked)
                        (unless (use-region-p) (forward-line -1))
                        (elfeed-search-tag-all (intern (format-time-string "%Y%m%d")))))
               ("R" . elfeed-search-untag-all-checked)
               ("d" . elfeed-search-untag-all-unread)
               ("Y" . elfeed-search-download-media)
               ("_" . elfeed-search-show-media-duration))
    (add-to-list 'elfeed-search-face-alist '(unchecked elfeed-search-unchecked-title-face))
    (add-to-list 'elfeed-search-face-alist '(checked elfeed-search-checked-title-face)))
  
  (defun elfeed-search-open-url ()
    "Visit the current entry in your browser using 'eww-browse-url'."
    (interactive)
    (elfeed-search-untag-all-unchecked)
    (unless (use-region-p) (forward-line -1))
    (elfeed-search-tag-all-checked)
    (unless (use-region-p) (forward-line -1))
    (elfeed-search-tag-all (intern (format-time-string "%Y%m%d")))
    (unless (use-region-p) (forward-line -1))
    (elfeed-search-browse-url))
  
  (defun elfeed-search-download-media ()
    "Downlaod video file."
    (interactive)
    (let ((entries (elfeed-search-selected)))
      (cl-loop for entry in entries
               when (or (caar (elfeed-entry-enclosures entry))
                        (elfeed-entry-link entry))
               do (let ((title (elfeed-entry-title entry)))
                    (yt-dlp-dispatch-dwim it title)
                    (dispatch-execute-macro)))
      (mapc #'elfeed-search-update-entry entries)
      (unless (or elfeed-search-remain-on-entry (use-region-p))
        (forward-line))))
  
  (defun elfeed-search-show-media-duration ()
    "Show duration of media attached to current entry."
    (interactive)
    (let* ((entry (elfeed-search-selected :single))
           (url (or (caar (elfeed-entry-enclosures entry))
                    (elfeed-entry-link entry))))
      (let ((dispatch-dwim--default-method
             (lambda (comm) (princ
                         (string-trim
                          (shell-command-to-string comm))))))
        (yt-dlp-dispatch-dwim url nil t)
        (dispatch-execute-macro))))
  

  • elfeed-score
    

    "emacs-elfeed-score"
    

    (use-package elfeed-score
      :after elfeed
      :custom
      (elfeed-score-score-format '("%d " 3 :right))
      (elfeed-score-rule-stats-file
       (no-littering-expand-var-file-name "elfeed/score/stats.el"))
      :config
      (elfeed-score-enable)
      (setq elfeed-search-sort-function #'my/elfeed-score-sort-descending)
      (setq elfeed-search-print-entry-function #'my/elfeed-score-search-print-entry)
      (keymap-set elfeed-search-mode-map "=" #'elfeed-score-map)
      :preface
      (defun my/elfeed-score-sort-descending (a b)
        "Return non-nil if A should sort after B."
        (let ((a-score (elfeed-score-scoring-get-score-from-entry a))
              (b-score (elfeed-score-scoring-get-score-from-entry b)))
          (if (< a-score b-score)
              t
            (let ((a-date (elfeed-entry-date a))
                  (b-date (elfeed-entry-date b)))
              (and (eq a-score b-score) (< a-date b-date))))))
      (defun my/elfeed-score-search-print-entry (entry)
        "Print ENTRY to the buffer with my style."
        (let* ((date (elfeed-search-format-date (elfeed-entry-date entry)))
               (title (or (elfeed-meta entry :title) (elfeed-entry-title entry) ""))
               (title-faces (elfeed-search--faces (elfeed-entry-tags entry)))
               (feed (elfeed-entry-feed entry))
               (feed-title
                (when feed
                  (or (elfeed-meta feed :title) (elfeed-feed-title feed))))
               (tags (mapcar #'symbol-name (elfeed-entry-tags entry)))
               (tags-str (mapconcat
                          (lambda (s) (propertize s 'face 'elfeed-search-tag-face))
                          tags ","))
               (title-width (- (window-width) 10 elfeed-search-trailing-width))
               (title-column (elfeed-format-column
                              title (elfeed-clamp
                                     elfeed-search-title-min-width
                                     title-width
                                     elfeed-search-title-max-width)
                              :left))
               (score
                (elfeed-score-format-score
                 (elfeed-score-scoring-get-score-from-entry entry))))
          (insert score)
          (when feed-title
            (insert (propertize (elfeed-format-column feed-title 6 :left)
                                'face 'elfeed-search-feed-face) " "))
          (insert (propertize title-column 'face title-faces 'kbd-help title) " ")
          (insert (propertize date 'face 'elfeed-search-date-face) " ")
          (when tags
            (insert "(" tags-str ")")))))
    

  • elfeed-org
    

    elfeed-org allow me to express feeds for elfeed in org file.

    "emacs-elfeed-org"
    

    (use-package elfeed-org
      :after (elfeed org)
      :init
      (with-eval-after-load 'denote
        (setq rmh-elfeed-org-files
              (list (denote-get-path-by-id "20230605T173315"))))
      :custom
      (rmh-elfeed-org-ignore-tag "ARCHIVE")
      (rmh-elfeed-org-auto-ignore-invalid-feeds nil)
      :config
      (elfeed-org))
    

    Packages managed by other than guix (i.e. straight.el or apt) are encouraged to register feed since updating information channel is desirable to exist.

    (advice-add #'rmh-elfeed-org-process
                :after #'my/elfeed-org-add-feeds)
    
    (defun my/elfeed-org-add-feeds (rmh-elfeed-org-files rmh-elfeed-org-tree-id)
      "Add feeds in addition to feeds in `rmh-elfeed-org-files'.
    
    This function needs to be invoked after `rmh-elfeed-org-process' which clear all feeds."
      (setf elfeed-feeds
            (append elfeed-feeds
                    '(;; s-exps for feeds will be inserted here
                      <<elfeed-feeds>>))))
    

• Terminal Emulators
  
  • shell
    

    (use-package shell
      :delight " SM"
      :commands (shell)
      :custom
      (shell-has-auto-cd t)
      :config
      (bind-keys :map shell-mode-map
                 ("C-j" . comint-send-input)))
    

  • term
    

    (use-package term
      :disabled t
      :delight
      (term-mode " TR")
      :config
      (bind-keys :map term-mode-map
                 ("C-j" . term-send-input)))
    

  • vterm
    

    "emacs-vterm"
    "emacs-multi-vterm"
    

    ("https://github.com/akermu/emacs-libvterm/releases.atom" soft_update)
    ("https://github.com/suonlight/multi-vterm/releases.atom" soft_update)
    

    # function/variable used in libvterm/emacs
    vterm_printf(){
      if [ -n "$TMUX" ]; then
        # Tell tmux to pass the escape sequences through
        # (Source: http://permalink.gmane.org/gmane.comp.terminal-emulators.tmux.user/1324)
        printf "\ePtmux;\e\e]%s\007\e\\" "$1"
      elif [ "${TERM%%-*}" = "screen" ]; then
        # GNU screen (screen, screen-256color, screen-256color-bce)
        printf "\eP\e]%s\007\e\\" "$1"
      else
        printf "\e]%s\e\\" "$1"
      fi
    }
    
    vterm_prompt_end(){
      vterm_printf "51;A$(whoami)@$(hostname):$(pwd)"
    }
    
    PROMPT_COMMAND='echo -ne "\033]0;${HOSTNAME}:${PWD}\007"'
    

    (use-package vterm
      :commands (vterm multi-vterm multi-vterm-next)
      :bind (:map vterm-mode-map
                  ("C-c M-n" . multi-vterm-next)
                  ("C-c M-p" . multi-vterm-prev))
      :delight " VT"
      :diminish ((vterm-copy-mode . "vc"))
      :custom
      (vterm-min-window-width 55)
      (vterm-buffer-name-string "vterm %s")
      :config
      (require 'multi-vterm)
      (bind-keys :map vterm-mode-map
                 ("C-h" . vterm-send-backspace)
                 ("M-h" . vterm-send-meta-backspace)
                 ("C-y" . vterm-yank)
                 ("M-y" . vterm-yank-pop)
                 ("M-l" . nil)
                 :map vterm-copy-mode-map
                 ("C-j" . vterm-copy-mode-done))
      (advice-add 'consult-yank-from-kill-ring :around #'advice/vterm-yank-pop))
    
    (defun my/multi-vterm (&optional arg)
      "Switch between existing vterm buffers.
    
    Spawn a new vterm buffer if there's no available vterm buffer.
    If command prefix ARG is simgle `C-u', spawn a vterm buffer forcibly regardless of condition."
      (interactive "P")
      (if (equal arg '(4))
          (multi-vterm)
        (multi-vterm-next)))
    
    (defun advice/vterm-yank-pop (orig-fun &rest args)
      (if (eq major-mode 'vterm-mode)
          (let ((inhibit-read-only t)
                (yank-undo-function (lambda (_start _end) (vterm-undo))))
            (cl-letf (((symbol-function 'insert-for-yank)
                       (lambda (str) (vterm-send-string str t))))
              (apply orig-fun args)))
        (apply orig-fun args)))
    

  • Eshell
    

    (use-package eshell
      :after my-launch-app
      :commands (eshell)
      :bind (:map my/launch-app-map
                  ("e" . eshell))
      :hook
      (eshell-kill . eshell-command-alert)
      :custom
      (eshell-prompt-function
       #'(lambda ()
           (format "[%s]\n%s"
                   (eshell/basename (eshell/pwd))
                   (if (= (user-uid) 0) "# " "$ "))))
      (eshell-prompt-regexp "[#$] ")
      (eshell-visual-subcommands '(("git" "log" "diff" "show")))
      (eshell-scroll-to-bottom-on-input 'this)
      (eshell-history-size 2500)
      (eshell-hist-ignoredups t)
      :config
      (require 'em-prompt)
      (bind-keys :map eshell-prompt-mode-map
                 ("C-h" . delete-backward-char)
                 ("M-h" . backward-kill-word))
      (setq eshell-path-env (getenv "PATH"))
      (with-eval-after-load 'consult
        ;; narrow down eshell history using vertico
        (when (require 'em-hist nil t)
          (bind-keys :map eshell-hist-mode-map
                     ("C-M-n" . consult-history)))))
    
    (defun eshell-command-alert (process status)
      "Send `alert' with severity based on STATUS when PROCESS finished."
      (let* ((cmd (process-command process))
             (buffer (process-buffer process))
             (msg (format "%s: %s" (mapconcat 'identity cmd " ")  status)))
        (if (string-prefix-p "finished" status)
            (alert msg :buffer buffer :severity  'normal)
          (alert msg :buffer buffer :severity 'urgent))))
    

    • Eshell Aliases
      

      Aliases for Eshell are shared with Bash.

      alias v view-file $1
      alias vo view-file-other-window $1
      alias <<print-aliases(lang="plain")>>
      

• Org Mode
  

  "emacs-org"
  "tree-sitter-org"
  

  ("https://updates.orgmode.org/feed/releases" soft_update)
  

  Basic settings for built-in Org features. Similar to this section, all entries obey customize group hierarchy for Org mode.

  (use-package org
    :mode ("\\.org$" . org-mode)
    :init
    (defvar my/org-initialized nil
      "Indicator showing whether any org file had opened.")
    (defvar my/org-mode-init-hook nil
      "One-off hook run when first org file open.")
    (setq org-directory "~/org")
    :hook
    (org-mode . (lambda ()
                  (unless my/org-initialized
                    (setq my/org-initialized t)
                    (run-hooks 'my/org-mode-init-hook)
                    (provide 'my/org-mode-init)))))
  
  (defvar my/org-todo-keyword--urgent "UG"
    "TODO keyword acronym standing for 'UrGent'")
  (put 'my/org-todo-keyword--urgent 'char ?u)
  (defvar my/org-todo-keyword--todo "TD"
    "TODO keyword acronym standing for 'ToDo'")
  (put 'my/org-todo-keyword--todo 'char ?t)
  (defvar my/org-todo-keyword--next "NX"
    "TODO keyword acronym standing for 'NeXt")
  (put 'my/org-todo-keyword--next 'char ?n)
  (defvar my/org-todo-keyword--in-action "IP"
    "TODO keyword acronym standing for 'In Progress")
  (put 'my/org-todo-keyword--in-action 'char ?i)
  (defvar my/org-todo-keyword--someday "SD"
    "TODO keyword acronym standing for 'Someday'")
  (put 'my/org-todo-keyword--someday 'char ?s)
  (defvar my/org-done-keyword--done "DN"
    "DONE keyword acronym standing for 'DoNe'")
  (put 'my/org-done-keyword--done 'char ?d)
  (defvar my/org-done-keyword--cancel "CX"
    "DONE keyword acronym standing for 'Cancel'")
  (put 'my/org-done-keyword--cancel 'char ?x)
  (defvar my/org-done-keyword--pending "GU"
    "DONE keyword acronym standing for 'Given-Up'")
  (put 'my/org-done-keyword--pending 'char ?g)
  
  (defvar my/org-project-tag "project" "A tag for projects")
  

  • org mode keymap
    

    (with-eval-after-load 'org
      (let ((map org-mode-map))
        (keymap-set map "C-j" #'org-return)
        (keymap-set map "C-M-j" #'org-return-indent)
        (keymap-set map "M-j" #'org-meta-return)
        (keymap-set map "C-S-p" #'org-previous-item)
        (keymap-set map "C-S-n" #'org-next-item)
        (keymap-set map "C-S-u" #'org-up-element)
        (keymap-set map "C-S-d" #'org-down-element)
        (keymap-set map "C-<" #'org-previous-link)
        (keymap-set map "C->" #'org-next-link)
        (keymap-set map "C-c @" #'org-mark-element)
        (keymap-set map "C-c C-SPC" #'org-mark-subtree)
        (keymap-set map "C-c C-a" nil)
        (keymap-set map "C-," nil)
        (keymap-set map "M-h" nil)))
    

  • org core feature setup
    

    (with-eval-after-load "org-macs"
      (setopt org-sort-function 'org-sort-function-fallback))
    

    • Org Agenda
      

      (use-package org-agenda
        :after (org my-org-global-map)
        :bind (:map my/org-global-map
                    ("a" . org-agenda))
        :hook
        (org-agenda-mode . (lambda ()
                             ;; TODO: this can be rewritten with `display-buffer'
                             (delete-other-windows)
                             (org-agenda-to-appt t '((category "appt")))))
        :custom
        (org-agenda-files
         `(,(file-name-as-directory
             (file-name-concat org-directory "agenda"))))
        (org-agenda-inhibit-startup t)
        (org-agenda-use-tag-inheritance nil)
        :config
        (bind-keys :map org-agenda-mode-map
                   ("C-j" . org-agenda-switch-to)
                   ("M" . org-agenda-month-view)))
      
      (defun org-agenda-cmp-latest-clock-log (a b)
        "Compare two org entry A and B in terms of clock log.
      
      This function can be used as `org-agenda-cmp-user-defined' in `org-agenda-sorting-strategy'."
        (let* ((marker-a (get-text-property 1 'org-marker a))
               (time-a (org-get-latest-clock-log-time marker-a))
               (marker-b (get-text-property 1 'org-marker b))
               (time-b (org-get-latest-clock-log-time marker-b)))
          (if (time-less-p time-a time-b) -1 +1)))
      
      (defun org-clock-sum-all ()
        "Sum the times for all agenda files."
        (interactive)
        (save-excursion
          (mapc (lambda (file)
                  (with-current-buffer (or (org-find-base-buffer-visiting file)
                                           (find-file-noselect file))
                    (org-clock-sum)
                    (org-clock-sum-today)))
                (org-agenda-files))))
      
      (defun org-get-latest-clock-log-time (pom)
        "Get the latest clock log time stamp in org entry at POM as a time object.
      
      If entry at POM has no clock log time stamp, this function returns 0."
        (org-with-point-at pom
          (save-excursion
            (setq end-of-subtree (org-end-of-subtree))
            (setq latest-time 0)
            (org-back-to-heading t)
            (org-show-all)
            (while (re-search-forward org-drawer-regexp end-of-subtree t)
              (when (string= (match-string 1) (org-clock-drawer-name))
                (while (progn
                         (forward-line 1)
                         (when (org-match-line (concat "^[ \t]*" org-clock-string "[ \t]*" org-tsr-regexp-both))
                           (setq match-ts
                                 (if (match-string 3)
                                     (match-string 3) (match-string 1)))
                           (when (time-less-p latest-time
                                              (apply 'encode-time (parse-time-string match-ts)))
                             (setq latest-time (apply 'encode-time (parse-time-string match-ts)))))
                         (not (org-match-line org-clock-drawer-end-re))))))))
        latest-time)
      

      • Org Agenda Custom Commands
        

        (with-eval-after-load 'org-agenda
          (setopt org-stuck-projects `(,(concat "+" my/org-project-tag)
                                       (,my/org-todo-keyword--todo ,my/org-todo-keyword--next ,my/org-todo-keyword--in-action)
                                       nil ""))
          (setq org-agenda-custom-commands
                `(("a" "Week-agenda"
                   agenda ""
                   ((org-agenda-skip-function #'my/org-agenda-skip-someday-task)))
                  ("l" "Log entries in a week"
                   agenda ""
                   ((org-agenda-skip-function #'my/org-agenda-skip-someday-task)
                    (org-agenda-span (if (equal current-prefix-arg '(4))
                                         'day 'week))
                    (org-agenda-start-with-log-mode t)
                    (org-agenda-start-with-clockreport-mode t)
                    (org-agenda-include-inactive-timestamps nil)
                    (org-agenda-include-diary t)
                    (org-agenda-sorting-strategy
                     '(time-up
                       deadline-up
                       todo-state-up
                       priority-down))))
                  ("L" "Log entry timeline on today with default org-agenda-prefix-format"
                   agenda ""
                   ((org-agenda-skip-function #'my/org-agenda-skip-someday-task)
                    (org-agenda-prefix-format (eval (car (get 'org-agenda-prefix-format 'standard-value))))
                    (org-agenda-span (if (equal current-prefix-arg '(4))
                                         'day 'week))
                    (org-agenda-start-with-clockreport-mode t)
                    (org-agenda-start-with-log-mode t)
                    (org-agenda-include-inactive-timestamps nil)
                    (org-agenda-include-diary t)
                    (org-agenda-sorting-strategy
                     '(time-up
                       deadline-up
                       todo-state-up
                       priority-down))))
                  ;; KEEP IN MIND
                  ;; invoking `org-clock-sum-all' is required before showing effort table
                  ("e" . "Effort table")
                  ("ei" "today"
                   ((org-ql-search-block `(or (todo ,my/org-todo-keyword--urgent)
                                              (todo ,my/org-todo-keyword--in-action)
                                              (and (clocked :on today)
                                                   (or (todo) (done))
                                                   (not (habit))
                                                   (not (tags "web"))))
                                         ((org-ql-block-header "Today's task"))))
                   ((org-agenda-overriding-header "Today's Task")
                    (org-overriding-columns-format "%26ITEM(Task) %Effort(Effort){:} %CLOCKSUM_T(Today){:} %CLOCKSUM(Total)")
                    (org-agenda-view-columns-initially t)
                    (org-agenda-sorting-strategy '(todo-state-up priority-down deadline-up))))
                  ("eg" "this week"
                   ((org-ql-search-block `(or (todo ,my/org-todo-keyword--urgent)
                                              (todo ,my/org-todo-keyword--next)
                                              (todo ,my/org-todo-keyword--in-action))
                                         ((org-ql-block-header "This Week's task"))))
                   ((org-agenda-overriding-header "This Week's Task")
                    (org-overriding-columns-format "%26ITEM(Task) %Effort(Effort){:} %CLOCKSUM_T(Today){:} %CLOCKSUM(Total)")
                    (org-agenda-view-columns-initially t)
                    (org-agenda-sorting-strategy '(todo-state-up priority-down deadline-up))))
                  ("ed" "done task"
                   ((org-ql-search-block `(or (todo ,my/org-done-keyword--done)
                                              (todo ,my/org-done-keyword--cancel)
                                              (todo ,my/org-done-keyword--pending))
                                         ((org-ql-block-header "Done task"))))
                   ((org-agenda-overriding-header "Done Task")
                    (org-overriding-columns-format "%26ITEM(Task) %Effort(Effort){:} %CLOCKSUM(Total){:}")
                    (org-agenda-view-columns-initially t)
                    (org-agenda-sorting-strategy '(todo-state-up priority-down deadline-up))))
                  ("i" "Today's agenda"
                   ((todo "Today's agenda"
                          ((org-agenda-sorting-strategy '(priority-up))))
                    (org-ql-search-block `(or (todo ,my/org-todo-keyword--urgent)
                                              (todo ,my/org-todo-keyword--in-action))
                                         ((org-ql-block-header "Today's task")))
                    (org-ql-search-block `(and (planning :on today)
                                               (not (todo ,my/org-todo-keyword--in-action
                                                          ,my/org-done-keyword--done
                                                          ,my/org-done-keyword--cancel
                                                          ,my/org-done-keyword--pending))
                                               (not (tags "web"))
                                               (not (habit))
                                               (not (todo ,my/org-todo-keyword--someday)))
                                         ((org-ql-block-header "Scheduled/Deadlined on today")))
                    (org-ql-search-block `(and (habit)
                                               (or (todo ,my/org-todo-keyword--todo)
                                                   (todo ,my/org-todo-keyword--next))
                                               (scheduled :to today)
                                               (not (tags "bad_habit"))
                                               (not (tags-inherited "ARCHIVE")))
                                         ((org-ql-block-header "Habits to take")))
                    (org-ql-search-block `(and (ts-active :on today)
                                               (not (or (todo ,my/org-todo-keyword--in-action)
                                                        (habit) (done)))
                                               (not (todo ,my/org-todo-keyword--someday)))
                                         ((org-ql-block-header "Today's common event")))
                    (org-ql-search-block '(and (done)
                                               (closed :on today))
                                         ((org-ql-block-header "Completed tasks on today")))
                    (org-ql-search-block '(and (habit)
                                               (last-repeat 0))
                                         ((org-ql-block-header "Completed habits on today"))))
                   ((org-agenda-sorting-strategy
                     '(todo-state-up priority-down deadline-up))))
                  ("n" "This Week's agenda"
                   ((org-ql-search-block `(heading ,(format-time-string "%G-W%V"))
                                         ((org-agenda-files `(,(file-name-concat org-directory "archive" (format-time-string "archive_%Y.org"))))
                                          (org-ql-block-header "This week in datetree archive")))
                    (org-ql-search-block `(or (todo ,my/org-todo-keyword--next))
                                         ((org-ql-block-header "This week's tasks")))
                    (org-ql-search-block `(or (todo ,my/org-todo-keyword--urgent)
                                              (todo ,my/org-todo-keyword--in-action))
                                         ((org-ql-block-header "Today's tasks")))
                    (org-ql-search-block `(and (planning :from 0 :to 6)
                                               (not (todo ,my/org-todo-keyword--in-action
                                                          ,my/org-done-keyword--done
                                                          ,my/org-done-keyword--cancel
                                                          ,my/org-done-keyword--pending))
                                               (not (tags "web"))
                                               (not (todo ,my/org-todo-keyword--someday))
                                               (not (habit)))
                                         ((org-ql-block-header "Scheduled/Deadlined this week")))
                    (org-ql-search-block `(and (and (ts-active :from 0 :to 6)
                                                    (not (deadline))
                                                    (not (scheduled))
                                                    (not (closed)))
                                               (not (or (todo ,my/org-todo-keyword--next
                                                              ,my/org-todo-keyword--in-action)
                                                        (done))))
                                         ((org-ql-block-header "This week's common event"))))
                   ((org-agenda-sorting-strategy
                     '(todo-state-up priority-down deadline-up))))
                  ("t" "All tasks"
                   ((org-ql-search-block `(todo ,my/org-todo-keyword--urgent)
                                         ((org-ql-block-header "Urgent task")))
                    (org-ql-search-block `(todo ,my/org-todo-keyword--in-action)
                                         ((org-ql-block-header "Today's task")))
                    (org-ql-search-block `(todo ,my/org-todo-keyword--next)
                                         ((org-ql-block-header "This week's task")))
                    (org-ql-search-block `(and (todo ,my/org-todo-keyword--todo)
                                               (not (habit)))
                                         ((org-ql-block-header "Remaining task")))))
                  ("d" "Done tasks"
                   ((org-ql-search-block `(and (or (done)
                                                   (and (todo ,my/org-todo-keyword--someday)
                                                        (not (olp "Someday Tasks"))))
                                               (not (tags "project")))
                                         ((org-ql-block-header "Done/Canceled/Pending task")))))
                  ("p" "Projects" tags ,(concat "+" my/org-project-tag))
                  ("h" "Habits in consistency graph"
                   agenda ""
                   ((org-agenda-span 'day)
                    (org-agenda-use-time-grid nil)
                    (org-agenda-prefix-format '((agenda . "")))
                    (org-habit-show-all-today t)
                    (org-agenda-sorting-strategy '(scheduled-up))
                    ;; display habits only
                    (org-agenda-skip-function
                     (lambda ()
                       (and (save-excursion
                              (not (org-is-habit-p)))
                            (progn (outline-next-heading) (point)))))))
                  ("H" "show all habits"
                   ((org-ql-search-block '(habit)
                                         ((org-ql-block-header "All Habits"))))
                   ((org-agenda-sorting-strategy '(scheduled-up)))))))
        

      • Org Agenda Daily/Weekly
        

        (with-eval-after-load 'org-agenda
          (setopt org-agenda-start-on-weekday 1)
          (setopt org-agenda-skip-deadline-if-done t)
          (setopt org-agenda-include-diary t)
          (setopt org-agenda-dim-blocked-tasks nil))
        

      • Org Agenda Line Format
        

        (with-eval-after-load 'org-agenda
          (setq org-agenda-prefix-format '((agenda   . "%?-12t% s")
                                           (timeline . "  %s")
                                           (todo     . " ")
                                           (tags     . " ")
                                           (search   . " "))))
        

    • Org Capture
      

      (use-package org-capture
        :after (org my-org-global-map)
        :bind (:map my/org-global-map
                    ("c" . org-capture))
        :hook
        (org-capture-mode . delete-other-windows)
        :custom
        (org-reverse-note-order nil)
        (org-capture-bookmark nil)
        (org-capture-templates
         `(("e" "Entry"
            entry (id "58e12e3e-da50-4089-9d22-565986637121")
            ,(concat "* [heading]\n%a\n"
                     "%(and (length> \"%i\" 0)
      (format \"#+begin_\%1$s\n\%2$s#+end_%1$s\n\"
      \"text\"
      (replace-regexp-in-string \"^*\" \",*\" \"%i\")))"))
           ("t" "Task"
            entry (id "58e12e3e-da50-4089-9d22-565986637121")
            ,(format "* %s %%?\n"
                     my/org-todo-keyword--todo))
           ("p" "Project"
            entry (id "58e12e3e-da50-4089-9d22-565986637121")
            "* %? [/] :project:\n"
            :jump-to-captured t)
           ("M" "Append memo to clocking task"
            item (clock)
            "- %i%?"))))
      

    • Org Startup
      

      (setopt org-startup-folded 'fold
              org-startup-truncated t
              org-startup-with-inline-images t
              org-cycle-hide-drawer-startup t)
      
      ;; allow _{}/^{} format for sub/super script
      (setopt org-use-sub-superscripts '{})
      

    • Org TODO
      

      (setopt org-enforce-todo-dependencies t)
      (setopt org-todo-keywords
              `((sequence ,(format "%s(%c)" my/org-todo-keyword--todo
                                   (get 'my/org-todo-keyword--todo 'char))
                          ,(format "%s(%c)" my/org-todo-keyword--urgent
                                   (get 'my/org-todo-keyword--urgent 'char))
                          ,(format "%s(%c)" my/org-todo-keyword--next
                                   (get 'my/org-todo-keyword--next 'char))
                          ,(format "%s(%c)" my/org-todo-keyword--in-action
                                   (get 'my/org-todo-keyword--in-action 'char))
                          ,(format "%s(%c!/!)" my/org-todo-keyword--someday
                                   (get 'my/org-todo-keyword--someday 'char))
                          "|"
                          ,(format "%s(%c!/@)" my/org-done-keyword--done
                                   (get 'my/org-done-keyword--done 'char))
                          ,(format "%s(%c!/@)" my/org-done-keyword--cancel
                                   (get 'my/org-done-keyword--cancel 'char))
                          ,(format "%s(%c!/@)" my/org-done-keyword--pending
                                   (get 'my/org-done-keyword--pending 'char)))))
      (setopt org-todo-keyword-faces
              `((,my/org-todo-keyword--urgent    . "red1")
                (,my/org-todo-keyword--todo      . "DeepPink1")
                (,my/org-todo-keyword--next      . "green1")
                (,my/org-todo-keyword--in-action . "DodgerBlue1")
                (,my/org-todo-keyword--someday   . "SpringGreen")
                (,my/org-done-keyword--done      . "gray30")
                (,my/org-done-keyword--cancel    . "dark gray")
                (,my/org-done-keyword--pending   . "sea green")))
      (setopt org-log-into-drawer t
              org-log-states-order-reversed t
              org-log-note-clock-out nil
              org-log-done 'time
              org-log-refile 'time
              org-log-reschedule nil
              org-log-redeadline 'time
              org-closed-keep-when-no-todo nil)
      

    • Org Structure
      

      (use-package org-indent
        :after org
        :bind (:map org-mode-map
                    ("C-c C-M-i" . org-indent-mode))
        :hook (org-mode . org-indent-mode)
        :custom
        (org-startup-indented t)
        (org-bookmark-names-plist nil)
        (org-insert-heading-respect-content t)
        (org-M-RET-may-split-line '((default . nil))))
      
      (use-package org-keys
        :after org
        :custom
        (org-use-speed-commands
         (lambda () (and (looking-at org-outline-regexp) (looking-back "^\**"))))
        :config
        (cl-labels ((os-set (key command)
                      (assoc-delete-all key org-speed-commands)
                      (add-to-list 'org-speed-commands
                                   (cons key command)
                                   t)))
          (add-to-list 'org-speed-commands '("Additional") t)
          (os-set "P" #'org-set-property)
          (os-set "C" #'org-clone-subtree-with-time-shift)
          (os-set "s" #'org-schedule)
          (os-set "d" #'org-deadline)
          (os-set "N" #'org-toggle-narrow-to-subtree)
          (os-set "$" #'org-archive-subtree)
          (os-set "'" #'ignore)))
      

      • Org Edit Structure
        

        (use-package org-src
          :after org
          :hook (org-src-mode . (lambda ()
                                  (setq-local auto-save-visited-mode nil)
                                  (setq-local buffer-save-without-query t)
                                  (when (eq major-mode 'text-mode)
                                    (visual-line-mode 1))))
          :custom
          (org-special-ctrl-a/e t)
          (org-src-window-setup 'current-window)
          (org-edit-src-content-indentation 0)
          (org-edit-src-turn-on-auto-save nil)
          (org-edit-src-auto-save-idle-delay 30)
          (org-edit-src-persistent-message nil)
          (org-src-ask-before-returning-to-edit-buffer nil)
          (org-special-ctrl-k t)
          (org-ctrl-k-protect-subtree t)
          (org-src-lang-modes
           (mapc (lambda (override-src-lang)
                   (add-to-list 'org-src-lang-modes override-src-lang))
                 '(("bash"   . bash-ts)
                   ("C"      . c)
                   ("ruby"   . ruby)
                   ("python" . python-ts)
                   ("java"   . java)
                   ("rust"   . rust)
                   ("lua"    . lua)
                   ("css"    . css-ts)
                   ("json"   . json-ts)
                   ("dot"    . graphviz-dot)
                   ("yaml"   . yaml-ts))))
          :config
          (mapc (lambda (temp-cons)
                  (if-let ((place (assoc (car temp-cons) org-structure-template-alist)))
                      (setf (cdr (assoc (car temp-cons) org-structure-template-alist)) (cdr temp-cons))
                    (add-to-list 'org-structure-template-alist temp-cons t)))
                '(("sh" . "src shell")
                  ("tx" . "src text")
                  ("el" . "src emacs-lisp")
                  ("py" . "src python")))
          (advice-add #'org-edit-src-save
                      :before
                      (lambda (&rest _)
                        (delete-trailing-whitespace))))
        

      • Org Plain lists
        

        (setopt org-list-demote-modify-bullet
                '(("-" . "+") ("+" . "-") ("*" . "-")
                  ("1." . "1)") ("1)" . "1.") ("*" . "1."))
                org-cycle-include-plain-lists 'integrate
                org-list-use-circular-motion t
                org-list-allow-alphabetical t)
        

      • Org Archive
        

        (use-package org-archive
          :defer t
          :custom
          (org-archive-default-command 'org-toggle-archive-tag))
        
        (setopt org-cycle-open-archived-trees t)
        

      • Org Inline Tasks
        

        (use-package org-inlinetask
          :commands (org-inlinetask-insert-task
                     org-inlinetask-promote
                     org-inlinetask-demote)
          :custom
          (org-inlinetask-default-state my/org-todo-keyword--todo)
          (org-inlinetask-min-level 10))
        

    • Org Tags
      

      (with-eval-after-load 'org
        (setopt org-use-tag-inheritance org-archive-tag
                org-tags-column -57
                org-tags-sort-function #'org-string-collate-greaterp))
      

    • Org Properties
      

      (setopt org-use-property-inheritance "TIMELIMIT.*"
              org-highest-priority ?A
              org-lowest-priority ?Z
              org-default-priority ?E
              org-global-properties
              '(("Effort_ALL". "0 0:10 0:20 0:30 1:00 1:30 2:00 3:00 4:00 6:00 8:00")))
      

    • Org Refile
      

      (use-package org-refile
        :after (org denote)
        :commands (org-refile)
        :custom
        (org-refile-targets
         `((org-agenda-files :tag . ,my/org-project-tag)
           (org-agenda-files :tag . "refile")
           (,(cl-remove-if-not (lambda (f)
                                 (member "refile"
                                         (denote-extract-keywords-from-path f)))
                               (denote-directory-files))
            :tag . "refile"))))
      

    • Org Time
      

      (setopt org-time-stamp-custom-formats
              '("<%m-%d %a>" . "<%H:%M>"))
      

      • Org Progress
        
        • Org Habit
          

          (use-package org-habit
            :after my/org-mode-init
            :custom
            (org-habit-graph-column 32)
            (org-habit-preceding-days 21)
            (org-habit-following-days 14)
            (org-habit-show-habits-only-for-today t))
          

        • Org Clock
          

          (use-package org-clock
            :after (org my-org-global-map)
            :custom
            (org-clock-into-drawer "CLOCK")
            (org-clock-out-when-done t)
            (org-clock-out-remove-zero-time-clocks t)
            (org-clock-persist t)
            (org-clock-persist-query-resume nil)
            (org-clock-string-limit 20)
            (org-clock-continuously t)
            (org-clock-ask-before-exiting nil)
            :config
            (org-clock-persistence-insinuate)
            (bind-keys :map my/org-global-map
                       ("j" . org-clock-goto)
                       ("I" . org-clock-in)
                       ("O" . org-clock-out)
                       ("X" . org-clock-cancel))
            (with-eval-after-load 'org-keys
              (dolist (elt '(("Clock Commands")
                             ("I" . org-clock-in)
                             ("O" . org-clock-out)
                             ("x" . nil)
                             ("X" . org-clock-cancel)))
                (add-to-list 'org-speed-commands elt t))))
          

    • Org Appearance
      

      (setopt org-hide-leading-stars t
              org-hide-emphasis-markers t
              org-pretty-entities t
              org-image-actual-width 100
              org-display-remote-inline-images 'cache)
      

    • Babel
      

      "plantuml"
      

      (use-package ob-core
        :after org
        :hook (org-babel-after-execute . org-display-inline-images)
        :init
        (cond
         ((string= system-type "gnu/linux")
          (setq org-plantuml-jar-path (expand-file-name "plantuml.jar" "~/.guix-profile/share/java")))
         ((string= system-type "darwin")
          (setq org-plantuml-jar-path "/usr/local/Cellar/plantuml/8041/plantuml.8041.jar")))
        :custom
        (org-babel-load-languages '((emacs-lisp . t)
                                    (lisp       . t)
                                    (C          . t)
                                    (java       . t)
                                    (R          . t)
                                    (shell      . t)
                                    (ruby       . t)
                                    (python     . t)
                                    (scheme     . t)
                                    (lua        . t)
                                    (ledger     . t)
                                    (gnuplot    . t)
                                    (dot        . t)
                                    (plantuml   . t)
                                    (lilypond   . t))))
      

      • Org Babel Tangle
        

        org-babel-tangle-default-file-mode does not seems to be in effect. I set org-babel-default-header-args:<lang> instead as a wordaround.

        (use-package ob-tangle
          :after ob-core
          :custom
          (org-babel-tangle-default-file-mode (identity #o444))
          (org-babel-tangle-use-relative-file-links nil))
        

    • Org ID
      

      (use-package org-id
        :after org
        :bind (:map org-mode-map
                    ("C-c i" . org-id-copy))
        :custom
        (org-id-track-globally t)
        (org-id-link-to-org-use-id 'create-if-interactive))
      

    • Org Crypt
      

      (use-package org-crypt
        :after my/org-mode-init
        :custom
        (org-crypt-key user-mail-address)
        :config
        (bind-keys :map org-mode-map
                   ("C-c M-: e" . org-encrypt-entry)
                   ("C-c M-: E" . org-encrypt-entries)
                   ("C-c M-: d" . org-decrypt-entry)
                   ("C-c M-: D" . org-decrypt-entries))
        (org-crypt-use-before-save-magic)
        (add-to-list 'org-tags-exclude-from-inheritance
                     org-crypt-tag-matcher))
      

    • Org Attach   ARCHIVE
      
    • Org Link
      

      (use-package ol
        :after (my-org-global-map my/org-mode-init)
        :bind (:map my/org-global-map
                    ("s" . org-store-link))
        :config
        (org-link-set-parameters "src" :follow #'org-babel-ref-resolve))
      

      • Org Follow Link
        

        (with-eval-after-load 'ol
          (setf (alist-get 'file org-link-frame-setup) 'find-file)
          (setopt org-link-elisp-confirm-function nil))
        
        (with-eval-after-load 'org-keys
          (setopt org-return-follows-link t))
        

    • Org Export
      
      • Org Export General
        

        (use-package ox
          :commands org-export-dispatch
          :custom
          (org-export-with-smart-quotes t)
          (org-export-with-emphasize t)
          (org-export-with-special-strings t)
          (org-export-with-fixed-width t)
          (org-export-with-timestamps t)
          (org-export-preserve-breaks nil)
          (org-export-with-sub-superscripts nil)
          (org-export-with-archived-trees 'headline)
          (org-export-with-author nil)
          (org-export-with-broken-links 'mark)
          (org-export-with-clocks nil)
          (org-export-with-creator nil)
          (org-export-with-drawers '(not "LOGBOOK"))
          (org-export-with-date nil)
          (org-export-with-entities t)
          (org-export-with-email nil)
          (org-export-with-footnotes t)
          (org-export-headline-levels 5)
          (org-export-with-inlinetasks t)
          (org-export-with-section-numbers nil)
          (org-export-with-planning nil)
          (org-export-with-priority nil)
          (org-export-with-properties nil)
          (org-export-with-statistics-cookies t)
          (org-export-with-tags nil)
          (org-export-with-tasks t)
          (org-export-with-latex t)
          (org-export-time-stamp-file nil)
          (org-export-with-title t)
          (org-export-with-toc nil)
          (org-export-with-todo-keywords nil)
          (org-export-with-tables t)
          (org-export-default-language "ja")
          (org-export-dispatch-use-expert-ui nil))
        

      • Org Export HTML
        

        (use-package ox-html
          :commands (org-html-export-as-html
                     org-html-export-to-html)
          :custom
          (org-html-preamble t)
          (org-html-postamble 'auto)
          (org-html-with-latex t)
          (org-html-container-element "div")
          (org-html-doctype "xhtml-strict"))
        

      • Org Export LaTeX
        

        (use-package ox-latex
          :commands (org-latex-export-as-latex
                     org-latex-export-to-latex
                     org-latex-export-to-pdf)
          :custom
          (org-latex-pdf-process '("platex %f"
                                   "platex %f"
                                   "bibtex %b"
                                   "platex %f"
                                   "platex %f"
                                   "dvipdfmx %b.dvi"))
          (org-latex-default-class "jsarticle")
          :config
          (add-to-list 'org-latex-classes
                       '("jsarticle"
                         "\\documentclass[dvipdfmx,12pt]{jsarticle}"
                         ("\\section{%s}" . "\\section*{%s}")
                         ("\\subsection{%s}" . "\\subsection*{%s}")
                         ("\\subsubsection{%s}" . "\\subsubsection*{%s}")
                         ("\\paragraph{%s}" . "\\paragraph*{%s}")
                         ("\\subparagraph{%s}" . "\\subparagraph*{%s}")))
          (add-to-list 'org-latex-classes
                       `("beamer"
                         "\\documentclass[presentation,dvipdfmx,18pt]{beamer}\n"
                         ("\\section{%s}" . "\\section*{%s}")
                         ("\\subsection{%s}" . "\\subsection*{%s}")
                         ("\\subsubsection{%s}" . "\\subsubsection*{%s}"))))
        

      • Org Export Texinfo
        

        (use-package ox-texinfo
          :after ox)
        

  • org external packages
    
    • org-ai   ARCHIVE
      
    • org-modern
      

      "emacs-org-modern"
      

      (use-package org-modern
        :after org
        :commands org-modern-mode)
      

    • org-transclusion
      

      "emacs-org-transclusion"
      

      (use-package org-transclusion
        :after org
        :bind (:map my/org-global-map
                    ("% a" . org-transclusion-add)
                    ("% A" . org-transclusion-add-all)
                    ("% n" . org-transclusion-make-from-link)
                    ("% t" . org-transclusion-activate)))
      

    • org-edna
      

      Org Edna allows to org entries to be blockers and action triggers, which is very intresting feature especially for managing successive set of tasks or any correlated tasks.

      "emacs-org-edna"
      

      (use-package org-edna
        :after org
        :custom
        (org-edna-mode t))
      

    • org-drill
      

      org-drill helps me to learn english words and phrases. This video introduces how I use org-drill.

      ("https://gitlab.com/phillord/org-drill/-/tags?format=atom" soft_update)
      

      (use-package org-drill
        :ensure t
        :after org
        :bind (:map org-mode-map
                    ("C-c D" . org-drill-tree))
        :custom
        (org-drill-spaced-repetition-algorithm 'sm5))
      

    • org-ql
      

      Org QL enables me to issue queries to search org entries with either SQL-like format or plain search strings.

      "emacs-org-ql"
      

      (use-package org-ql
        :after (org my-org-global-map)
        :bind (:map my/org-global-map
                    ("q q" . org-ql-search)
                    ("q v" . org-ql-view)
                    ("q f f" . org-ql-find)
                    ("q f F" . org-ql-find-in-org-directory)
                    ("q f a" . org-ql-find-in-agenda)
                    ("q f n" . my/org-ql-find-in-notes)
                    ("q /" . org-ql-sparse-tree))
        :preface
        (defun my/org-ql-find-in-notes ()
          "Call 'org-ql-find' on 'denote-all-files'."
          (interactive)
          (when (require 'denote nil t)
            (org-ql-find (denote-directory-files))))
        :custom
        (org-ql-search-directories-files-regexp "\\.org\\(?:\\.gpg\\)?$")
        (org-ql-search-directories-files-recursive t)
        :preface
        (defconst org-last-repeat-time-regexp
          "\\(?::LAST_REPEAT: *\\[\\([^]]+\\)]\\)"
          "Matches the LAST_REPEAT property together with a time stamp.")
        :config
        (require 'org-ql-search)
        (org-ql-defpred last-repeat (&key from to _on)
          "Return non-nil if current entry was repeated in given period.
      Without arguments, return non-nil if entry has LAST_REPEAT property."
          :normalizers ((`(,predicate-names ,(and num-days (pred numberp)))
                         (let* ((from-day (* -1 num-days))
                                (rest (list :from from-day)))
                           (org-ql--normalize-from-to-on
                             `(last-repeat :from ,from))))
                        (`(,predicate-names . ,rest)
                         (org-ql--normalize-from-to-on
                           `(last-repeat :from ,from :to ,to))))
          :preambles ((`(,predicate-names . ,_)
                       ;;  Predicate still needs testing.
                       (list :regexp org-last-repeat-time-regexp :query query)))
          :body
          (org-ql--predicate-ts :from from :to to :regexp org-last-repeat-time-regexp :match-group 1))
        (org-ql-defpred (tags-expanded expanded-tags tags-x xtags) (&rest tags)
          "Return non-nil if current heading has one or more of TAGS.
      If TAGS contains a group tag, all tags in the group is used to match.
      Both inherited and local tags is tested."
          :normalizers ((`(,predicate-names . ,tags)
                         `(tags-expanded ,@tags)))
          :body (apply #'org-ql--predicate-tags
                       (seq-uniq (--mapcat (org-tags-expand it t)
                                           tags))))
        (org-ql-defpred (category-inherited) (&rest categories)
          "Return non-nil if current heading has CATEGORY.
      Ancestors are looked up If current heading has no CATEGORY."
          :body (when-let ((category (or (org-get-category (point))
                                         (org-entry-get (point) "CATEGORY" t))))
                  (cl-typecase categories
                    (null t)
                    (otherwise (member category categories)))))
        (with-eval-after-load 'org-expiry
          (org-ql-defpred expired ()
            "Return non-nil if the entry is expired."
            :body (org-expiry-expired-p))))
      
      (use-package org-ql-view
        :after (org-ql org-agenda)
        :config
        (push `("Tasks on Web/Book"
                :buffers-files org-agenda-files
                :query (and (or (tags "web")
                                (tags "book"))
                            (not (or (done) (todo ,my/org-todo-keyword--someday))))
                :super-groups ((:auto-tags))
                :sort (priority date))
              org-ql-views)
        (push `("Habits"
                :buffers-files org-agenda-files
                :query (habit)
                :sort (todo scheduled))
              org-ql-views))
      

    • org-contacts
      

      "emacs-org-contacts"
      

      (use-package org-contacts
        :after org
        :commands (org-contacts-anniversaries)
        :config
        (when (require 'denote nil t)
          (setq org-contacts-files
                (list (denote-get-path-by-id "20230605T173003")))))
      

    • org-ml   ARCHIVE
      
    • org-roam   ARCHIVE
      
    • org-mime
      

      "emacs-org-mime"
      

      (use-package org-mime
        :after org
        :commands (org-mime-org-subtree-htmlize)
        :bind (:map org-mode-map
                    ("C-c M-M" . org-mime-org-subtree-htmlize))
        :custom
        (org-mime-use-property-inheritance t)
        (org-mime-export-ascii t))
      

    • org-web-tools
      

      "emacs-org-web-tools"
      

      (use-package org-web-tools
        :bind (("C-c C-;" . org-web-tools-insert-link-for-url)))
      

    • org-volume   ARCHIVE
      
    • org-clock-convenience
      

      ("https://github.com/dfeich/org-clock-convenience/releases.atom" soft_update)
      

      (use-package org-clock-convenience
        :ensure t
        :after org-agenda
        :bind
        (:map org-agenda-mode-map
              ("@"   . org-clock-convenience-fill-gap)
              ("C-@" . org-clock-convenience-fill-gap-both)))
      

    • org-reveal
      

      "emacs-org-reveal"
      

    • org-expiry
      

      "emacs-org-contrib"
      

      (use-package org-expiry
        :after my/org-mode-init
        :custom
        (org-expiry-inactive-timestamps t)
        (org-expiry-handler-function 'org-expiry-archive-subtree)
        :config
        (with-eval-after-load 'org-capture
          (add-hook 'org-capture-prepare-finalize-hook
                    #'org-expiry-insert-created))
        ;; Workaround for the malfunction of org-expiry-insinuate
        (unless (ignore-errors (org-expiry-insinuate))
          (add-hook 'org-insert-heading-hook 'org-expiry-insert-created)
          (add-hook 'org-after-todo-state-change-hook 'org-expiry-insert-created)
          (add-hook 'org-after-tags-change-hook 'org-expiry-insert-created)))
      

    • ob-async   ARCHIVE
      
    • ob-lilypond   ARCHIVE
      
    • ox-hugo
      

      "emacs-ox-hugo"
      

      (use-package ox-hugo
        :after ox)
      

    • org-web-track
      

      org-web-track-update-all-and-notify seems not to suit midnight-hook.

      (use-package org-web-track
        :ensure t
        ;; :load-path "~/data/home/.local/share/ghq/github.com/p-snow/org-web-track"
        :after (my/org-mode-init my-org-global-map)
        :bind (:map my/org-global-map
                    ("T q" . my/org-web-track-ql-view)
                    ("T c" . org-web-track-columns)
                    ("T a" . org-web-track-agenda-columns)
                    ("T n" . org-web-track-setup-entry)
                    ("T u" . org-web-track-update-entry)
                    ("T U" . org-web-track-update-files)
                    ("T r" . org-web-track-report))
        :preface
        (defun my/org-web-track-ql-view ()
          "Open Org Agenda view with tracking items which hold TRACK_URL property."
          (interactive)
          (require 'org-web-track nil t)
          (with-current-buffer (get-buffer-create "Org Web Track")
            (org-agenda-mode)
            (setq-local org-overriding-columns-format (org-web-track-columns-format)
                        org-agenda-view-columns-initially t)
            (setq org-columns-modify-value-for-display-function
                  'org-web-track-display-values)
            (when (require 'org-ql nil t)
              (org-ql-search org-web-track-files
                             `(property ,org-web-track-url)
                             :super-groups '((:tag "book") (:tag "food")
                                             (:tag "tool") (:tag "supply"))
                             :buffer (current-buffer)))))
        (defun my/org-web-track-update-all-and-notify ()
          "Update all web tracking items in `org-web-track-files'
       and send an email if any of them has changed its value."
          (let* ((org-log-into-drawer t)
                 (message-kill-buffer-on-exit t)
                 (mail-msg (mapconcat
                            (lambda (chg)
                              (org-with-point-at chg
                                (let ((org-trust-scanner-tags t))
                                  (format "%s\n\t%s\n"
                                          (substring-no-properties
                                           (org-get-heading t t t t))
                                          (org-web-track-current-changes nil "%p => %c" " | ")))))
                            (org-web-track-update-files))))
            (unless (string-blank-p mail-msg)
              ;; you need to set SMTP info to smtpmail-xxx variables
              (message-mail user-mail-address "Web Tracking Notification")
              (message-goto-body)
              (insert mail-msg)
              (message-send-and-exit))))
        (defvar my/usd-exchange-rates nil)
        (defun my/usd-excange-rate (currency)
          "Return the exchange rate between CURRENCY and the US dollar.
      
      This function also Update `my/usd-exchange-rates', a list of
      exchange rate against US dollar."
          (or my/usd-exchange-rates
              (request (concat "https://openexchangerates.org/api/latest.json?app_id="
                               (my/credential-info "openexchangerates.org" "app id"))
                :sync t
                :success
                (cl-function
                 (lambda (&key response &allow-other-keys)
                   (let ((content (request-response-data response)))
                     (setq my/usd-exchange-rates (json-parse-string content :object-type 'alist)))))
                :complete
                (cl-function
                 (lambda (&key data &allow-other-keys)
                   data))))
          (assoc-default currency
                         (assoc-default 'rates my/usd-exchange-rates)))
        (defun my/convert-currency (target-currency amount)
          "Convert AMOUNT into TARGET-CURRENCY."
          (let* ((currs '(("$" . USD) ("€" . EUR) ("£" . GBP) ("₹" . INR)
                          ("¥" . JPY) ("¥" . CNY) ("₩" . KRW) ("₽" . RUB)))
                 (curr-re (rx-to-string `(seq (group-n 1 (or ,@(mapcar 'car currs)))
                                              (group-n 2 (1+ digit))))))
            (when (string-match curr-re amount)
              (let ((amt-in-usd (string-to-number (match-string 2 amount)))
                    (to-usd-rate (my/usd-excange-rate
                                  (assoc-default (match-string 1 amount) currs)))
                    (from-usd-rate (my/usd-excange-rate target-currency)))
                (format "%s%.2f"
                        (car (rassq target-currency currs))
                        (/ (* amt-in-usd from-usd-rate) to-usd-rate))))))
        :custom
        (org-web-track-use-curl nil)
        (org-web-track-content-fetcher-alist
         `((,(regexp-quote "melpa.org/#/") .
            "fetch-dynamic-page.py %s")))
        (org-web-track-selectors-alist
         `((,(regexp-quote "melpa\.org/#/") .
            "htmlq --text dd | head -n 1 | cut -d ' ' -f 1")
           (,(regexp-quote "www.lenovo.com/jp/ja/p/laptops/thinkpad")
            (lambda (dom)
              (when-let ((price-node (car (dom-search dom (lambda (node) (string= "productpromotionprice"
                                                                              (dom-attr node 'name)))))))
                (assoc-default 'content (cadr price-node)))))
           (,(rx "www.amazon.co.jp" (+ anychar) "-ebook")
            "pup 'span[id=\"priceblock_ourprice\"],span[id=\"kindle-price\"],span[class=\"a-text-price\"],span[class=\"a-offscreen\"] json{}' \| jq -re '.[0].text'")
           (,(regexp-quote "www.amazon.co.jp/product-reviews")
            [.a-size-base.a-color-secondary] ; num of stars
            [.a-size-medium.a-color-base])  ; rating
           (,(regexp-quote "www.amazon.co.jp")
            [.a-price.aok-align-center > .a-offscreen]
            [div:availability span]         ; availability
            )
           (,(regexp-quote "www.yodobashi.com/product")
            [:js_scl_unitPrice])
           (,(regexp-quote "kakaku.com/item")
            [.priceTxt])
           (,(regexp-quote "store.steampowered.com")
            (lambda (dom)
              (when-let ((products (dom-search dom (lambda (node) (string-prefix-p "game_area_purchase_game"
                                                                                   (dom-attr node 'class))))))
                (seq-some (lambda (prod)
                            (let ((text (dom-text (or (dom-by-class prod "game_purchase_price")
                                                      (dom-by-class prod "discount_final_price")))))
                              (if (length= text 0) nil text)))
                          products))))
           (,(regexp-quote "www.googleapis.com/youtube/v3/channels")
            (lambda (json)
              (assoc-default 'subscriberCount
                             (assoc-default 'statistics (aref (cdr (assoc 'items json))
                                                              0)))))
           (,(regexp-quote "www.googleapis.com/youtube/v3/videos")
            (lambda (json)
              (when (require 'dash nil t)
                (let ((stat (->> json
                                 (assoc-default 'items)
                                 (mapcar #'identity)
                                 (nth 0)
                                 (assoc-default 'statistics))))
                  (list (assoc-default 'likeCount stat)
                        (assoc-default 'commentCount stat))))))
           (,(regexp-quote "openexchangerates.org/api/latest")
            (lambda (json)
              (format "%.3f"
                      (assoc-default 'JPY
                                     (assoc-default 'rates json)))))
           (,(regexp-quote "map.kaldi.co.jp/kaldi")
            "pup 'div[class=\"shop_bnr news\"] ul li text{}' | xargs echo -n")
           (,(regexp-quote "www.seijoishii.com")
            [.price > .total])
           ("localhost" identity)
           (,(regexp-quote "store.minisforum.jp/products")
            (lambda (dom)
              (when-let* ((prod-price (car (dom-by-class dom "product-info__price")))
                          (sale-price (car (dom-by-tag prod-price 'sale-price))))
                (dom-text sale-price))))
           (,(rx (seq "www.gmktec.com/" (or "products" "collections")))
            (lambda (dom)
              (when-let* ((price-w (car (dom-by-class dom "product-info__header_price-wrapper")))
                          (price (car (dom-by-class price-w "tw-text-save-color"))))
                (my/convert-currency 'JPY (dom-text price)))))
           (,(regexp-quote "api.github.com/repos") .
            ,(apply-partially 'assoc-default 'stargazers_count))))
        (org-agenda-bulk-custom-functions
         '((?U org-web-track-agenda-update)))
        (org-web-track-item-column-width 16)
        (org-web-track-update-column-width 30)
        (org-web-track-files
         (lambda ()
           (when (require 'denote nil t)
             (let ((denote-directory (expand-file-name "~/org/notes"))
                   (org-agenda-files '("~/org/agenda/")))
               (append (org-agenda-files)
                       (cl-remove-if-not (lambda (f)
                                           (member "track"
                                                   (denote-extract-keywords-from-path f)))
                                         (denote-directory-files))))))))
      

      • batch tracking
        

        export DISPLAY=:0 && \
          emacs -Q --batch \
                -l $XDG_CONFIG_HOME/emacs/early-init.el \
                -l $XDG_CONFIG_HOME/emacs/lisp/ext-config.el \
                -l $XDG_CONFIG_HOME/emacs/lisp/org-web-track-config.el \
                -l $XDG_CONFIG_HOME/emacs/batch/org-web-track-mail.el \
                -f my/org-web-track-mail
        

        (provide 'my/org-mode-init)
        (define-keymap :prefix 'my/org-global-map)
        (provide 'my-org-global-map)
        
        (setopt message-send-mail-function 'smtpmail-send-it
                smtpmail-smtp-server "<<smtp-host>>"
                smtpmail-smtp-service 465
                smtpmail-smtp-user user-mail-address
                smtpmail-stream-type 'ssl
                smtpmail-mail-address user-mail-address
                message-send-mail-function 'smtpmail-send-it
                network-security-level 'low
                make-backup-files nil)
        
        (defun my/org-web-track-mail ()
          "Update `org-web-track' items along with sending email and immediate exit."
          (my/org-web-track-update-all-and-notify)
          (org-save-all-org-buffers)
          (save-buffers-kill-emacs t))
        

    • org-tidy
      

      org-tidy attentively conceals all org drawers. I use it in my English drill session.

      (use-package org-tidy
        :ensure t
        :after org
        :bind (:map org-mode-map
                    ("C-c t" . org-tidy-mode)))
      

    • org-super-links   ARCHIVE
      
    • org-appear
      

      org-appear attentively displays emphasis markers, such as / for italic and _ for underline, only when the cursor is positioned over the word in Org Mode.

      "emacs-org-appear"
      

      (use-package org-appear
        :after org
        :disabled t ;; tempprarily not working with Org 9.7
        :hook (org-mode . (org-appear-mode)))
      

• Completion
  
  • vertico
    

    "emacs-vertico"
    

    ("https://github.com/minad/vertico/releases.atom" soft_update)
    

    (use-package vertico
      :bind (:map vertico-map
                  ("C-j" . exit-minibuffer)
                  ("RET" . vertico-directory-enter)
                  ("C-h" . vertico-directory-delete-char)
                  ("M-h" . vertico-directory-delete-word)
                  ("M-q" . vertico-quick-insert)
                  ("C-q" . vertico-quick-exit))
      :hook
      ((minibuffer-setup . vertico-repeat-save)
       ;; enable to write "~/" or "/" whatever path being input in minibuffer
       (rfn-eshadow-update-overlay . vertico-directory-tidy))
      :custom
      (vertico-cycle t)
      (vertico-scroll-margin 0)
      (vertico-count 11)
      (vertico-resize 'grow-only)
      :config
      (bind-keys ("M-R" . vertico-repeat))
      (vertico-mode 1))
    
    (use-package vertico-multiform
      :after vertico
      :bind (:map vertico-map
                  ("M-G" . vertico-multiform-grid))
      :config
      (vertico-multiform-mode 1))
    

  • consult
    

    "emacs-consult"
    

    ("https://github.com/minad/consult/releases.atom" soft_update)
    

    (use-package consult
      :after my-org-global-map
      :bind (("C-;" . consult-buffer)
             ("C-c m" . consult-mode-command)
             ("C-c r" . consult-recent-file)
             ("C-c h" . consult-outline)
             ("C-x M-:" . consult-complex-command)
             ("M-y" . consult-yank-pop)
             ("C-M-y" . consult-yank-from-kill-ring)
             ("M-g M-g" . consult-goto-line)
             ("M-g m" . consult-mark)
             ("M-g M" . consult-global-mark)
             ("M-g i" . consult-imenu)
             ("M-g I" . consult-imenu-multi)
             ("C-x r j" . consult-register)
             ("M-s e" . consult-isearch-history)
             ("M-s \\" . consult-locate)
             ("M-s f" . consult-find)
             ("M-s F" . consult-fd)
             ("M-s g" . consult-grep)
             ("M-s G" . consult-git-grep)
             ("M-s r" . consult-ripgrep)
             ("M-s l" . consult-line)
             ("H-s" . consult-line)
             ("M-s L" . consult-line-multi)
             ("M-s m" . consult-multi-occur)
             ("M-s k" . consult-keep-lines)
             ("M-s u" . consult-focus-lines)
             ("M-s i" . consult-info)
             ("C-x M-#" . consult-theme)
             :map my/org-global-map
             ("h" . consult-org-agenda)
             :map isearch-mode-map
             ("C-M-n" . consult-isearch-history)
             ("M-l" . consult-line)
             ("M-L" . consult-line-multi)
             :map minibuffer-local-map
             ("C-M-n" . consult-history)
             :map text-mode-map
             ("C-M-i" . completion-at-point)
             :map org-mode-map
             ("C-M-i" . completion-at-point))
      :custom
      (consult-narrow-key "<")
      (consult-widen-key ">")
      (consult-line-start-from-top t)
      (consult-locate-args (format "plocate -d %s --ignore-case --existing --regexp"
                                   (expand-file-name "<<plocate-db()>>")))
      (consult-find-args "find . ")
      (consult-fd-args '((if (executable-find "fdfind" 'remote)
                             "fdfind" "fd")
                         "--hidden --full-path --color=never"))
      :init
      ;; use consult for completion unless Corfu is active
      (setq completion-in-region-function
            (lambda (&rest args)
              (apply (if vertico-mode
                         #'consult-completion-in-region
                       #'completion--in-region)
                     args)))
      :config
      (with-eval-after-load 'org
        (bind-keys :map org-mode-map
                   ("C-c H" . consult-org-heading))))
    

    • consult-dir
      

      "emacs-consult-dir"
      

      (use-package consult-dir
        :after consult
        :bind ("H-d" . consult-dir))
      

    • affe
      

      (use-package affe
        :ensure t
        :bind (("M-s a f" . affe-find)
               ("M-s a g" . affe-grep)))
      

    • consult-ghq
      

      (use-package consult-ghq
        :ensure t
        :after consult
        :bind (("C-c q f" . consult-ghq-find)
               ("C-c q g" . consult-ghq-grep))
        :custom
        (consult-ghq-find-function 'dired))
      

  • embark
    

    "emacs-embark"
    

    ("https://github.com/oantolin/embark/releases.atom" soft_update)
    

    (use-package embark
      :bind (("C-." . embark-act)
             ("M-." . embark-dwim)
             ("<help> B" . embark-bindings)
             :map embark-file-map
             ("b" . browse-url))
      :init
      (setq prefix-help-command #'embark-prefix-help-command) ;
      :custom
      (embark-mixed-indicator-delay 3)
      :hook
      (embark-collect-mode . consult-preview-at-point-mode)
      :config
      (require 'embark-consult)
      (require 'embark-org)
      (require 'avy-embark-collect)
      (push 'embark--allow-edit
            (alist-get 'shell-command-on-region embark-target-injection-hooks)))
    

  • marginalia
    

    "emacs-marginalia"
    

    ("https://github.com/minad/marginalia/releases.atom" soft_update)
    

    (use-package marginalia
      :after vertico
      :config
      (marginalia-mode 1))
    

  • orderless
    

    "emacs-orderless"
    

    ("https://github.com/oantolin/orderless/releases.atom" soft_update)
    

    (use-package orderless
      :custom (completion-styles '(orderless)))
    

    • support for migemo in orderless
      

      (defun orderless-migemo (component)
        (let ((pattern (migemo-get-pattern component)))
          (condition-case nil
              (progn (string-match-p pattern "") pattern)
            (invalid-regexp nil))))
      
      (orderless-define-completion-style orderless-default-style
        (orderless-matching-styles '(orderless-literal
                                     orderless-regexp)))
      
      (orderless-define-completion-style orderless-migemo-style
        (orderless-matching-styles '(orderless-literal
                                     orderless-regexp
                                     orderless-migemo)))
      
      (setq orderless-matching-styles '(orderless-literal orderless-regexp orderless-migemo))
      
      ;; Uncomment this clause if you prefer to apply rules for completion categories selectively
      ;; (setq completion-category-overrides
      ;;       '((command (styles orderless-default-style))
      ;;         (file (styles orderless-migemo-style))
      ;;         (project-file (styles orderless-migemo-style))
      ;;         (buffer (styles orderless-migemo-style))
      ;;         (symbol (styles orderless-default-style))
      ;;         (multi-category (styles orderless-migemo-style))
      ;;         (org-heading (styles orderless-migemo-style))
      ;;         (consult-location (styles orderless-migemo-style))
      ;;         (org-roam-node (styles orderless-migemo-style))
      ;;         (unicode-name (styles orderless-migemo-style))
      ;;         (variable (styles orderless-default-style))))
      

  • corfu
    

    Though I prefer vertico more for completion interface, consult manual says Vertico can't be used with Eglot or lsp-mode. So I decided to use Corfu only in prog-mode.

    "emacs-corfu"
    

    (use-package corfu
      :hook ((prog-mode shell-mode eshell-mode) . corfu-mode)
      :custom
      (corfu-cycle t)
      (corfu-auto t)
      (corfu-preselect-first t))
    

  • cape
    

    "emacs-cape"
    

    (use-package cape
      :bind (:map ctl-x-map
                  :prefix "C-M-i"
                  :prefix-map my/cape-map
                  :prefix-docstring "Keymap for cape commands."
                  ("C-M-i" . completion-at-point)
                  ("d" . cape-dabbrev)
                  ("h" . cape-history)
                  ("f" . cape-file)
                  ("k" . cape-keyword)
                  ("s" . cape-symbol)
                  ("a" . cape-abbrev)
                  ("l" . cape-line)
                  ("w" . cape-dict)
                  ("\\" . cape-tex)
                  ("_" . cape-tex)
                  ("^" . cape-tex)
                  ("&" . cape-sgml)
                  ("r" . cape-rfc1345))
      :hook
      (text-mode . (lambda ()
                     (setq-local completion-at-point-functions
                                 (append completion-at-point-functions
                                         '(cape-dabbrev
                                           cape-file
                                           cape-symbol
                                           cape-dict)))))
      (prog-mode . (lambda ()
                     (setq-local completion-at-point-functions
                                 (append completion-at-point-functions
                                         '(cape-dabbrev
                                           cape-file
                                           cape-symbol
                                           cape-keyword
                                           cape-history))))))
    

• text-mode and its derivatives
  
  • nxml-mode
    

    (use-package nxml-mode
      :delight (nxml-mode " XM")
      :mode (("\.xml$"   . nxml-mode)
             ("\.xsl$"   . nxml-mode)
             ("\.xhtml$" . nxml-mode)
             ("\.page$"  . nxml-mode)
             ("\.plist$" . nxml-mode))
      :hook (nxml-mode . my/prog-mode-hook-function)
      :custom
      (nxml-child-indent 2)
      (nxml-attribute-indent 2)
      (nxml-slash-auto-complete-flag t)
      :config
      (setq-local tab-width 2)
      ;; pattern in hideshow mode for nxml mode
      (add-to-list 'hs-special-modes-alist
                   (list 'nxml-mode
                         "<!--\\|<[^/>]*[^/]>"
                         "-->\\|</[^/>]*[^/]>"
                         "<!--"
                         'nxml-forward-element
                         nil)))
    

  • toml-mode
    

    language grammar for toml

    (toml "https://github.com/tree-sitter/tree-sitter-toml")
    

    (toml-mode . toml-ts-mode)
    

    (use-package toml
      :mode "\\.toml$")
    

  • yaml-mode
    

    (yaml "https://github.com/ikatyang/tree-sitter-yaml")
    

    (yaml-mode . yaml-ts-mode)
    

    (yaml-ts-mode . combobulate-mode)
    

    (use-package yaml
      :mode "\\.ya?ml$")
    

  • json-mode
    

    "tree-sitter-json"
    

    (json-mode . json-ts-mode)
    

    (use-package json
      :mode "\\.json$")
    

  • markdown-mode
    

    "markdown"
    "tree-sitter-markdown"
    "emacs-markdown-mode"
    

    (use-package markdown-mode
      :mode "\\.md$")
    

  • tex-mode
    

    (use-package tex-mode
      :mode ("\\.tex$" . latex-mode)
      :hook ((tex-mode . (lambda () (setq ispell-parser 'tex))))
      :config
      (my/add-dash-docsets-hook 'latex-mode-hook '("LaTeX")))
    

• prog-mode and its derivatives
  

  (add-hook 'prog-mode-hook
            #'my/prog-mode-hook-function)
  
  (defun my/prog-mode-hook-function ()
    (hl-line-mode -1)
    (hs-minor-mode -1)
    (display-fill-column-indicator-mode 1)
    (prettify-symbols-mode 1))
  

  • sh-mode
    

    "tree-sitter-bash"
    

    (use-package sh-script
      :delight " SH"
      :commands sh-mode
      :mode ("\\.sh$" . sh-mode)
      :hook ((sh-mode)
             . (lambda ()
                 (my/add-dash-docsets-hook 'sh-mode-hook '("Bash"))
                 (setq-local devdocs-current-docs '("bash"))))
      :custom
      (sh-basic-offset 2)
      (sh-indent-after-if '+)
      (sh-indent-for-case-label 0)
      (sh-indent-for-case-alt '+))
    

  • bash-ts-mode
    

    (use-package bash-ts-mode
      :interpreter "bash"
      :hook ((bash-ts-mode)
             . (lambda ()
                 (setq-local devdocs-current-docs '("bash")))))
    

  • emacs-lisp-mode
    

    I'm in the trial of pp-eval-last-sexp instead of eval-last-sexp adviced from this blog post

    (elisp "https://github.com/Wilfred/tree-sitter-elisp")
    

    (use-package elisp-mode
      :mode ("\\.eld?$" . emacs-lisp-mode)
      :commands emacs-lisp-mode
      :hook (emacs-lisp-mode . (lambda ()
                                 (setq-local devdocs-current-docs '("elisp"))
                                 (push '("lambda" . ?λ) prettify-symbols-alist)
                                 (setq-local tab-width 8)
                                 (eldoc-mode 1)))
      :config
      (require 'eldoc)
      (substitute-key-definition 'eval-last-sexp
                                 'pp-eval-last-sexp
                                 global-map)
      (my/add-dash-docsets-hook 'emacs-lisp-mode-hook
                                '("Emacs Lisp")))
    
    (defun my/elisp-mode-eval-buffer ()
      (interactive)
      (message "Evaluated buffer")
      (eval-buffer))
    
    (keymap-set emacs-lisp-mode-map "C-c C-c" #'my/elisp-mode-eval-buffer)
    (keymap-set lisp-interaction-mode-map "C-c C-c" #'my/elisp-mode-eval-buffer)
    

  • lisp-mode
    

    (use-package lisp-mode
      :mode "\\.lisp$"
      :config
      (my/add-dash-docsets-hook 'lisp-mode-hook
                                '("Common Lisp")))
    

    • sly
      

      Sly, a fork of Slime.

      "emacs-sly"
      

      (use-package sly
        :custom
        (inferior-lisp-program "<<which(filename="sbcl")>>")
        (sly-auto-start 'ask)
        :config
        (with-eval-after-load 'ob-lisp
          (setopt org-babel-lisp-eval-fn 'sly-eval)))
      

  • scheme-mode
    

    "tree-sitter-scheme"
    

    (use-package scheme
      :mode (("\\.guix-channel" . scheme-mode)
             ("\\.guix-authorizations" . scheme-mode)))
    

  • cc-mode
    

    (use-package cc-mode
      :mode (("\\.c\\'"   . c-mode)
             ("\\.cpp\\'" . c++-mode))
      :hook (((c-mode c-ts-mode)
              . (lambda ()
                  (setq-local devdocs-current-docs '("c"))))
             ((c++-mode c++-ts-mode)
              . (lambda ()
                  (setq-local devdocs-current-docs '("cpp")))))
      :custom
      (c-tab-always-indent t)
      (c-auto-align-backslashes nil)
      (c-echo-syntactic-information-p t)
      (c-default-style "my/c-style")
      :config
      (my/add-dash-docsets-hook 'c-mode-common-hook
                                '("C"))
      (c-toggle-auto-newline 1)
      (c-add-style "my/c-style"
                   '((c-basic-offset . 4)
                     (c-comment-only-line-offset . 0)
                     (c-hanging-braces-alist
                      . ((brace-if-brace before after)
                         (substatement-open before after)))
                     (c-hanging-colons-alist
                      . ((case-label after)))
                     (c-cleanup-list
                      . (brace-else-brace
                         brace-elseif-brace
                         empty-defun-braces
                         defun-close-semi
                         list-close-comma
                         scope-operator))
                     (c-offsets-alist
                      . ((arglist-intro . +)
                         (arglist-cont-nonempty . c-lineup-arglist)))))
      (c-add-style "my/objc-style"
                   '((c-basic-offset . 2)
                     (c-comment-only-line-offset . 0)
                     (c-hanging-braces-alist
                      . ((brace-if-brace before after)
                         (substatement-open before after)))
                     (c-hanging-colons-alist
                      . ((case-label after)))
                     (c-cleanup-list
                      . (brace-else-brace
                         brace-elseif-brace
                         empty-defun-braces
                         defun-close-semi
                         list-close-comma
                         scope-operator))
                     (c-offsets-alist
                      . ((arglist-intro . +)
                         (arglist-cont-nonempty . c-lineup-arglist))))))
    

  • rust-mode
    

    "emacs-rust-mode"
    

    (use-package rust-mode
      :mode "\\.rs$"
      :hook ((rust-mode rust-ts-mode)
             . (lambda ()
                 (setq-local devdocs-current-docs '("rust")))))
    

  • rustic   ARCHIVE
    
  • python-mode
    

    "tree-sitter-python"
    

    (python-mode . python-ts-mode)
    

    (python-ts-mode . combobulate-mode)
    

    (use-package python
      :mode "\\.py\\'"
      :interpreter "python"
      :hook
      ((python-mode inferior-python-mode python-ts-mode) .
       (lambda ()
         (setq-local flycheck-checker 'python-pylint)
         (setq-local devdocs-current-docs '("python~3.9"))))
      :config
      (my/add-dash-docsets-hook 'python-mode-hook
                                '("Python 3" "NumPy" "Matplotlib"))
      (my/add-dash-docsets-hook 'inferior-python-mode-hook
                                '("Python 3")))
    
    (defvar python-mode-initialized nil)
    
    (defun my-python-mode-hook ()
      (setq-local flycheck-checker 'python-pylint)
      (jedi:setup)
      (jedi-mode 1)
      (unless python-mode-initialized
        (setq python-mode-initialized t)
        (info-lookup-add-help
         :mode 'python-mode
         :regexp "[a-zA-Z_0-9.]+"
         :doc-spec
         '(("(python)Python Module Index" )
           ("(python)Index"
            (lambda
              (item)
              (cond
               ((string-match
                 "\\([A-Za-z0-9_]+\\)() (in module \\([A-Za-z0-9_.]+\\))" item)
                (format "%s.%s" (match-string 2 item)
                        (match-string 1 item))))))))))
    

    • emacs-project
      

      "emacs-company-jedi"
      

      (use-package company-jedi
        :after python
        :hook (python-mode . my/python-mode-hook)
        :custom
        (jedi:tooltip-method nil)
        :config
        (defun my/python-mode-hook ()
          (add-to-list 'company-backends 'company-jedi)))
      

  • ruby-mode
    

    (ruby-mode . ruby-ts-mode)
    

    (use-package ruby
      :mode (("\\.rb$"   . ruby-mode)
             ("Capfile$" . ruby-mode)
             ("Gemfile$" . ruby-mode))
      :interpreter (("ruby"    . ruby-mode)
                    ("rbx"     . ruby-mode)
                    ("jruby"   . ruby-mode))
      :hook ((ruby-mode ruby-ts-mode)
             . (lambda ()
                 (setq-local flycheck-checker 'ruby-rubocop)
                 (setq-local devdocs-current-docs '("ruby~3.2"))))
      :config
      (setq ruby-indent-level 2)
      (setq ruby-insert-encoding-magic-comment nil)
      (add-to-list 'hs-special-modes-alist
                   `(ruby-mode
                     ,(rx (or "def" "class" "module" "do" "if" "{" "[")) ; Block start
                     ,(rx (or "}" "]" "end"))                       ; Block end
                     ,(rx (or "#" "=begin"))                        ; Comment start
                     ruby-forward-sexp nil))
      (my/add-dash-docsets-hook 'ruby-mode-hook '("Ruby")))
    

    • inf-ruby
      

      "emacs-inf-ruby"
      

      (use-package inf-ruby
        :after ruby
        :config
        (setq inf-ruby-default-implementation "pry")
        (add-to-list 'inf-ruby-implementations '("pry" . "pry"))
        (setq inf-ruby-eval-binding "Pry.toplevel_binding")
        (setq inf-ruby-first-prompt-pattern "^\\[[0-9]+\\] pry\\((.*)\\)> *")
        (setq inf-ruby-prompt-pattern "^\\[[0-9]+\\] pry\\((.*)\\)[>*\"'] *"))
      

  • java-ts-mode
    

    (java-mode . java-ts-mode)
    

    (use-package java-ts-mode
      :mode "\\.java$"
      :hook (java-ts-mode
             . (lambda ()
                 (setq-local devdocs-current-docs '("openjdk~21")))))
    

  • lua-mode
    

    "emacs-lua-mode"
    

    (use-package lua-mode
      :mode "\\.lua$"
      :hook ((lua-mode lua-ts-mode)
             . (lambda ()
                 (setq-local flycheck-checker 'lua-rubocop)
                 (setq-local devdocs-current-docs '("lua~3.2")))))
    

  • perl-mode
    

    (use-package perl-mode
      :delight " PL")
    

  • web-mode
    

    "emacs-web-mode"
    "tree-sitter-html"
    "tree-sitter-css"
    

    (use-package web-mode
      :delight " WB"
      :mode (("\\.phtml$"     . web-mode)
             ("\\.tpl\\.php$" . web-mode)
             ("\\.jsp$"       . web-mode)
             ("\\.as[cp]x$"   . web-mode)
             ("\\.erb$"       . web-mode)
             ("\\.html?$"     . web-mode))
      :custom
      (web-mode-attr-indent-offset        2)
      (web-mode-attr-value-indent-offset  2)
      (web-mode-code-indent-offset        2)
      (web-mode-css-offset                2)
      (web-mode-markup-indent-offset      2)
      (web-mode-sql-indent-offset         2)
      (web-mode-block-padding             2)
      (web-mode-script-padding            2)
      :config
      (my/add-dash-docsets-hook 'web-mode-hook '("HTML")))
    

  • css-mode
    

    (use-package css-mode
      :mode "\\.css$"
      :hook ((css-mode css-ts-mode)
             . (lambda ()
                 (my/add-dash-docsets-hook 'css-mode-hook '("CSS"))
                 (setq-local devdocs-current-docs '("css"))))
      :custom
      (css-indent-offset 2))
    

  • js2-mode
    

    "emacs-js2-mode"
    

    (js2-mode . js-ts-mode)
    (css-mode . css-ts-mode)
    

    (use-package js2-mode
      :delight " J2"
      :mode (("\\.js\\(on\\)?\\'" . js2-mode)
             ("\\.eslintrc\\'"    . js2-mode))
      :hook (js2-mode . (lambda ()
                          (setq-local flycheck-checker 'javascript-eslint)
                          (setq-local flycheck-disabled-checkers '(javascript-jshint javascript-jscs))))
      :custom
      (flycheck-javascript-eslint-executable "eslint")
      (my/add-dash-docsets-hook 'js2-mode-hook '("JavaScript")))
    
    (use-package js
      :disabled t
      :delight " JS"
      :custom
      (js-indent-level 2))
    

  • make
    

    (cmake "https://github.com/uyha/tree-sitter-cmake")
    (make "https://github.com/alemuller/tree-sitter-make")
    

    (cmake-mode . cmake-ts-mode)
    

    (use-package cmake
      :mode (("\\.mk$" . cmake-mode)
             ("^Makefile$" . cmake-mode)))
    

  • sql-mode
    

    (use-package sql
      :delight " SQ"
      :commands (sql-mode)
      :mode (("\\.sql$" . sql-mode))
      :bind (:map sql-interactive-mode-map
                  ("C-j" . comint-send-input))
      :hook (sql-mode . (lambda ()
                          (setq-local flycheck-checker 'sql-sqlint))))
    

  • plantuml-mode
    

    "emacs-plantuml-mode"
    

    (use-package plantuml
      :mode "\\.plu$"
      :custom
      (plantuml-jar-path "~/.guix-extra-profiles/emacs/emacs/share/java/plantuml.jar")
      (plantuml-exec-mode 'jar)
      :config
      (my/add-dash-docsets-hook 'plantuml-mode-hook '("PlantUML")))
    

  • conf
    

    (use-package conf-mode
      :delight " CF")
    

  • generic-x
    

    (use-package generic-x
      :mode (("\\.conf$"     . apache-conf-generic-mode)
             ("\\.htaccess$" . apache-conf-generic-mode)))
    

• special-mode derivatives
  
  • special mode
    

    (keymap-set special-mode-map "C-j" #'push-button)
    

  • help
    

    (with-eval-after-load 'help
      (keymap-set help-map "C-?" #'help-for-help)
      (keymap-set help-map "c" #'describe-face)
      (keymap-set help-map "K" #'describe-keymap))
    

  • woman
    

    (autoload #'woman "woman" nil t)
    

• Programming
  
  • sMerge
    

    sMerge can be used to solve merging problems. The code below kicks off sMerge if there is a collision sign.

    (autoload 'smerge-mode "smerge-mode" nil t)
    
    (defun my/try-smerge ()
      (save-excursion
        (goto-char (point-min))
        (when (re-search-forward "^<<<<<<< " nil t)
          (smerge-mode 1))))
    (add-hook 'find-file-hook 'my/try-smerge t)
    

  • Next Error
    

    (setopt next-error-message-highlight t)
    

  • Hideshow
    

    (use-package hideshow
      :diminish "hs"
      :bind (("C-c TAB" . hs-toggle-hiding)))
    

  • imenu
    

    (use-package imenu
      :custom
      (imenu-auto-rescan t))
    

  • compile
    

    (use-package compile
      :bind (:map compilation-mode-map
                  ("C-j" . compile-goto-error)))
    

  • grep
    

    (use-package grep
      :custom
      (grep-program "rg")
      :config
      (bind-keys :map grep-mode-map
                 ("C-j" . compile-goto-error)))
    
    (defun my/grep-ripgrep-all ()
      "Grep many kind of files like pdf, epub and more."
      (interactive)
      (let ((grep-find-command '("rga --with-filename --no-heading --line-number --color never -e '' ./* ./**/*" . 66)))
        (call-interactively 'grep-find)))
    
    (keymap-global-set "M-s R" 'my/grep-ripgrep-all)
    

  • executable
    

    The post says it is useful to set executable bit if the saved file seems to be script.

    (with-eval-after-load 'executable
      (add-hook 'after-save-hook
                'executable-make-buffer-file-executable-if-script-p))
    

  • Paren Showing
    

    (use-package paren
      :hook (prog-mode . show-paren-local-mode)
      :custom
      (show-paren-style 'mixed)
      (show-paren-delay 0.2)
      (show-paren-mode nil)
      (show-paren-context-when-offscreen t))
    

  • project
    

    (use-package project
      :custom
      (project-kill-buffers-display-buffer-list t)
      :config
      (add-to-list 'project-switch-commands
                   '(project-dired "Dired root"))
      (with-eval-after-load 'magit
        (bind-keys :map project-prefix-map
                   ("M" . magit-project-status))
        (add-to-list 'project-switch-commands
                     '(magit-project-status "Magit"))))
    

  • log-view
    

    (use-package log-view
      :delight
      (log-view-mode " LV")
      :mode ("\\.log$" . log-view-mode)
      :hook ((log-view-mode . my/prog-mode-hook-function )
             (log-view-mode . auto-revert-tail-mode)))
    

  • vc (version control)
    
  • vc-hooks
    

    (use-package vc-hooks
      :custom
      (vc-follow-symlinks t))
    

• Tree Sitter
  

  "tree-sitter"
  

  (use-package treesit
    :preface
    (defun my/setup-install-grammars ()
      "Install Tree-sitter grammars if they are absent."
      (interactive)
      (dolist (grammar
               '(<<treesit-language-source>>))
        (add-to-list 'treesit-language-source-alist grammar)
        (unless (treesit-language-available-p (car grammar))
          (treesit-install-language-grammar (car grammar)))))
    :config
    (my/setup-install-grammars))
  

  • combobulate
    

    (use-package combobulate
      :disabled t
      :after treesit
      :preface
      (setq combobulate-key-prefix "C-c o")
      :hook (<<combobulate-hook>>)
      :load-path ("~/.emacs.d/site-elisp/combobulate/"))
    

  • major mode remapping
    

    (setq major-mode-remap-alist
          '(<<major-mode-remap-rule>>))
    

• Elisp Package Development
  
  • package build
    

    "emacs-package-build"
    

    (let ((default-directory package-user-dir))
      (setopt package-build-recipes-dir
              (expand-file-name "recipes")
              package-build-archive-dir
              (expand-file-name "packages")
              package-build-working-dir
              (expand-file-name "working")))
    

  • flycheck package
    

    "emacs-flycheck-package"
    

    (eval-after-load 'flycheck
      '(flycheck-package-setup))
    

  • package lint
    

    "emacs-package-lint"
    

  • makem.sh
    

    (require 'makem)
    

• Blogging
  

  This subtree holds resources for my blog.

  • org-static-blog   ARCHIVE
    
  • templates for blogging
    

    (blog-post-filename (format-time-string "%Y%m%d-%H%M.org"))
    (blog-post-dotfile-url "https://p-snow.org/config/dotfiles.html#")
    

    (blog-post-skeleton "#+title:" n
                        "#+date:" n
                        "#+description:" n
                        "#+filetags:" n n
                        "#+SETUPFILE: "
                        (pcase (file-name-base (directory-file-name default-directory))
                          ("posts" "diary/header")
                          ("org-content" "header")))
    (blog-post-macro-preview "{{{preview-begin}}}" n
                             "{{{preview-end}}}")
    (blog-post-macro-accordion (p "Summary: " summary t)
                               (format "{{{accordion-begin(%s)}}}" summary) n
                               "{{{accordion-end}}}")
    

    (desktop-recording
     "ffmpeg -video_size 2560x1440 -framerate 25 -f x11grab -i :0.0 output.mp4")
    

  • ox-haunt
    

    "emacs-ox-haunt"
    

    (use-package ox-haunt
      :after ox)
    

• Journaling
  
  • journal entry template
    

    (journal "- diary" n>
             "#+begin_src text" n> "#+end_src" n
             "- clocktable" n>
             "#+begin: clocktable-by-tag :maxlevel 3 :wstart 1 "
             ":block " (p "year") "-" (p "month") "-" (p "day") n>
             "#+end:" n
             "- agenda" n>
             "#+begin_example" n
             (p "agenda") n>
             "#+end_example")
    

  • week subtree template
    

    (nw & "- mission [/]" n
        "- clocktable" n>
        "#+begin: clocktable-by-tag :maxlevel 3 "
        ":block " (p "year" year) "-W" (p "isoweek" isoweek) " :wstart 1" n>
        "#+end:" n
        "- meta-projects" n>
        "#+begin: clocktable :maxlevel 3 :scope agenda "
        ":block " year "-W" isoweek
        " :wstart 1 :narrow 40! :tcolumns 3 :formula %" n>
        "#+end:")
    

• External Emacs Packages
  

  Packages below are out of categories above. Packages which have ARCHIVE tag is no longer in use. Keywords which package gives in its description are set to tag.

  • git-modes
    

    "emacs-git-modes"
    

    (use-package git-modes)
    

  • git-annex
    

    "emacs-git-annex"
    

    ("https://github.com/jwiegley/git-annex-el/releases.atom" soft_update)
    

    (use-package git-annex
      :after dired
      :custom-face
      (git-annex-dired-annexed-available ((t (:foreground "green yellow"))))
      (git-annex-dired-annexed-unavailable ((t (:foreground "red3")))))
    

  • magit-annex   ARCHIVE
    
  • orgit
    

    "emacs-orgit"
    

    (use-package orgit
      :after my/org-mode-init
      :custom
      (orgit-remote "github"))
    

  • suggest
    

    "emacs-suggest"
    

    (use-package suggest
      :commands suggest
      :custom
      (suggest-insert-example-on-start nil))
    

  • mastodon
    

    "emacs-mastodon"
    

    (use-package mastodon
      :after my-launch-app
      :bind (:map my/launch-app-map
                  ("@" . mastodon))
      :hook (mastodon-mode . visual-line-mode)
      :custom
      (mastodon-active-user "p_snow")
      (mastodon-instance-url "https://social.linux.pizza")
      (mastodon-client--token-file
       (no-littering-expand-var-file-name "mastodon.plstore"))
      :config
      (require 'mastodon-views))
    

  • bookmark+   ARCHIVE
    
  • chatgpt-shell
    

    "emacs-chatgpt-shell"
    

    (use-package chatgpt-shell
      :after engine-mode
      :preface
      (defun my/chatgpt-shell-dwim ()
        "docstring"
        (interactive)
        (if (use-region-p)
            (chatgpt-shell-prompt-compose)
          (chatgpt-shell)))
      :bind (:map engine-mode-prefixed-map
                  ("p c" . my/chatgpt-shell-dwim)
                  ("p C" . chatgpt-shell-prompt)
                  ("p e" . chatgpt-shell-explain-code)
                  ("p d" . chatgpt-shell-describe-code)
                  ("p p" . chatgpt-shell-proofread-region)
                  ("p g" . chatgpt-shell-write-git-commit)
                  ("p u" . chatgpt-shell-generate-unit-test)
                  ("p i" . (lambda (&optional lang)
                             "Ask ChatGPT to interpret into Japanese or some other language if LANG is non-nil."
                             (interactive "P")
                             (when (require 'chatgpt-shell nil t)
                               (chatgpt-shell-send-region-with-header
                                (format "Please help me interpret the following sentence into %s:"
                                        (if (equal lang '(4))
                                            (completing-read "Langauage: " '("Japanese" "English" "German"))
                                          "Japanese"))))))
                  :map chatgpt-shell-mode-map
                  ("C-M-g" . chatgpt-shell-clear-buffer))
      :custom
      (chatgpt-shell-openai-key 'my/credential-info)
      (chatgpt-shell-system-prompt 3)
      (chatgpt-shell-model-temperature 0.6))
    
    (use-package ob-chatgpt-shell
      :after (chatgpt-shell ob-core)
      :config
      (ob-chatgpt-shell-setup)
      (add-to-list 'org-structure-template-alist
                   '("ch" . "src chatgpt-shell")
                   t))
    
    (use-package dall-e-shell
      :commands dall-e-shell
      :custom
      (dall-e-shell-openai-key 'my/credential-info))
    

  • async
    

    "emacs-async"
    

    (use-package dired-async
      :after dired
      :config
      (dired-async-mode 1))
    
    (use-package async-bytecomp
      :custom
      (async-bytecomp-package-mode t))
    

  • visible-mark   marking faces color
    

    (use-package visible-mark
      :ensure t
      :config
      (global-visible-mark-mode 1))
    

  • ement   comm
    

    "emacs-ement"
    

  • ligature   extensions data
    

    "emacs-ligature"
    

    (use-package ligature
      :hook (prog-mode . ligature-mode)
      :config
      ;; ligatures below are supported by `Iosevka' font
      (ligature-set-ligatures 'prog-mode
                              '("-<<" "-<" "-<-" "<--" "<---" "<<-" "<-" "->" "->>" "-->" "--->" "->-" ">-" ">>-"
                                "=<<" "=<" "=<=" "<==" "<===" "<<=" "<=" "=>" "=>>" "==>" "===>" "=>=" ">=" ">>="
                                "<->" "<-->" "<--->" "<---->" "<=>" "<==>" "<===>" "<====>" "::" ":::" "__"
                                "<~~" "</" "</>" "/>" "~~>" "==" "!=" "/=" "~=" "<>" "===" "!==" "!===" "=/=" "=!="
                                "<:" ":=" "*=" "*+" "<*" "<*>" "*>" "<|" "<|>" "|>" "<." "<.>" ".>" "+*" "=*" "=:" ":>"
                                "(*" "*)" "/*" "*/" "[|" "|]" "{|" "|}" "++" "+++" "\\/" "/\\" "|-" "-|" "<!--" "<!---")))
    

  • meow   modal_editing convenience ARCHIVE
    
  • enlive   selector query css
    

    "emacs-enlive"
    

  • gptel   convenience
    

    gptel is my go-to AI frontend in Emacs as of [2024-07-19 Fri]. It supports a large number of services (LLM models).

    (use-package gptel
      :ensure t
      :after engine-mode
      :bind ("H-Q" . my/gpeel-invoke)
      :preface
      (defun my/gpeel-invoke (&optional arg)
        "Enable users to call gptel/gptel-menu/gptel-send by changing prefix argument."
        (interactive "P")
        (call-interactively (pcase arg
                              ('(16) #'gptel)
                              ('(4) #'gptel-menu)
                              (default #'gptel-send))))
      :custom
      (gptel-api-key (apply-partially #'my/credential-info "openai.com" "apikey"))
      (gptel-max-tokens 500)
      (gptel-model "gpt-4o-mini")
      (gptel-default-mode 'org-mode)
      :config
      (cl-pushnew '(proofreading . "Please help me proofread the following text with English.")
                  gptel-directives)
      (cl-pushnew '(commit-message-pr . "Please help me proofread the following text as a commit message for Git.")
                  gptel-directives)
      (cl-pushnew '(japanese . "Please help me interpret the following sentence into Japanese.")
                  gptel-directives)
      (cl-pushnew '(english . "Please help me interpret the following sentence into English.")
                  gptel-directives)
      (gptel-make-gemini "Gemini"
        :key (apply-partially 'my/credential-info "www.google.com/<<full-name>>" "gemini apikey")
        :stream t)
      (gptel-make-openai "Perplexity"
        :host "api.perplexity.ai"
        :key (apply-partially 'my/credential-info "perplexity.ai")
        :endpoint "/chat/completions"
        :stream t
        :models '("llama-3.1-sonar-small-128k-online"
                  "llama-3.1-sonar-large-128k-online"
                  "llama-3.1-sonar-small-128k-chat"
                  "llama-3.1-sonar-large-128k-chat"
                  "llama-3.1-70b-instruct"
                  "llama-3.1-8b-instruct")))
    

  • engine-mode
    

    "emacs-engine-mode"
    

    (use-package engine-mode
      :preface
      (defvar engine/minibuffer-history nil
        "Minibuffer history for `engine-mode'.")
      (defun engine--history-search-term (engine-name)
        "Prompt the user for a search term for ENGINE-NAME.
    Default to the symbol at point."
        (let ((current-word (or (thing-at-point 'symbol 'no-properties) "")))
          (read-string (engine--search-prompt engine-name current-word)
                       nil 'engine/minibuffer-history current-word)))
      :config
      (advice-add 'engine--prompted-search-term :override
                  'engine--history-search-term)
      (engine/set-keymap-prefix (kbd "H-q"))
      (engine-mode 1)
      (defengine google
        "https://www.google.com/search?ie=utf-8&oe=utf-8&q=%s"
        :keybinding "g")
      (defengine duckduckgo
        "https://duckduckgo.com/?q=%s"
        :keybinding "d")
      (defengine youtube
        "https://www.youtube.com/results?aq=f&oq=&search_query=%s"
        :keybinding "y")
      (defengine github
        "https://github.com/search?ref=simplesearch&q=%s"
        :keybinding "h")
      (defengine amazon
        "https://www.amazon.co.jp/gp/search/?field-keywords=%s"
        :keybinding "a")
      (defengine melpa
        "https://melpa.org/#/?q=%s"
        :keybinding "m")
      (defengine eijiro
        "https://eow.alc.co.jp/search?q=%s"
        :keybinding "e")
      (defengine weblio
        "https://www.weblio.jp/content/%s"
        :keybinding "l")
      (defengine wikipedia-ja
        "https://ja.wikipedia.org/wiki/%s"
        :keybinding "w")
      (defengine wikipedia
        "https://en.wikipedia.org/wiki/%s"
        :keybinding "W"))
    

  • tmr   timer convenience
    

    "emacs-tmr"
    

    (use-package tmr
      :after my-launch-app
      :bind (:map my/launch-app-map
                  ("t" . tmr)))
    

  • beframe
    

    "emacs-beframe"
    

    (use-package beframe
      :ensure t
      :bind (("C-x B" . beframe-switch-buffer)
             ("C-x C-b" . beframe-buffer-menu))
      :custom
      (beframe-global-buffers '("*Messages*" "*Backtrace*"))
      (beframe-create-frame-scratch-buffer nil)
      :config
      (with-eval-after-load 'consult
        (defface beframe-buffer
          '((t :inherit font-lock-string-face))
          "Face for `consult' framed buffers.")
        (defvar beframe--consult-source
          `( :name     "Frame-specific buffers (current frame)"
             :narrow   ?F
             :category buffer
             :face     beframe-buffer
             :history  beframe-history
             :items    ,#'beframe--buffer-names
             :action   ,#'switch-to-buffer
             :state    ,#'consult--buffer-state))
        (add-to-list 'consult-buffer-sources 'beframe--consult-source))
      (beframe-mode 1))
    

  • free-keys   convenience
    

    "emacs-free-keys"
    

    (use-package free-keys
      :after my-launch-app
      :bind (:map my/launch-app-map
                  ("f" . free-keys))
      :config
      (setq free-keys-modifiers (append free-keys-modifiers
                                        '("H"))))
    

  • consult-recoll   docs convenience
    

    (use-package consult-recoll
      :ensure t
      :after consult
      :bind ("M-s c" . consult-recoll)
      :preface
      (defun my/consult-recoll--html (file)
        (let ((mime (mailcap-extension-to-mime (file-name-extension file))))
          (cond
           ((string= mime (regexp-quote "application/epub+zip"))
            (my/open-epub-as-html file))
           (t (eww-open-file file)))))
      :custom
      (consult-recoll-open-fns
       '(("text/html" . my/consult-recoll--html)
         ("application/pdf" . my/open-pdf-as-html))))
    

  • detached   processes convenience
    

    How to use detached.el

    • in vterm
      1. create a session with S-RET(detached-vterm-send-input)
      2. detach from the session with C-c C-d(detached-detach-key)
      3. attach to the session with C-RET(detached-vterm-attach)
    • with shell-command
      • invoke/call detached-shell-command

    "dtach"
    "emacs-detached"
    

    (use-package detached
      :init
      (detached-init)
      (defvar my/detached-bury-buffer nil)
      :bind
      (([remap async-shell-command] . detached-shell-command)
       ([remap compile] . detached-compile)
       ([remap recompile] . detached-compile-recompile))
      :custom
      (detached-shell-command-initial-input nil)
      (detached-terminal-data-command system-type)
      (detached-terminal-data-command system-type)
      :config
      (add-to-list 'display-buffer-alist
                   `((lambda (buffer-or-name arg)
                       (when (and (string-match-p
                                   (regexp-opt (list detached--shell-command-buffer))
                                   (cond
                                    ((stringp buffer-or-name) buffer-or-name)
                                    ((bufferp buffer-or-name) (buffer-name buffer-or-name))))
                                  my/detached-bury-buffer)
                         (setq my/detached-bury-buffer nil)
                         t))
                     (display-buffer-reuse-window)
                     (body-function
                      . (lambda (window) (interactive)
                          (bury-buffer))))))
    
    (defun my/org-link--open-shell-detached (path _)
      "Open a \"shell\" type.
    
    PATH is the command to execute with `detached-shell-command'."
      (if (or (and (org-string-nw-p org-link-shell-skip-confirm-regexp)
                   (string-match-p org-link-shell-skip-confirm-regexp path))
              (not org-link-shell-confirm-function)
              (funcall org-link-shell-confirm-function
                       (format "Execute %s in shell? "
                               (org-add-props path nil 'face 'org-warning))))
          (progn
            (message "Executing %s" path)
            (detached-shell-command path))
        (user-error "Abort")))
    
    (with-eval-after-load 'ol
      (org-link-set-parameters "shell" :follow #'my/org-link--open-shell-detached))
    
    (use-package detached-list
      :after my-launch-app
      :bind (:map my/invoke-list-command-map
                  ("d" . detached-list-sessions))
      :config
      (bind-keys :map detached-list-mode-map
                 ("C-m" . detached-list-open-session)
                 ("C-j" . detached-list-open-session)))
    

  • emacs-guix   tools
    

    "emacs-guix"
    

    (use-package guix
      :commands guix
      :config
      (with-eval-after-load 'my-launch-app
        (bind-keys :map my/launch-app-map
                   ("x" . guix))))
    

  • pcre2el
    

    pcre2el is not only the converter between PCRE, emacs lisp style regexp and RX representation. It support re-builder as a conversion environment. Great!

    "emacs-pcre2el"
    

    (use-package pcre2el)
    

  • iedit   simultaneous region refactoring occurrence
    

    IEdit is not only replacement for M-%/C-M-% but it highlights symbol occurences to change. This advise would be useful for anyone who needs dedicated command to replace symbols in defun.

    "emacs-iedit"
    

    (use-package iedit
      :bind ("C-\"" . iedit-mode)
      :custom
      (iedit-toggle-key-default (kbd "C-\""))
      (iedit-auto-narrow t))
    

  • ledger-mode / flycheck-ledger   tools languages convenience
    

    "emacs-ledger-mode"
    "emacs-flycheck-ledger"
    

    (use-package ledger-mode
      :bind (:map ledger-mode-map
                  ("C-c C-y" . ledger-copy-transaction-at-point))
      :custom
      (ledger-reconcile-default-commodity "\\")
      :config
      (require 'flycheck-ledger)
      (with-eval-after-load 'ob-core
        (require 'ob-ledger)))
    

  • mentor   processes comm bittorrent
    

    mentor is a rTorrent client for emacs.

    Typical file downloading workflow:

    1. start mentor: M-x mentor
    2. add magnet link (URL or torrent file path): M-x mentor-download-load-magnet-link-or-url (l)
    3. view downloaded file in dired: M-x mentor-dired-jump (v)
    4. shutdown mentor: M-x mentor-shutdown (Q)

    "emacs-mentor"
    

    (use-package mentor
      :commands mentor
      :custom
      (mentor-rtorrent-download-directory "<<torrent-dir()>>")
      (mentor-rtorrent-keep-session t)
      (mentor-rtorrent-external-rpc "<<rtorrent-sock()>>"))
    

  • geiser   scheme languages geiser
    

    guix#The Perfect Setup

    "guile"
    "emacs-geiser"
    "emacs-geiser-guile"
    

    (use-package geiser-guile
      :commands (scheme-mode)
      :config
      (add-to-list 'geiser-guile-load-path
                   (file-name-concat "<<ghq-root()>>" "git.savannah.gnu.org/git/guix"))
      (with-eval-after-load 'yasnippet
        (add-to-list 'yas-snippet-dirs
                     (file-name-concat "<<ghq-root()>>" "git.savannah.gnu.org/git/guix/etc/snippets/yas")
                     t))
      (load-file (file-name-concat "<<ghq-root()>>" "git.savannah.gnu.org/git/guix/etc/copyright.el")))
    

  • consult-dash   docs dash consult
    

    "emacs-dash-docs"
    

    (use-package dash-docs
      :custom
      (dash-docs-docsets-path
       (file-name-concat "<<share-dir()>>" "dash/docsets")))
    
    (add-to-list 'load-path
                 (expand-file-name "elpa/consult-dash-20220621.226" user-emacs-directory))
    
    (use-package consult-dash
      :after dash-docs
      :bind ("M-s M-d" . consult-dash))
    

    (defmacro my/add-dash-docsets-hook (hook docsets)
      `(add-hook ,hook
                 (lambda ()
                   (when (functionp 'consult-dash)
                     (setq-local consult-dash-docsets ,docsets)))))
    

  • denote
    

    Denote leverages note taking in org mode by providing file naming scheme and backlink capability.

    "emacs-denote"
    

    (use-package denote
      :after my/org-mode-init
      :bind (("C-c n n" . denote)
             ("C-c n o" . denote-open-or-create))
      :custom
      (denote-directory (expand-file-name "~/org/notes"))
      :config
      (require 'denote-org-extras)
      (with-eval-after-load 'org-capture
        (setq denote-org-capture-specifiers "%l\n%i\n%?")
        (add-to-list 'org-capture-templates
                     '("n" "New note (with denote.el)" plain
                       (file denote-last-path)
                       #'denote-org-capture
                       :no-save t
                       :immediate-finish nil
                       :kill-buffer t
                       :jump-to-captured t))))
    

  • denote-menu
    

    "emacs-denote-menu"
    

    (use-package denote-menu
      :after denote
      :custom
      (denote-menu-date-column-width 12)
      (denote-menu-title-column-width 32)
      (denote-menu-show-file-type nil))
    

  • tree-sitter   ARCHIVE
    
  • xr   ARCHIVE
    
  • Whole Line Or Region   wp convenience
    

    ("https://github.com/purcell/whole-line-or-region/releases.atom" soft_update)
    

    (use-package whole-line-or-region
      :ensure t
      :config
      (whole-line-or-region-global-mode 1))
    

  • projectile   ARCHIVE ignore
    
  • counsel-projectile   ARCHIVE ignore
    
  • ag.el   ARCHIVE ignore
    
  • ripgrep.el   ARCHIVE ignore
    
  • wgrep   grep extensions edit
    

    "emacs-wgrep"
    

    (use-package wgrep
      :custom
      (wgrep-auto-save-buffer t)
      (wgrep-enable-key "e"))
    

  • dumb-jump   programming
    

    dumb-jump is "jump to definition" package without tagging.

    "emacs-dumb-jump"
    

    (use-package dumb-jump
      :after xref
      :config
      (add-to-list 'xref-backend-functions
                   #'dumb-jump-xref-activate)
      (bind-keys ("M-g ." . dumb-jump-go)
                 ("M-g ," . dumb-jump-back)
                 ("M-g l" . dumb-jump-quick-look)))
    

  • visual-regexp   ARCHIVE
    
  • avy   point location
    

    This post tell me how we can concoct efficient editing workflow with avy.

    "emacs-avy"
    

    (use-package avy
      :preface
      (defun avy-action-embark (pt)
        (unwind-protect
            (save-excursion
              (goto-char pt)
              (embark-act))
          (select-window
           (cdr (ring-ref avy-ring 0))))
        t)
      :config
      (setf (alist-get ?. avy-dispatch-alist) 'avy-action-embark)
      (bind-keys ("M-g g" . avy-goto-line)
                 ("H-g" . avy-goto-line)))
    

    • avy-migemo
      

      (use-package avy-migemo
        :ensure t
        :after migemo
        :bind (("M-g M-a" . avy-migemo-goto-char-timer)
               ("M-g a" . avy-migemo-goto-char-timer)
               ("H-a" . avy-migemo-goto-char-timer)
               :map isearch-mode-map
               ("M-a" . avy-migemo-isearch)))
      

  • paredit   lisp
    

    Handy commands

    • press '(' to insert '()' pair
    • C-<left/right> to barf and slurp s-expressions
    • call paredit-splice-sexp to strip embracing parenthes
    • press M-<up> or M-r to delete upper sexp except pointing one
    • DEL, C-d, C-k act like originals but care for parenthes
    • press DEL to remedy unbalanced parenthes
    • press C-q ( to insert ( char manually

    "emacs-paredit"
    

    (use-package paredit
      :bind (:map paredit-mode-map
                  ("<backspace>" . paredit-backward-delete)
                  ("C-M-g" .  paredit-splice-sexp)
                  ("M-s" . nil)
                  ("C-M-;" . paredit-comment-dwim)
                  ("M-;" . nil))
      :hook (((emacs-lisp-mode lisp-mode scheme-mode) . enable-paredit-mode)))
    

    • workaround Thanks to this blog post, a couple of commands in paredit.el are fixed with transient-mark-mode

      (defvar my/paredit-delete-region-functions
        '(paredit-forward-delete
          paredit-backward-delete)
        "List of `paredit-mode' functions that should support tmm region deletion.")
      
      (defvar my/paredit-kill-region-functions
        '(paredit-forward-kill-word
          paredit-backward-kill-word)
        "List of `paredit-mode' functions that should support tmm region killing.")
      
      (defun my/paredit-fix-transient-mark-mode (orig-fn &rest args)
        "Allow deleting/killing a region if expression is balanced."
        (if (and transient-mark-mode
                 mark-active)
            (cond ((memq this-command my/paredit-delete-region-functions)
                   (paredit-delete-region (region-beginning) (region-end)))
                  ((memq this-command my/paredit-kill-region-functions)
                   (paredit-kill-region (region-beginning) (region-end)))
                  (t (apply orig-fn args)))
          (apply orig-fn args)))
      
      (dolist (fun (append my/paredit-delete-region-functions
                           my/paredit-kill-region-functions))
        (advice-add fun :around #'my/paredit-fix-transient-mark-mode))
      

  • lsp-mode   ARCHIVE
    
  • company-mode   ARCHIVE
    
  • flycheck   tools languages convenience
    

    "emacs-flycheck"
    

    (use-package flycheck
      :diminish
      :hook (prog-mode . flycheck-mode-on-safe)
      :custom
      (global-flycheck-mode t)
      (flycheck-check-syntax-automatically
       '(save new-line idle-change))
      (flycheck-display-errors-delay 10.0)
      (flycheck-checker-error-threshold 1000)
      (flycheck-textlint-config ".textlintrc")
      :config
      (add-hook 'flycheck-mode-hook
                (lambda ()
                  (if (my/ascii-string-p (buffer-string))
                      (setq flycheck-textlint-config ".textlintrc")
                    (setq flycheck-textlint-config ".config/textlint/textlintrc_ja"))))
      (add-to-list 'display-buffer-alist
                   `(,flycheck-error-message-buffer
                     . (display-buffer-reuse-window
                        display-buffer-in-previous-window
                        display-buffer-pop-up-window
                        . ((window-height . 5))))))
    

  • twittering-mode   web twitter ARCHIVE
    
  • comment-dwim-2   ARCHIVE
    
  • undo-tree   undo tree redo history files convenience ARCHIVE
    
  • quickrun   ARCHIVE
    
  • expand-region
    

    "emacs-expand-region"
    

    (use-package expand-region
      :bind (("C-,"   . er/expand-region)
             ("C-M-," . er/contract-region))
      :config
      (push 'er/mark-outside-pairs er/try-expand-list))
    

  • helpful
    

    helpful-mode displays more sources compared to help-mode, including callers, debugging information, and source code.

    "emacs-helpful"
    

    (use-package helpful
      :after help
      :bind (:map help-map
                  ("C-u a" . helpful-callable)
                  ("C-u f" . helpful-function)
                  ("C-u s" . helpful-symbol)
                  ("C-u x" . helpful-command)
                  ("C-u v" . helpful-variable)
                  ("C-u k" . helpful-key)
                  ("C-u m" . helpful-macro)))
    

  • define-word   dictionary convenience
    

    ("https://github.com/abo-abo/define-word/releases.atom" soft_update)
    

    (use-package define-word
      :ensure t
      :defer t
      :bind (:map engine-mode-prefixed-map
                  ("n" . my/define-word))
      :preface
      (defvar my/define-word-minibuffer-history nil)
      (defun my/define-word (word)
        "Invoke `define-word' with dedicated minibuffer history."
        (interactive (list (determine-search-word "Word to define: " 'my/define-word-minibuffer-history)))
        (define-word word define-word-default-service))
      :custom
      (define-word-displayfn-alist
       '((wordnik . my/define-word--display-in-buffer)
         (openthesaurus . my/define-word--display-in-buffer)
         (webster . my/define-word--display-in-buffer)))
      (define-word-default-service 'wordnik)
      :config
      (setf (cdr (assoc 'wordnik define-word-services))
            '("http://wordnik.com/words/%s" my/define-word--parse-wordnik-all))
      (push '("<b>\\(.*?\\)</b>" bold)
            define-word--tag-faces)
      ;; fix issue #31 temporally
      (defun my/define-word--fix-31 (define-word-orig &rest args)
        "Fix `define-word' backends that require a user agent (like wordnik)."
        (let ((url-request-extra-headers
               '(("User-Agent" .
                  "Mozilla/5.0 (Macintosh; Intel Mac OS X 11_5_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.63 Safari/537.36"))))
          (apply define-word-orig args)))
      (advice-add #'define-word :around #'my/define-word--fix-31))
    
    (defun my/define-word--display-in-buffer (definition)
      "docstring"
      (let* ((buf-name "*DEFINE WORD*")
             (buffer (get-buffer-create buf-name))
             (display-buffer-alist
              `((,buf-name
                 (display-buffer-same-window)))))
        (with-current-buffer buffer
          (read-only-mode -1)
          (erase-buffer)
          (insert definition)
          (goto-char (point-min))
          (save-excursion (xml-parse-string))
          (read-only-mode 1))
        (display-buffer buffer)))
    
    (defun my/define-word--parse-wordnik-example ()
      (save-excursion
        (let (beg
              results
              (define-word-limit 10))
          (re-search-forward "<h2>Examples" nil t)
          (save-excursion
            (setq beg (re-search-forward "<div class=\"relatedWords-module\">" nil t)))
          (while (re-search-forward "<p class=\"text\">\\(.*\\)</p>" beg t)
            (push "---" results)
            (push (match-string 1) results))
          (when (setq results (nreverse results))
            (define-word--convert-html-tag-to-face (define-word--join-results results))))))
    
    (defvar my/define-word-part-map-alist '(("adjective" "adj.")
                                            ("adverb" "adv.")
                                            ("intransitive verb" "v.i.")
                                            ("transitive verb" "v.t.")))
    
    
    (defun my/define-word--parse-wordnik ()
      (let ((str (define-word--parse-wordnik)))
        (with-temp-buffer
          (insert str)
          (mapc (lambda (abbrev-map)
                  (goto-char (point-min))
                  (while (re-search-forward (format "\\(%s\\)" (car abbrev-map)) nil t)
                    (let ((match (match-string 1)))
                      (replace-match
                       (propertize (cadr abbrev-map) 'face (text-properties-at (point)))))))
                my/define-word-part-map-alist)
          (buffer-string))))
    
    (defun my/define-word--parse-wordnik-related-word ()
      "docstring"
      (save-excursion
        (save-match-data
          (seq-reduce
           (lambda (accum group)
             (let (results
                   (define-word-limit 20))
               (if (re-search-forward (format "<h3>%s" group) nil t)
                   (progn (save-excursion
                            (setq beg (re-search-forward "<div class=\"related-group-header clearfix\">" nil t)))
                          (push (concat group ":") results)
                          (while (re-search-forward "<span data-definition-for=\"\\([^\"]*\\)\"" beg t)
                            (push (concat "- " (match-string 1)) results)
                            (re-search-forward "</span>"))
                          (concat (when accum (concat accum "\n\n"))
                                  (when (setq results (nreverse results))
                                    (define-word--convert-html-tag-to-face (define-word--join-results results)))))
                 accum)))
           '("antonym" "equivalents" "hypernyms" "hyponyms" "same context")
           nil))))
    
    (defun my/define-word--parse-wordnik-all ()
      ""
      (let* ((def (funcall #'my/define-word--parse-wordnik))
             (rel (funcall #'my/define-word--parse-wordnik-related-word))
             (exp (funcall #'my/define-word--parse-wordnik-example)))
        (concat ;; "Definitions:\n" (funcall #'define-word--parse-wordnik) "\n\n"
         (when def (format "Definitions:\n%s\n\n" def))
         (when rel (format "%s\n\n" rel))
         (when exp (format "Examples:\n%s\n" exp)))))
    

  • synosaurus
    

    "emacs-synosaurus"
    

    (use-package synosaurus
      :bind (:map engine-mode-prefixed-map
                  ("s" . synosaurus-lookup))
      :custom
      (synosaurus-choose-method 'default))
    

  • exec-path-from-shell   unix environment
    

    A GNU Emacs library to ensure environment variables inside Emacs look the same as in the user's shell.

    "emacs-exec-path-from-shell"
    

    (use-package exec-path-from-shell
      :config
      (when (memq window-system '(mac))
        (exec-path-from-shell-initialize)))
    

  • migemo.el
    

    migemo allows me to search incrementally Japanese words using roma-ji expression.

    ("https://github.com/emacs-jp/migemo/releases.atom" soft_update)
    

    (use-package migemo
      :ensure t
      :ensure-system-package cmigemo
      :custom
      (migemo-command "cmigemo")
      (migemo-options '("-q" "--emacs"))
      (migemo-directory
       (file-name-concat "<<migemo-dict-path()>>" "utf-8"))
      (migemo-user-dictionary nil)
      (migemo-coding-system 'utf-8-unix)
      (migemo-regex-dictionary nil)
      :config
      (migemo-init))
    

    • ivy-migemo   ARCHIVE ignore
      
  • jaword
    

    Jaword.elはbackward-wordやforward-wordを日本語に対応させる機能を提供します。これらのコマンドはデフォルトではひらがな・カタカナ・漢字の境界を単語の区切りとするのに対し、jaword.elを使用するとより正確に日本語の単語単位での移動が可能です。

    ("https://github.com/zk-phi/jaword/releases.atom" soft_update)
    

    (use-package jaword
      :ensure t
      :custom
      (jaword-enable-subword t)
      :hook ((skk-mode
              . (lambda ()
                  (jaword-mode 1)))
             (input-method-activate
              . (lambda ()
                  (when (string= current-input-method "japanese-skk")
                    (jaword-mode 1))))
             (input-method-deactivate
              . (lambda ()
                  (when (string= current-input-method "japanese-skk")
                    (jaword-mode -1))))))
    

  • hungry-delete   ARCHIVE
    
  • aggressive-indent-mode   tools maint lisp indent
    

    "emacs-aggressive-indent"
    

    (use-package aggressive-indent
      :diminish (aggressive-indent-mode . "ai")
      :hook ((emacs-lisp-mode scheme-mode) . aggressive-indent-mode))
    

  • adaptive-wrap
    

    adaptive-wrap and visual-line-mode are active in a bundle in a bunch of major modes.

    "emacs-adaptive-wrap"
    

    (use-package adaptive-wrap)
    

  • restart-emacs   convenience ARCHIVE
    
  • pangu-spacing   ARCHIVE
    
  • which-key   ARCHIVE
    
  • hydra   ARCHIVE
    
  • pass   store password password keychain
    

    Major mode for manupulating password store file.

    "emacs-pass"
    

    (use-package pass
      :commands pass
      :bind (:map pass-mode-map
                  ("C-j" . pass-view)))
    

  • password-store   tools store password password pass
    

    "emacs-password-store"
    

    (use-package password-store
      :custom
      (password-store-time-before-clipboard-restore 25))
    

  • nov.el   multimedia hypermedia epub
    

    "emacs-nov-el"
    

    (use-package nov
      :mode ("\\.epub$" . nov-mode)
      :hook (nov-mode . nov-abbreviate-file-name)
      :custom
      (nov-variable-pitch nil)
      (nov-text-width t)
      :config
      (bind-keys :map nov-mode-map
                 ("C-j" . nov-browse-url)))
    
    (defun nov-abbreviate-file-name ()
      "Shorten `nov-file-name' using `directory-abbrev-alist'."
      (setq nov-file-name (abbreviate-file-name nov-file-name)))
    

  • yasnippet   emulation convenience
    

    "emacs-yasnippet"
    "emacs-yasnippet-snippets"
    

    (use-package yasnippet
      :disabled t
      :bind (:prefix "C-c y"
                     :prefix-map my/yas-map
                     :prefix-docstring "Keymap for YASnippet family."
                     ("v" . yas-visit-snippet-file)
                     ("n" . yas-new-snippet)
                     ("i" . yas-insert-snippet)
                     ("TAB" . yas-insert-snippet))
      :hook
      ((prog-mode text-mode) . yas-minor-mode)
      (after-init . yas-reload-all)
      :custom
      (yas-triggers-in-field t)
      (yas-wrap-around-region t)
      :config
      (require 'yasnippet-snippets))
    

  • auto-yasnippet
    

    "emacs-auto-yasnippet"
    

    (use-package auto-yasnippet
      :disabled t
      :after yasnippet
      :config
      (bind-keys :map my/yas-map
                 ("a"   . aya-create)
                 ("A"   . aya-expand)
                 ("C-s" . aya-persist-snippet)))
    

  • yankpad   convenience abbrev ARCHIVE
    
  • pdf-tools   multimedia files ARCHIVE
    
  • rainbow-mode   faces
    

    "emacs-rainbow-mode"
    

    (use-package rainbow-mode
      :diminish
      (rainbow-mode . "rb")
      :hook
      ((css-mode scss-mode php-mode html-mode) . rainbow-mode)
      :custom
      (rainbow-html-colors t)
      (rainbow-x-colors t)
      (rainbow-latex-colors t)
      (rainbow-ansi-colors t))
    

  • alert   notification message emacs
    

    "emacs-alert"
    

    (use-package alert
      :config
      (set-face-background 'alert-saved-fringe-face nil)
      (alert-add-rule :status '(buried)
                      :mode   'mu4e-alert
                      :style  'fringe)
      (alert-add-rule :status '(buried)
                      :mode   'dired-mode
                      :style  'fringe)
      (alert-add-rule :status '(buried)
                      :mode   'org-mode
                      :style  'libnotify))
    

  • ts   lisp calendar
    

    "emacs-ts"
    

    (use-package ts)
    

  • app-launcher
    

    "emacs-app-launcher"
    

    (use-package app-launcher
      :after my-launch-app
      :bind (:map my/launch-app-map
                  ("a" . app-launcher-run-app)))
    

  • tldr   tools docs
    

    I ran into a problem with downloading TL;DR document. I forcibly download, uncompress and locate that to `tldr-directory-path'.

    "emacs-tldr"
    

    (use-package tldr
      :commands tldr
      :custom
      (tldr-use-word-at-point t))
    

  • burly   convenience
    

    Burly.el is capable of saving and opening Emacs frames and windows by describing them as URL which can be stored in bookmark. You can use Burly as a lightweight workspace tool.

    "emacs-burly"
    

    (require 'burly)
    

  • tempel   wp tools languages abbrev
    

    "emacs-tempel"
    ;; "emacs-tempel-collection"
    

    (use-package tempel
      :bind (("M-+" . tempel-complete) ;; Alternative tempel-expand
             ("M-_" . tempel-insert))
      :hook
      ((conf-mode prog-mode text-mode minibuffer-mode) . tempel-setup-capf)
      (mu4e-compose-mode . tempel-abbrev-mode)
      :preface
      (defun tempel-setup-capf ()
        (setq-local completion-at-point-functions
                    (cons #'tempel-expand
                          completion-at-point-functions)))
      :custom
      (tempel-path (list (no-littering-expand-etc-file-name "tempel/templates/*.eld")
                         (no-littering-expand-etc-file-name "tempel/templates/*/*.eld")))
      :config
      (bind-keys :map tempel-map
                 ("TAB" . tempel-next)
                 ("M-TAB" . tempel-previous)
                 ("C->" . tempel-next)
                 ("C-<" . tempel-previous))
      (with-eval-after-load 'cape
        (bind-keys :map my/cape-map
                   ("t" . tempel-expand))))
    
    (use-package tempel-collection
      :ensure t
      :after tempel)
    

  • literate calc mode   tools languages calc
    

    "emacs-literate-calc-mode"
    

    (use-package literate-calc-mode
      :bind ("C-c M-=" . literate-calc-mode))
    

  • git-link
    

    "emacs-git-link"
    

    (use-package git-link)
    

  • jinx
    

    "emacs-jinx"
    

    (use-package jinx
      :bind (("M-$" . jinx-correct)
             ("C-M-$" . jinx-languages))
      :config
      (bind-keys :map jinx-mode-map
                 ("M-n" . jinx-next)
                 ("M-p" . jinx-previous)))
    

  • simple-httpd
    

    "emacs-simple-httpd"
    

    (use-package simple-httpd
      :commands (httpd-start httpd-serve-directory))
    

  • logos
    

    "emacs-logos"
    

    (use-package logos
      :config
      (require 'fingertip)
      :preface
      (defun logos-toggle-read-only ()
        "Toggle read only state in `logos-focus-mode'"
        (interactive)
        (let ((current-ro-state logos-buffer-read-only))
          (logos-focus-mode -1)
          (setq logos-buffer-read-only (not current-ro-state))
          (logos-focus-mode 1)
          (unless logos-buffer-read-only
            (fingertip-mode -1))
          (message "Buffer is %s"
                   (if logos-buffer-read-only
                       "read-only" "editable"))))
      :bind (("H-;" . logos-focus-mode)
             ("H-n" . logos-narrow-dwim)
             :map logos-focus-mode-map
             ("H-e" . logos-toggle-read-only))
      :hook (((help-mode helpful-mode Info-mode eww-mode nov-mode mu4e-view-mode
                         woman-mode mastodon-mode Custom-mode devdocs-mode)
              . logos-focus-mode)
             (logos-focus-mode
              . (lambda () (if logos-focus-mode
                           (fingertip-mode 1)
                         (setq logos-buffer-read-only t)
                         (fingertip-mode -1)))))
      :custom
      (logos-scroll-lock nil)
      (logos-variable-pitch nil)
      (logos-hide-cursor nil)
      (logos-hide-mode-line t)
      (logos-hide-buffer-boundaries t)
      (logos-buffer-read-only t)
      (logos-olivetti nil)
      (logos-hide-fringe t))
    

  • editorconfig
    

    "emacs-editorconfig"
    

    (use-package editorconfig)
    

  • elisp-demos
    

    "emacs-elisp-demos"
    

    (use-package elisp-demos
      :bind (:map help-map
                  ("O" . elisp-demos-find-demo))
      :config
      (require 'helpful)
      (bind-keys :map helpful-mode-map
                 ("O" . elisp-demos-for-helpful)))
    

  • yeetube
    

    "emacs-yeetube"
    

    (use-package yeetube
      :after engine-mode
      :bind (:map engine-mode-prefixed-map
                  ("Y" . yeetube-search))
      :custom
      (yeetube-download-directory "<<media-dir()>>")
      (yeetube-default-sort-column "Date")
      (yeetube-display-thumbnails nil)
      :config
      (keymap-set yeetube-mode-map "Y"
                  (lambda () (interactive)
                    "Dwonload a video at point using `yt-dlp-dispatch-dwim'"
                    (yt-dlp-dispatch-dwim (yeetube-get-url))))
      (keymap-set yeetube-mode-map "P"
                  (lambda () (interactive)
                    "Play a video at point using `yt-dlp-dispatch-dwim'"
                    (yt-dlp-dispatch-dwim (yeetube-get-url) nil nil t)
                    (dispatch-execute-macro))))
    

  • consult-notes   wp convenience ARCHIVE
    
  • gnuplot
    

    "gnuplot"
    "emacs-gnuplot"
    

    (use-package gnuplot
      :defer t
      :mode ("\\.\\(gnuplot\\|gpt\\|plt\\|gp\\)\\'" . gnuplot-mode)
      :hook
      (gnuplot-mode . (lambda ()
                        (setq-local devdocs-current-docs '("gnuplot")))))
    

  • treesit-auto
    

    (use-package treesit-auto
      :ensure t
      :config
      (treesit-auto-add-to-auto-mode-alist 'all))
    

  • devdocs
    

    "emacs-devdocs"
    

    (use-package devdocs
      :bind (:map help-map
                  ("M-d" . devdocs-lookup)))
    

  • unfill
    

    "emacs-unfill"
    

    (use-package unfill
      :bind ("M-Q" . unfill-toggle))
    

  • htmlize
    

    "emacs-htmlize"
    

    (funcall (if (= full-path 0) #'identity #'expand-file-name)
             (file-name-concat no-littering-var-directory "htmlize"))
    

    <<htmlize-dir()>>
    

    d <<htmlize-dir(full-path=1)>> - - - 5d
    

    EWW is a nice place for intensive reading. When there are articles or documents in a format other than HTML, I convert them to HTML and browse them in EWW with my/view-htmlized.

    (use-package htmlize
      :bind ("C-!" . my/view-htmlized)
      :custom
      (Htmlize-force-inline-images t)
      :init
      (with-eval-after-load 'org-keys
        (add-to-list 'org-speed-commands
                     '("!" . my/view-htmlized)
                     t))
      :config
      (defun my/view-htmlized ()
        (interactive)
        (pcase-let* ((`(,fname . ,write-proc)
                      (if (derived-mode-p 'org-mode)
                          (cons (format "%s.html"
                                        (secure-hash 'md5 (org-id-get-create)))
                                (lambda (file)
                                  (let ((org-export-show-temporary-export-buffer nil)
                                        (org-export-preserve-breaks t)
                                        (org-export-use-babel nil))
                                    (org-html-export-as-html nil (if (org-before-first-heading-p) nil t) nil)
                                    (with-current-buffer "*Org HTML Export*"
                                      (write-file file)))))
                        (cons (format "%s.html"
                                      (secure-hash 'md5
                                                   (apply 'buffer-substring-no-properties
                                                          (if (region-active-p)
                                                              (list (region-beginning) (region-end))
                                                            (list (point-min) (point-max))))))
                              (lambda (file)
                                (let ((region-text (apply 'htmlize-region-for-paste
                                                          (if (region-active-p)
                                                              (list (region-beginning) (region-end))
                                                            (list (point-min) (point-max))))))
                                  (with-temp-buffer
                                    (insert region-text)
                                    (write-file file nil)))))))
                     (file-path (file-name-concat "<<htmlize-dir()>>" fname)))
          (when (or (not (file-exists-p file-path))
                    (derived-mode-p 'org-mode))
            (apply write-proc (list file-path)))
          (browse-url-of-file file-path))))
    

  • everywhere   frames convenience
    

    "emacs-everywhere"
    "xdotool"
    

    (use-package emacs-everywhere
      :hook (emacs-everywhere-mode
             . (lambda () (when emacs-everywhere-mode
                        (set-frame-parameter nil 'fullscreen 'fullboth)))))
    

    emacsclient -s server-<<hash-string(seed="server", len=6)>> --eval "(emacs-everywhere)"
    

  • Eat
    

    "emacs-eat"
    

    (use-package eat
      :commands (eat eat-eshell-mode)
      :hook (eshell-load . eat-eshell-mode))
    

  • japanese-holidays   calendar
    

    japanese-holidays

    (use-package japanese-holidays
      :ensure t
      :preface
      (defun my/japanese-holiday-show (&rest _args)
        "Show holiday information in mini buffer if date on which the cursor is any holidays."
        (let* ((date (calendar-cursor-to-date t))
               (calendar-date-display-form '((format "%s年 %s月 %s日（%s）" year month day dayname)))
               (date-string (calendar-date-string date))
               (holiday-list (calendar-check-holidays date)))
          (when holiday-list
            (message "%s: %s" date-string (mapconcat #'identity holiday-list "; ")))))
      :custom-face
      (japanese-holiday-saturday ((t (:foreground "blue" :background nil))))
      :custom
      (japanese-holiday-weekend '(0 6))
      (japanese-holiday-weekend-marker
       '(holiday nil nil nil nil nil japanese-holiday-saturday))
      :config
      (setf calendar-holidays
            (append japanese-holidays holiday-local-holidays holiday-other-holidays))
      (with-eval-after-load 'calendar
        (add-hook 'calendar-today-visible-hook
                  #'japanese-holiday-mark-weekend)
        (add-hook 'calendar-today-invisible-hook
                  #'japanese-holiday-mark-weekend)
        (add-hook 'calendar-move-hook
                  #'my/japanese-holiday-show)))
    

  • consult-denote
    

    "emacs-consult-denote"
    

    (use-package consult-denote
      :after (consult denote)
      :init (consult-denote-mode)
      :bind (("C-c n f" . consult-denote-find)
             ("C-c n g" . consult-denote-grep)))
    

  • capf-autosuggest
    

    capf-autosuggest provides auto-suggestion functionality in Eshell and major modes, which is derived from Comint mode. In capf-autosuggest-mode, you can use C-e to complete the entire command suggested as a placeholder, and M-f to complete a single word.

    (use-package capf-autosuggest
      :ensure t
      :hook ((eshell-mode comint-mode) . capf-autosuggest-mode))
    

  • denote-explore
    

    (use-package denote-explore
      :ensure t
      :after denote)
    

• My Emacs Packages
  
  • lfile
    

    (use-package lfile
      :after org
      :config
      (put 'lfile-locate 'org-link-abbrev-safe t))
    

  • open-file
    

    (require 'open-file)
    

  • org-password-store
    

    (use-package org-password-store
      :after org
      :bind (:map org-mode-map
                  ("C-c p c c" . my/password-store-copy)
                  ("C-c p c f" . my/password-store-copy-field)
                  ("C-c p s" . my/password-store-show-field)
                  ("C-c p w" . my/password-store-url)
                  ("C-c p l" . my/password-store-web-login)
                  ("C-c p n" . my/password-store-create)
                  ("C-c p e" . my/password-store-edit)
                  ("C-c p v" . my/password-store-edit)
                  ("C-c p k" . my/password-store-remove)))
    

  • org-english
    

    (use-package org-english
      :after org
      :config
      (bind-keys :map my/org-global-map
                 ("e e" . my/org-english-capture)
                 ("e d" . my/org-english-drill)
                 ("e r" . my/org-english-drill-resume)
                 ("e l" . my/org-english-link)
                 ("E" . my/cloze-deletion-replace)
                 ("e q" . my/org-english-search)
                 :map engine-mode-prefixed-map
                 ("j" . (lambda (word)
                          "Copy Japanese translation as well as the pronunciation to `kill-ring'."
                          (interactive (list (determine-search-word)))
                          (kill-new (message "%s %s"
                                             (my/english-japanese-translate word t)
                                             (my/english-pronunciation word t))))))
      (with-eval-after-load 'denote-org-extras
        (setq my/org-english-file (denote-get-path-by-id "20230605T170959"))))