Emacs Ecosystem

---

name: Emacs Ecosystem description: This skill should be used when the user asks to "write elisp", "emacs config", "init.el", "use-package", ".el file", "emacs lisp", or "magit". Provides comprehensive Emacs ecosystem patterns and best practices. For org-mode, use org-ecosystem skill.

<elisp_fundamentals> S-expressions as code and data (homoiconicity). Prefix notation for all operations.

;; cons_cell: Pair (cons 1 2) ; => (1 . 2)

;; list: Linked cons cells '(1 2 3)

;; vector: Fixed-size array [1 2 3]

;; hash-table: Key-value store (make-hash-table)

;; string: Text "hello"

;; number: Integer or float 42 3.14

(let* ((x 1) (y (+ x 1))) ; y can reference x y)

(when condition body-forms...)

(unless condition body-forms...)

(cond (condition1 result1) (condition2 result2) (t default-result))

(pcase value ('symbol (handle-symbol)) ((pred stringp) (handle-string)) (_ (handle-default)))

(dotimes (i 10) (process i))

(cl-loop for item in list collect (transform item))

(seq-map #'transform sequence) (seq-filter #'predicate sequence) (seq-reduce #'fn sequence initial)

(mapcar (lambda (x) (* x 2)) '(1 2 3))

;; Short form (Emacs 28+) (mapcar (lambda (x) (+ x 1)) list)

<configuration_patterns> Modern init.el organization ;;; init.el --- Emacs configuration -*- lexical-binding: t; -_-

;;; Commentary: ;; Personal Emacs configuration

;;; Code:

;; Bootstrap package manager (require 'package) (setq package-archives '(("melpa" . "https://melpa.org/packages/") ("gnu" . "https://elpa.gnu.org/packages/") ("nongnu" . "https://elpa.nongnu.org/nongnu/"))) (package-initialize)

;; Install use-package if not present (unless (package-installed-p 'use-package) (package-refresh-contents) (package-install 'use-package))

(eval-when-compile (require 'use-package))

;; Configuration sections...

(provide 'init) ;;; init.el ends here

;; Mode-specific (define-key emacs-lisp-mode-map (kbd "C-c C-e") #'eval-last-sexp)

;; With use-package (use-package magit :bind (("C-x g" . magit-status) ("C-x M-g" . magit-dispatch)))

;; Keymap definition (defvar my-prefix-map (make-sparse-keymap) "Keymap for my custom commands.") (global-set-key (kbd "C-c m") my-prefix-map) (define-key my-prefix-map (kbd "f") #'find-file)

;; Remove function from hook (remove-hook 'prog-mode-hook #'display-line-numbers-mode)

;; Lambda in hook (discouraged for removability) (add-hook 'after-save-hook (lambda () (message "Saved!")))

;; With use-package (use-package flycheck :hook (prog-mode . flycheck-mode))

(advice-add 'save-buffer :around #'my-after-save-message)

;; Remove advice (advice-remove 'save-buffer #'my-after-save-message)

(defcustom my-package-option t "Enable my-package option." :type 'boolean :group 'my-package)

(defcustom my-package-list '("a" "b") "List of strings." :type '(repeat string) :group 'my-package) </configuration_patterns>

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

;; Install a package (package-install 'magit)

;; Use with use-package (straight-use-package 'use-package) (setq straight-use-package-by-default t)

;; Install package (use-package magit :straight t)

;; Use with use-package (elpaca elpaca-use-package (elpaca-use-package-mode))

(use-package magit :ensure t)

<lsp_integration> <decision_tree name="when_to_use"> Do you need LSP features like completion, go-to-definition, and diagnostics? <if_yes>Use eglot for built-in simplicity or lsp-mode for rich features</if_yes> <if_no>Use basic major modes without LSP overhead</if_no> </decision_tree>

;; Custom server configuration (add-to-list 'eglot-server-programs '(rust-mode . ("rust-analyzer")))

(use-package lsp-ui :ensure t :hook (lsp-mode . lsp-ui-mode) :custom (lsp-ui-doc-enable t) (lsp-ui-sideline-enable t))

;; With company (traditional) (use-package company :ensure t :hook (after-init . global-company-mode) :custom (company-idle-delay 0.2)) </lsp_integration>

<modern_packages> Vertical completion UI with orderless, marginalia, and consult (use-package vertico :ensure t :init (vertico-mode))

(use-package orderless :ensure t :custom (completion-styles '(orderless basic)))

(use-package marginalia :ensure t :init (marginalia-mode))

(use-package consult :ensure t :bind (("C-s" . consult-line) ("C-x b" . consult-buffer) ("M-g g" . consult-goto-line)))

;; Install grammars (mapc #'treesit-install-language-grammar (mapcar #'car treesit-language-source-alist))

;; Remap modes (setq major-mode-remap-alist '((python-mode . python-ts-mode) (javascript-mode . js-ts-mode))) </modern_packages>

<context7_integration>

<usage_pattern> Resolve library ID (known: /websites/emacsdocs) Fetch documentation with specific topic Emacs Lisp programming patterns Package configuration patterns Org mode configuration Magit usage and configuration Hook usage patterns </usage_pattern>

<common_queries> Key binding patterns Function definition Advice system usage Customization variables </common_queries> </context7_integration>

<best_practices> Enable lexical-binding in all Elisp files: -*- lexical-binding: t; -_- Use #'function-name for function references (enables byte-compiler warnings) Document functions with docstrings Namespace all symbols with package prefix Prefer seq.el functions for sequence operations Use pcase for complex pattern matching Use defcustom for user-configurable options Use provide at end of file Prefer :custom over setq in use-package Use :hook instead of add-hook in use-package Lazy load packages with :defer, :commands, or :hook Use native-compilation when available (Emacs 28+) Prefer eglot for LSP (built-in, simpler) Use tree-sitter modes when available (Emacs 29+) </best_practices>

<anti_patterns> Using dynamic binding when lexical is needed Add lexical-binding: t to file header

<related_agents> Architecture analysis for elisp package structure Docstring and commentary generation Elisp implementation and configuration tasks Debugging elisp errors and hook issues </related_agents>

<related_skills> Org-mode document creation, GTD workflow, Babel, export patterns Symbol operations for elisp code navigation Emacs documentation lookup via /websites/emacsdocs Debugging package conflicts and performance issues Creating package documentation and README files </related_skills>

<error_escalation> Byte-compilation warning Fix warning, ensure clean compilation Configuration error on startup Debug with --debug-init, fix issue Package conflict or version mismatch Stop, present resolution options to user Emacs becomes unusable Provide recovery steps, require user action </error_escalation>