Emacs Configuration

Language Servers

(use-package lsp-mode
  :commands (lsp lsp-deferred)
  :init
  (setq lsp-keymap-prefix "C-c l")
  :config
  (lsp-enable-which-key-integration t))

JavaScript/TypeScript

(add-hook 'javascript-mode-hook #'lsp-deferred)

(use-package typescript-mode
  :mode "\\.tsx?\\'" ;; .ts and .tsx files are typescript
  :hook (typescript-mode . lsp-deferred)
  :config
  (setq typescript-indent-level 2))

YAML

(use-package yaml-mode)

Gherkin

(use-package feature-mode)

Python

(use-package lsp-pyright
  :ensure t
  :hook (python-mode . (lambda ()
                         (require 'lsp-pyright)
                         (lsp-deferred))))

(use-package company)

SQL

(use-package lsp-mssql)

GLSL

(use-package glsl-mode)

• NEXT Add GLSL file types to the mode definition
  

Guile Scheme

(use-package geiser)

HTTP Daemon

(use-package simple-httpd
  :ensure t)

Bindings

Auto-tangle this config file

(defun my/org-babel-tangle-config ()
(when (string-equal (buffer-file-name)
                    (expand-file-name "~/.emacs.d/config.org")) ; This file
  (let ((org-confirm-babel-evaluate nil))
    (org-babel-tangle))))

(add-hook 'org-mode-hook (lambda () (add-hook 'after-save-hook #'my/org-babel-tangle-config)))

Main config

(use-package org-roam
  :ensure t
  :demand t  ;; Ensure org-roam is loaded by default
  :init
  (setq org-roam-v2-ack t)
  :custom
  (org-roam-directory (concat my/org-file-path "roam"))
  (org-roam-completion-everywhere t)
  :bind (("C-c n l" . org-roam-buffer-toggle)
         ("C-c n o" . org-roam-node-find)
         ("C-c n f" . org-roam-refile)
         ("C-c n i" . org-roam-node-insert)
         ("C-c n I" . org-roam-node-insert-immediate)
         ("C-c n p" . my/org-roam-find-active-project)
         ("C-c n a" . my/org-roam-find-area)
         ("C-c n r" . my/org-roam-find-resource)
         ("C-c n t" . my/org-roam-capture-task)
         ("C-c n e" . my/org-roam-find-rpg)
         ("C-c n b" . my/org-roam-capture-inbox)
         ("C-c n R" . org-roam-node-random)
         ("C-c n T a" . org-roam-tag-add)
         ("C-c n T r" . org-roam-tag-remove)
         ("C-c n A a" . org-roam-alias-add)
         ("C-c n A r" . org-roam-alias-remove)
         ("C-c n s" . org-roam-db-sync)
         :map org-mode-map
         ("C-M-i" . completion-at-point)
         :map org-roam-dailies-map
         ("Y" . org-roam-dailies-capture-yesterday)
         ("T" . org-roam-dailies-capture-tomorrow))
  :bind-keymap
  ("C-c n d" . org-roam-dailies-map)
  :config
  (require 'org-roam-dailies) ;; Ensure the keymap is available
  (setq org-roam-db-autosync-mode t))

Templates

(setq my/org-roam-project-template "* Purpose and Principles\n/You cannot know what a project should look like or how to create it if you don't understand *why* you're doing it. This includes both its 'purpose' - why this project needs to be produced - and you 'principles' - the standards and values you hold that impact how and what you produce/.\n\n** Purpose\n\n** Principles\n\n* Outcome Visioning\n/What will it be like when this project is out in the world? It's much easier to see how to do something once it's already done. So, envision your completion of the project so that you know what it might take to get there/.\n\n** What will the end ideally look like?\n\n** How will I ideally feel after completing this?\n\n** How will others ideally respond?\n\n** What else will result from the completion of this project?\n\n* Brainstorm\n/Write down *every* idea that occurs to you so that you don't have to hold *any* ideas in your head. Do not judge the ideas, aim for quantity not quality. Resist the urge to organize or analyze for now/.\n\n* Tasks\n/Look through the brainstorm output, and decide what bite-sized, well defined tasks can be started *now*. Then work on them/!\n\n** PLAN ${title}"
      my/org-roam-area-template "* Goals\n\n%?\n\n* Tasks\n\n** NEXT Add initial tasks\n\n* Dates\n\n"
      my/org-roam-biblio-template "* Source\n\nAuthor: %^{Author}\nTitle: ${title}\nYear: %^{Year}\n\n* Summary\n\n%?\n\n* Notes\n\n"
      my/org-roam-daily-template "#+title: %<%Y-%m-%d>\n#+filetags: Daily\n\n* High Impact Tasks\n** TODO\n** TODO\n** TODO\n* Day in Review\n** Today's Wins\n- \n* Notes")

(setq org-roam-capture-templates
      `(("d" "default" plain
         "%?"
         :if-new (file+head
                  "%<%Y%m%d%H%M%S>-${slug}.org" "#+title: ${title}\n\n")
         :unnarrowed t)

        ("p" "project" plain
         ,my/org-roam-project-template
         :if-new (file+head
                  "%<%Y%m%d%H%M%S>-${slug}.org" "#+title: ${title}\n#+category: ${title}\n#+filetags: Project\n\n")
         :unnarrowed t)

        ("a" "area" plain
         ,my/org-roam-area-template
         :if-new (file+head
                  "%<%Y%m%d%H%M%S>-${slug}.org" "#+title: ${title}\n#+category: ${title}\n#+filetags: Area\n\n")
         :unnarrowed t)

        ("b" "bibliography" plain
         ,my/org-roam-biblio-template
         :if-new (file+head
                  "%<%Y%m%d%H%M%S>-biblio-${slug}.org" "#+title: ${title}\n#+filetags: Biblio\n\n")
         :unnarrowed t)))

(setq org-roam-dailies-capture-templates
      `(("d" "default" entry
         "** %<%H:%M>: %?"
         :if-new (file+head+olp
                  "%<%Y-%m-%d>.org" ,my/org-roam-daily-template ("Notes")))))

(load "~/.emacs.d/templates.el")

Support Functions

• Filtering
  

  There's a couple of filter modes I had to custom define to be able to implement PARA how I wanted to.

  Create a filtering lambda which accepts all nodes tagged with tag-name, a string.

  (defun my/org-roam-filter-by-tag (tag-name)
      "Takes TAG-NAME, a string, and creates a lambda which return t iff a provided org-roam node is tagged with TAG-NAME."
      (lambda (node)
        (member tag-name (org-roam-node-tags node))))
  
  

  Using that filtering lambda, create a list of all nodes with a provided tag.

  (defun my/org-roam-list-notes-by-tag (tag-name)
    "Create and return a list of all org-roam nodes which have TAG-NAME as one of their tags."
    (mapcar #'org-roam-node-file
            (seq-filter
             (my/org-roam-filter-by-tag tag-name)
             (org-roam-node-list))))
  
  (defun my/org-roam-list-notes-by-tags-exclude-archive (taglist)
    "Returns a list of all org-roam nodes which are tagged with TAGLIST and not tagged with 'Archive'"
    (mapcar #'org-roam-node-file
            (seq-filter
             (my/org-roam-filter-by-tags-exclude-archive taglist)
             (org-roam-node-list))))
  
  

  Create a filter lambda which accepts all nodes tagged with any element of taglist, a list of strings.

  (defun my/org-roam-filter-by-tags (taglist)
    "Create a lambda which returns t iff any string in TAGLIST is a tag on a provided org-roam node."
    (lambda (node)
      (setq check nil)
      (dolist (tag taglist)
        (if (member tag (org-roam-node-tags node))
            (setq check t)))
      check))
  
  

  Create a filtering lambda which accepts all nodes that are not tagged with any member of taglist, a list of strings.

  (defun my/org-roam-filter-by-tags-exclusive (taglist)
    "Create a filtering lambda which returns nil iff the provided roam node is tagged with any member of taglist, and returns t otherwise"
    (lambda (node)
      (setq check t)
      (dolist (tag taglist)
        (if (member tag (org-roam-node-tags node)) (setq check nil)))
      check))
  
  

  Create a filtering lambda which accepts all nodes which are tagged with any element of taglist, and are not tagged with "Archive".

  (defun my/org-roam-filter-by-tags-exclude-archive (taglist)
    "Does the same thing as my/org-roam-filter-by-tags, but will always return nil if \"Archive\" is a member of the node's tags."
    (lambda (node)
      (setq check nil)
      (dolist (tag taglist)
        (if (and (member tag (org-roam-node-tags node)) (not (member "Archive" (org-roam-node-tags node))))
            (setq check t)))
      check))
  
  

• Node Link Insertion
  

  This initially seemed like a great idea, enabling something similar to Obsidian's \[\[link-to-an-unreal-note]] syntax. Since realizing a zettelkasten is not a wiki though it seems much less useful - How can I link to a proper note of my own thought that I haven't recorded yet? I think it is usually better to capture that thought as an inbox entry and a link to the note which prompted it. I am considering removing this function.

  (defun org-roam-node-insert-immediate (arg &rest args)
    "Insert a link to an org-roam node. If the node does not exist, create it but do not prompt for a template or contents."
    (interactive "P")
    (let ((args (push arg args))
          (org-roam-capture-templates (list (append (car org-roam-capture-templates)
                                                    '(:immediate-finish t)))))
      (apply #'org-roam-node-insert args)))
  
  

• Org Agenda management
  

  I used to dynamically generate the agenda files list from tagged roam nodes, but I have since changed to a single dedicated file.

  (setq org-agenda-files `(,(concat org-roam-directory "/000-Agenda.org")))
  
  

• Node Searching
  

  Searching for org-roam nodes is a little bit of a fiddly task, because I want to be able to search in heavily filtered ways, and have specific capture templates for each kind of filtered search I do.

  First of all, there is a hook to rebuild the agenda files list after a roam capture, to ensure the agenda is always up to date with newly created projects.

  (defun my/org-roam-project-finalize-hook ()
    "Refreshes `org-agenda-files' to ensure the captured node is added if the capture was not aborted."
    ;; When this hook is invoked, remove it from the hookpoint
    (remove-hook 'org-capture-after-finalize-hook #'my/org-roam-project-finalize-hook)
    (unless org-note-abort
      (my/org-roam-refresh-agenda-list)))
  
  (defun my/org-roam-refresh-agenda-list ()
    "Does nothing. Used to ensure a new project file was added to the agenda list.")
  
  

  Search for all nodes tagged with Project not tagged with Archive. If the selected node doesn't exist, capture a new node with only one available template - my project template.

  (defun my/org-roam-find-active-project ()
    "Find or create a node by title which has the tag \"Project\" and does not have the tag \"Archive\". If the target node does not exist, the creation process is identical to `my/org-roam-find-all-projects'."
    (interactive)
    (add-hook 'org-capture-after-finalize-hook #'my/org-roam-project-finalize-hook)
    (org-roam-node-find
     nil
     nil
     (my/org-roam-filter-by-tags-exclude-archive '("Project"))
     nil
     :templates `(("p" "project" plain
                   ,my/org-roam-project-template
                   :if-new (file+head
                            "%<%Y%m%d%H%M%S>-${slug}.org"
                            "#+title: ${title}\n#+category: ${title}\n#+filetags: Project\n\n")
                   :unnarrowed t))))
  
  

  Filtering out archived projects was a refinement of this original function as I finished setting up a PARA-ish roam graph, but I decided to keep the option to search among all projects including the archive.

  (defun my/org-roam-find-all-projects ()
    "Find or create an org node by title which has the tag \"Project\"."
    (interactive)
    (add-hook 'org-capture-after-finalize-hook #'my/org-roam-project-finalize-hook)
    (org-roam-node-find
     nil
     nil
     (my/org-roam-filter-by-tag "Project")
     nil
     :templates `(("p" "project" plain
                   ,my/org-roam-project-template
                   :if-new (file+head
                            "%<%Y%m%d%H%M%S>-${slug}.org"
                            "#+title: ${title}\n#+category: ${title}\n#+filetags: Project\n\n")
                   :unnarrowed t))))
  
  

  And after all, why not see only what's archived? So here's that search function.

  (defun my/org-roam-find-archive ()
    "Find or create an org node by title which has the tag \"Archive\"."
    (interactive)
    (add-hook 'org-capture-after-finalize-hook #'my/org-roam-project-finalize-hook)
    (org-roam-node-find
     nil
     nil
     (my/org-roam-filter-by-tag "Archive")
     nil)) ;; No template override is given, so defaults are used.
  
  

  Search for all roam nodes which are tagged Area.

  (defun my/org-roam-find-area ()
    "Find or create an org node by title which has the tag \"Area\"."
    (interactive)
    (add-hook 'org-capture-after-finalize-hook #'my/org-roam-project-finalize-hook)
    (org-roam-node-find
     nil
     nil
     (my/org-roam-filter-by-tags-exclude-archive '("Area"))
     nil
     :templates `(("a" "area" plain
                   ,my/org-roam-area-template
                   :if-new (file+head
                            "%<%Y%m%d%H%M%S>-${slug}.org"
                            "#+title: ${title}\n#+category: ${title}\n#+filetags: Area\n")
                   :unnarrowed t))))
  
  

  And finally the laziest part of my PARA implementation. Anything which is not a Project or Area (or the Inbox) must be a resource, archived or not.

  (defun my/org-roam-find-resource ()
    "Find an org node by title which is not tagged with \"Project\", \"Area\", or \"Inbox\", or \"Daily\"."
    (interactive)
    (org-roam-node-find
     nil nil
     (my/org-roam-filter-by-tags-exclusive '("Project" "Area" "Inbox" "Daily"))
     nil)) ;; Don't override default templates if creating a new file
  
  

  • TTRPG specific
    

    RPG resources are important for me to be able to find, so I'm adding an explicit section to find it in my PARA setup.

    (defun my/org-roam-find-rpg ()
      "Find an org node by title which is tagged with \"ttrpg\""
      (interactive)
      (org-roam-node-find
       nil nil
       (my/org-roam-filter-by-tag "ttrpg") nil)) ;; Don't override default templates
    
    

• Capturing
  

  (defun my/org-roam-capture-inbox ()
    "Capture a bullet into the Inbox.org file."
    (interactive)
    (org-roam-capture- :node (org-roam-node-create)
                       :templates '(("i" "default" plain
                                     "* %?"
                                     :if-new (file+head
                                              "Inbox.org" "#+title: Inbox\n")))))
  
  

  I need to rewrite capture-task in order to direct the captures into the Agenda File on new projects and areas.

  (defun my/org-roam-capture-task ()
    (interactive)
    ;; Ensure that the project or area node is included in the org agenda after the capture is saved
    (add-hook 'org-capture-after-finalize-hook #'my/org-roam-project-finalize-hook)
  
    ;; Capture the new task, creating the project file if necessary
    (org-roam-capture- :node (org-roam-node-read
                              nil
                              (my/org-roam-filter-by-tags-exclude-archive '("Area" "Project")))
                       :templates '(("p" "project" plain
                                     "** TODO %?"
                                     :if-new (file+head+olp
                                              "%<%Y%m%d%H%M%S>-${slug}.org"
                                              "#+title: ${title}\n#+category: ${title}\n#+filetags: Project\n\n"
                                              ("Tasks")))
  
                                    ("a" "area" plain
                                     "** TODO %?"
                                     :if-new (file+head+olp
                                              "%<%Y%m%d%H%M%S>-${slug}.org"
                                              "#+title: ${title}\n#+category: ${title}\n#+filetags: Area\n"
                                              ("Tasks"))))))
  
  (defun my/org-roam-capture-event ()
    (interactive)
    (org-roam-capture- :node (org-roam-node-read
                              nil
                              (my/org-roam-filter-by-tags-exclude-archive '("Area" "Project")))
                       :templates '(("e" "event" plain
                                     "** %?\n%U\n%^T"
                                     :if-new (file+head+olp
                                              "%<%Y%m%d%H%M%S>-${slug}.org"
                                              "#+title: ${title}\n#+category: ${title}"
                                              ("Dates"))))))
  
  

Org Roam UI

(use-package org-roam-ui
  :after org-roam
  :bind (("C-c n u" . org-roam-ui-open))
  :config
  (setq org-roam-ui-sync-theme t
        org-roam-ui-follow t
        org-roam-ui-update-on-save t
        org-roam-ui-open-on-start t))