Emacs.txt

;;; -*- mode: org; -*-
#+TITLE: Emacs Configuration
#+DESCRIPTION: my emacs configuration
#+AUTHOR: Dan Pomohaci
#+EMAIL: dan.pomohaci@gmail.com
#+STARTUP: overview indent align inlineimages

* Features Oriented Config
** Description

The configuration file is the way to customize emacs

Emacs is an extremely complex application and that's why configuring it is very complicated. Although originally it was just an editor, now it is a working platform and can do almost anything you need on a daily basis. The big advantage of emacs is its extensibility. The problem is that as there are hundreds of emacs packages many with similar functionality and the configuration file becomes very cluttered and hard to maintain.

There are 2 ways of configuration:
1. to use a ready configured distribution (spacemacs, doom, rational emacs, etc)
2. make your own configuration

After many years of trying with the first method I came to the conclusion that the only viable solution is to do your own configuration.

And with this method I have had several attempts and the solution that seems to me the most viable is the one based on literate programming using org file

This version use nix program manager.

** Subfeatures

1. [X] (foc1) reproductibilitate si usurinta in instalare
2. [X] (foc2) usor de localizat informatia necesara
3. [X] (foc3) cod cat mai mic, promovează pachetele built-in
4. [X] (foc4) pot rula simultan mai multe configuratii de emacs

** Implementation

*** early-init.el
:PROPERTIES:
  :header-args: :tangle modules/home/emacs/early-init.el
:END:

- header:
  #+begin_src emacs-lisp
;; early-init.el --- Early Initialisation -*- lexical-binding: t -*-

;;; Commentary:

;;; Code:

  #+end_src
- Provide an easy way to toggle debug mode which will set certain variables to produce more informative output. It can be set either by providing the environment variable =DEBUG= or start Emacs with =--debug-init=:
  #+begin_src emacs-lisp
(when (getenv "DEBUG") (setq init-file-debug t))
(setq debug-on-error (and (not noninteractive) init-file-debug))
  #+end_src
- Time the startup and display the startup time after completed.
  #+begin_src emacs-lisp
(add-hook 'emacs-startup-hook
          (lambda ()
            (message "Loaded Emacs in %.03fs"
                     (float-time (time-subtract after-init-time before-init-time)))))
  #+end_src
- Temporarily reduce garbage collection to gain some performance boost during startup:
  #+begin_src emacs-lisp
(let ((normal-gc-cons-threshold gc-cons-threshold)
      (normal-gc-cons-percentage gc-cons-percentage)
      (normal-file-name-handler-alist file-name-handler-alist)
      (init-gc-cons-threshold most-positive-fixnum)
      (init-gc-cons-percentage 0.6))
  (setq gc-cons-threshold init-gc-cons-threshold
        gc-cons-percentage init-gc-cons-percentage
        file-name-handler-alist nil)
  (add-hook 'after-init-hook
            `(lambda ()
               (setq gc-cons-threshold ,normal-gc-cons-threshold
                     gc-cons-percentage ,normal-gc-cons-percentage
                     file-name-handler-alist ',normal-file-name-handler-alist))))
  #+end_src
- Inhibit startup screen and messages:
  #+begin_src emacs-lisp
(setq inhibit-startup-echo-area-message t)
(setq inhibit-startup-screen t)
(setq initial-scratch-message nil)
  #+end_src
- Performance tweaks.  Don't load default library and use =fundamental-mode= to reduce amount
of hooks.
  #+begin_src emacs-lisp
(setq inhibit-default-init t)
(setq initial-major-mode 'fundamental-mode)
  #+end_src
- Disable =package.el= support. Packages are managed via Nix and disabling this gives a slight performance boost.
  #+begin_src emacs-lisp
(setq package-enable-at-startup nil)
  #+end_src
- Disable GUI components.
  #+begin_src emacs-lisp
(setq use-dialog-box nil)
(push '(undecorated . t) default-frame-alist)
(push '(menu-bar-lines . 0) default-frame-alist)
(push '(tool-bar-lines . 0) default-frame-alist)
(push '(vertical-scroll-bars) default-frame-alist)
  #+end_src
- Don't implicitly resize frames when changing various settings:
  #+begin_src emacs-lisp
(setq frame-inhibit-implied-resize t)
(defvar global-text-scale-adjust-resizes-frames t)
  #+end_src
- Allow resizing by dragging internal border:
  #+begin_src emacs-lisp
(push '(drag-internal-border . t) default-frame-alist)
  #+end_src
- Ignore X resources:
  #+begin_src emacs-lisp
(advice-add #'x-apply-session-resources :override #'ignore)
  #+end_src
- compile cache:
  #+begin_src emacs-lisp
(unless (eq system-type 'darwin)
  (startup-redirect-eln-cache (expand-file-name "~/.cache/emacs/eln/")))
  #+end_src
*** init.el
:PROPERTIES:
  :header-args: :tangle modules/home/emacs/init.el
:END:

#+begin_src emacs-lisp
;; init.el --- user init file  -*- lexical-binding: t -*-

;;; Commentary:

;;; Code:

#+end_src

**** directories



- Add the folder of custom elisp files to load-path
  #+begin_src emacs-lisp
(add-to-list 'load-path (expand-file-name "elisp" user-emacs-directory))
#+end_src
- Provide a location where Emacs can store data and cache. I follow the [[https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html][XDG base directory specification]].
#+begin_src emacs-lisp
(defvar xdg-bin (or (getenv "XDG_BIN_HOME") "~/.local/bin/")
  "The XDG bin base directory.")
(defvar xdg-cache (or (getenv "XDG_CACHE_HOME") "~/.cache/")
  "The XDG cache base directory.")
(defvar emacs-cache-dir (expand-file-name "emacs/" xdg-cache)
  "The emacs cache directory")
(defvar xdg-config (or (getenv "XDG_CONFIG_HOME") "~/.config/")
  "The XDG config base directory.")
(defvar xdg-data (or (getenv "XDG_DATA_HOME") "~/.local/share/")
  "The XDG data base directory.")
(defvar xdg-lib (or (getenv "XDG_LIB_HOME") "~/.local/lib/")
  "The XDG lib base directory.")
#+end_src
- Unifying Emacs' cache in a single, stable location
  #+begin_src emacs-lisp
(defvar emacs-cache-dir (expand-file-name "emacs/" xdg-cache)
  "Path to the Emacs cache directory.")

;; Create the directory if it does not exist
(unless (file-exists-p emacs-cache-dir)
  (make-directory emacs-cache-dir t))
  #+end_src

**** use-package
A macro for package customization, see  [[info:use-package#Top][use-package]] for further details.

#+begin_src emacs-lisp
(require 'package)

(add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/") t)
(add-to-list 'package-archives '("elpa"  . "https://elpa.gnu.org/packages/") t)

(package-initialize)

;; Instaleaza use-package dacă lipsește
(unless (package-installed-p 'use-package)
  (package-refresh-contents)
  (package-install 'use-package))

(require 'use-package)

(setq use-package-always-ensure t
      package-install-upgrade-built-in t)

;; Forțează încărcarea versiunii noi de Org înainte ca restul fișierului să o declanșeze pe cea veche
(use-package org
  :ensure t
  :demand t)
#+end_src

**** helpers

- Prevent forms from producing output or other noise.
  #+begin_src emacs-lisp
(defmacro quiet! (&rest forms)
  "Run FORMS without making any noise."
  `(if init-file-debug
       (progn ,@forms)
     (let ((message-log-max nil))
       (with-temp-message (or (current-message) "") ,@forms))))

(defun quiet-function-advice (orig-fn &rest args)
  "Advice used to make a function quiet.
Call ORIG-FN with ARGS and suppress the output.  Usage:

  (advice-add \\='orig-fn :around #\\='quiet-function-advice)"
  (quiet! (apply orig-fn args)))
  #+end_src

- Easily define REPL functions.
  #+begin_src emacs-lisp
(defmacro define-repl (fn-name buffer-name command &rest args)
  "Define a REPL function named FN-NAME running COMMAND inside BUFFER-NAME."
  (let ((repl-buffer (concat "*" buffer-name "*")))
    `(defun ,fn-name ()
       ,(format "Run an inferior instance of %s inside Emacs." command)
       (interactive)
       (let ((buffer (get-buffer-create ,repl-buffer)))
         (unless (comint-check-proc ,repl-buffer)
           (apply 'make-comint-in-buffer ,buffer-name buffer ,command nil ,args))
         (pop-to-buffer buffer)))))
  #+end_src

- Get secret
  #+begin_src emacs-lisp
(defun local/get-secret (key)
  (with-temp-buffer
    (insert-file-contents (expand-file-name key "~/.config/sops-nix/secrets/"))
    (string-trim (buffer-string))))
  #+end_src

**** Data

#+begin_src emacs-lisp
(use-package exec-path-from-shell
  :ensure t
  :demand t
  :config
  (customize-set-variable 'exec-path-from-shell-variables
                        '("PATH" "MANPATH" "DPOM_CONFIG"
                          "LANG" "LC_ALL" "SSH_AUTH_SOCK"
                          "XDG_BIN_HOME"  "XDG_CACHE_HOME"
                          "XDG_CONFIG_HOME" "XDG_DATA_HOME"
                          "XDG_LIB_HOME"))
  (customize-set-variable 'exec-path-from-shell-check-startup-files nil)
  (when (memq window-system '(mac ns x pgtk))
    (exec-path-from-shell-initialize)
    (exec-path-from-shell-copy-envs '("SSH_AUTH_SOCK" "GPG_AGENT_INFO"))))

#+end_src

**** Customization

Put custom definitions in a temporary file so it doesn't grow over time. This means all customization will disappear upon reboot and instead needs to be managed via the initialization file.

#+begin_src emacs-lisp
(setq custom-file (expand-file-name "custom.el" temporary-file-directory))
#+end_src

**** no-littering

Help keeping ~user-emacs-directory~ clean.

#+begin_src emacs-lisp :tangle no
(use-package no-littering
  :ensure t
  :demand t
  :init
  (setq no-littering-etc-directory xdg-data)
  (setq no-littering-var-directory xdg-cache))
#+end_src

**** Performance

No second pass of case-insensitive search over =auto-mode-alist=.
#+begin_src emacs-lisp
(setq auto-mode-case-fold nil)
#+end_src

Give up some bidirectional functionality for slightly faster re-display.
#+begin_src emacs-lisp
(setq bidi-inhibit-bpa t)
(setq-default bidi-display-reordering 'left-to-right
              bidi-paragraph-direction 'left-to-right)
#+end_src

Defer processing font faces while scrolling and typing.
#+begin_src emacs-lisp
(setq fast-but-imprecise-scrolling t)
(setq jit-lock-defer-time 0)
#+end_src

**** gcmh

Adjust Garbage Collector threshold depending on activity and try to run garbage collection
during idle instead.
#+begin_src emacs-lisp
(use-package gcmh
  :ensure t
  :demand t
  :init
  (setq gcmh-idle-delay 5)
  (setq gcmh-high-cons-threshold (* 16 1024 1024)) ; 16MB
  (setq gcmh-verbose init-file-debug)
  :config
  (gcmh-mode))
#+end_src

**** explain-pause-mode

Track how much time is spent in each function and present a view to investigate this data.
#+begin_src emacs-lisp :tangle no
(use-package explain-pause-mode
  :ensure t
  :commands
  (explain-pause-mode)
  :init
  (when init-file-debug
    (explain-pause-mode 1)))
#+end_src

**** vlf

Large file support. This can view/edit/search and compare large files.
#+begin_src emacs-lisp :tangle no
(use-package vlf :ensure t)
#+end_src

**** Local Config


  #+begin_src emacs-lisp
(defgroup local nil
  "Local defined variables and functions."
  :tag "Local"
  :group 'config)

(defcustom local/pers-dir "~/pers/"
  "Personal directory."
  :type '(directory)
  :group 'local)

(defcustom local/work-dir "~/work/"
  "Work related directory."
  :type '(directory)
  :group 'local)

(defcustom local/admin-dir "~/.dotfiles/"
  "Directory of the system configurations."
  :type '(directory)
  :group 'local)

(defcustom local/plan-dir (file-name-as-directory (expand-file-name "plan" local/pers-dir))
  "Plan directory."
  :type '(directory)
  :group 'local)

(defcustom local/notes-dir (file-name-as-directory (expand-file-name "notes" local/pers-dir))
  "Org-roam notes directory."
  :type '(directory)
  :group 'local)

(defcustom local/backlog-file (expand-file-name "Backlog.org" local/plan-dir)
  "Backlog tasks and notes file."
  :type '(file)
  :group 'local)

(defcustom local/config-file (expand-file-name "Emacs.txt" local/admin-dir)
  "Emacs config file."
  :type '(file)
  :group 'local)

(defcustom local/private-dir (file-name-as-directory (local/get-secret "private_dir"))
  "Private info directory."
  :type '(directory)
  :group 'local)

(defcustom local/accounts-file (expand-file-name "Cont.gpg" local/private-dir)
  "Personal accounts file."
  :type '(file)
  :group 'local)

(defcustom local/contacts-file (expand-file-name "contacts.org" local/private-dir)
  "Contacts file."
  :type '(file)
  :group 'local)

(defcustom local/resources-dir (file-name-as-directory (expand-file-name "resources" local/notes-dir))
  "Notes resources directory."
  :type '(directory)
  :group 'local)

(defcustom local/bibliography-file (expand-file-name "dpom.bib" local/resources-dir)
  "Bibliography file."
  :type '(file)
  :group 'local)

(defcustom local/bibliography-library-path (list local/resources-dir)
  "Bibliography library directory."
  :type '(list directory)
  :group 'local)

(let ((personal-settings (expand-file-name "local.el" user-emacs-directory)))
  (when (file-exists-p personal-settings)
        (load-file personal-settings)))
  #+end_src
- calendar
  #+begin_src emacs-lisp
(setq calendar-date-style 'iso)
(setq mark-diary-entries-in-calendar t)
(setq org-agenda-include-diary t)
(setq local/diary-file "~/.config/emacs-default/diary")
(defun getcal (url)
  "Download ics file and add to diary"
  (let ((tmpfile (url-file-local-copy url)))
    (icalendar-import-file tmpfile local/diary-file t)
    (kill-buffer (car (last (split-string tmpfile "/"))))
    )
  )

#+end_src

**** Defaults

- from rational-emacs defaults module:
  #+begin_src emacs-lisp
;; Revert Dired and other buffers
(customize-set-variable 'global-auto-revert-non-file-buffers t)

;; Revert buffers when the underlying file has changed
(global-auto-revert-mode 1)

;; Use spaces instead of tabs
(setq-default indent-tabs-mode nil)

;; Use "y" and "n" to confirm/negate prompt instead of "yes" and "no"
;; Using `advice' here to make it easy to reverse in custom
;; configurations with `(advice-remove 'yes-or-no-p #'y-or-n-p)'
;;
;; N.B. Emacs 28 has a variable for using short answers, which should
;; be preferred if using that version or higher.
(if (boundp 'use-short-answers)
    (setq use-short-answers t)
  (advice-add 'yes-or-no-p :override #'y-or-n-p))



;; Do not saves duplicates in kill-ring
(customize-set-variable 'kill-do-not-save-duplicates t)

;; Make scrolling less stuttered
(setq-default
 auto-window-vscroll nil
 fast-but-imprecise-scrolling t
 scroll-conservatively 101
 scroll-margin 0
 scroll-preserve-screen-position t)

;; Better support for files with long lines
(setq-default
  bidi-paragraph-direction 'left-to-right
  bidi-inhibit-bpa t)
(global-so-long-mode 1)

;; Make shebang (#!) file executable when saved
(add-hook 'after-save-hook #'executable-make-buffer-file-executable-if-script-p)

#+end_src
- don't warn for large files (shows up when launching videos)
  #+begin_src emacs-lisp
  (setq-default large-file-warning-threshold nil)
  #+end_src
- don't warn for following symlinked files
  #+begin_src emacs-lisp
  (setq-default vc-follow-symlinks t)
  #+end_src

- don't warn when advice is added for functions
  #+begin_src emacs-lisp
  (setq ad-redefinition-action 'accept)
  #+end_src

- ediffs settings
  #+begin_src emacs-lisp
(setq
 ediff-make-buffers-readonly-at-startup nil
 ediff-show-clashes-only t
 ediff-split-window-function 'split-window-horizontally
 ediff-window-setup-function 'ediff-setup-windows-plain)
  #+end_src

- enable column number
  #+begin_src emacs-lisp
  (column-number-mode)
#+end_src
- default browser
  #+begin_src emacs-lisp
(setq browse-url-browser-function 'browse-url-default-browser)
  #+end_src
- prefer utf-8
  #+begin_src emacs-lisp
(setq-default
 buffer-file-coding-system 'utf-8-unix
 default-file-name-coding-system 'utf-8-unix
 default-keyboard-coding-system 'utf-8-unix
 default-process-coding-system '(utf-8-unix . utf-8-unix)
 default-sendmail-coding-system 'utf-8-unix
 default-terminal-coding-system 'utf-8-unix)
  #+end_src
- max lisp eval depth
  #+begin_src emacs-lisp
(setq max-lisp-eval-depth 10000)
  #+end_src

**** cl-lib

#+begin_src emacs-lisp
(require 'cl-lib)
(require 'cl-extra)
(require 'seq)
#+end_src

* Simple UI
** Description
A UI must be at the same time simple, aesthetic and functional. Defining precisely the three attributes is practically impossible and very personal. Through successive attempts I think I have arrived at a form that satisfies me (for now)
** Subfeatures
1. (sui1) A balance between simplicity, functionality and aesthetics
2. (sui2) Fonts visible on both the big screen and the laptop screen
3. (sui3) An eye-friendly theme
4. (sui4) Custom view (mold) depending on information contained in the buffer
** Implementation
:PROPERTIES:
  :header-args: :tangle modules/home/emacs/init.el
:END:

- create a group for ui:
  #+begin_src emacs-lisp
(defgroup local-ui '()
  "User interface related configuration."
  :tag "Local UI"
  :group 'local)
  #+end_src

*** activate only menu bar
- clean up Emacs' user interface, make it more minimal.
  #+begin_src emacs-lisp
(setq-default inhibit-startup-message t)
(scroll-bar-mode -1)  ; Disable visible scrollbar
(tool-bar-mode -1)    ; Disable the toolbar
(tooltip-mode -1)     ; Disable tooltips
(set-fringe-mode 10)  ; Give some breathing room
(menu-bar-mode 1)    ; Enable the menu bar
(setq visible-bell t) ; Set up the visible bell
#+end_src

- improve scrolling.
  #+begin_src emacs-lisp
(setq-default
  mouse-wheel-scroll-amount '(1 ((shift) . 1)  ((control) . nil)) ;; one line at a time
  mouse-wheel-progressive-speed nil ;; don't accelerate scrolling
  mouse-wheel-follow-mouse 't ;; scroll window under mouse
 scroll-margin 2 ; scroll with 2 line margin for continuity
;; keyboard scroll one line at a time instead of jumping
 scroll-step            1
 scroll-conservatively  10000)
  #+end_src

- set frame transparency and maximize windows by default.
  #+begin_src emacs-lisp
    ;; (set-frame-parameter (selected-frame) 'alpha '(90 . 90))
    ;; (add-to-list 'default-frame-alist '(alpha . (90 . 90)))
    (set-frame-parameter (selected-frame) 'fullscreen 'maximized)
    (add-to-list 'default-frame-alist '(fullscreen . maximized))
  #+end_src

*** font
- use [[https://protesilaos.com/emacs/fontaine#h:35bc7f51-6368-4718-ad25-b276a1f2cc08][fontaine]]:
  #+begin_src emacs-lisp
(use-package fontaine
  :ensure t
  :demand t
  :config
  (setq fontaine-latest-state-file
        (locate-user-emacs-file "fontaine-latest-state.eld"))
  (setq fontaine-presets
        '((tiny
           :default-family "Aporetic Serif Mono"
           :default-height 130)
          (small
           :default-family "Aporetic Serif Mono"
           :default-height 150)
          (regular
           :default-height 200)
          (medium
           :default-height 220)
          (large
           :default-weight semilight
           :default-height 240
           :bold-weight extrabold)
          (presentation
           :default-weight semilight
           :default-height 280
           :bold-weight extrabold)
          (jumbo
           :default-weight semilight
           :default-height 300
           :bold-weight extrabold)
          (t
           :default-family "Aporetic Serif Mono"
           :default-weight regular
           :default-height 180
           :fixed-pitch-family "Aporetic Serif Mono" ; Forțează-l și aici
           :fixed-pitch-weight nil
           :fixed-pitch-height 1.0
           :variable-pitch-family "Aporetic Serif"
           :variable-pitch-weight nil
           :variable-pitch-height 1.1 ; De obicei fontul serif arată mai mic, 1.1 ajută
           :bold-family nil
           :bold-weight bold
           :italic-family nil ; Dacă fontul are variantă italic, lasă nil să o folosească pe cea nativă
           :italic-slant italic
           :line-spacing nil)))

  ;; Recover last preset or fall back to desired style from
  ;; `fontaine-presets'.
  (fontaine-set-preset (or (fontaine-restore-latest-preset) 'small))

  ;; The other side of `fontaine-restore-latest-preset'.
  (add-hook 'kill-emacs-hook #'fontaine-store-latest-preset)
  )
  #+end_src
- change font size "globally":
  #+begin_src emacs-lisp
(defun local/iw-set-font-size ()
  "Adjust the font size in all windows."
  (interactive)
  (let (font-size)
    (setq font-size (read-number "Text size: "))
    (set-frame-font (font-spec :size font-size) t `(,(selected-frame)))))

  #+end_src

*** theme

- ef-themes:
  #+begin_src emacs-lisp
(use-package ef-themes
  :ensure t
  :demand t
  :config
  (load-theme 'ef-elea-dark t))
  #+end_src
*** icons

Remember to do M-x and run `nerd-icons-install-fonts' to get the
font files.  Then restart Emacs to see the effect.

- nerd icons
  #+begin_src emacs-lisp
(use-package nerd-icons
    :ensure t
    :demand t)
  #+end_src
- nerd-icons-completion
  #+begin_src emacs-lisp
(use-package nerd-icons-completion
  :ensure t
  :demand t
  :after marginalia
  :config
  (nerd-icons-completion-mode)
  (add-hook 'marginalia-mode #'nerd-icons-completion-marginalia-setup))
  #+end_src
- nerd-icon-corfu
  #+begin_src emacs-lisp
(use-package nerd-icons-corfu
  :ensure t
  :demand t
  :after corfu
  :config
  (add-to-list 'corfu-margin-formatters #'nerd-icons-corfu-formatter))
  #+end_src
- dired
  #+begin_src emacs-lisp
(use-package nerd-icons-dired
  :ensure t
  :demand t
  :config
  (add-hook 'dired-mode-hook 'nerd-icons-dired-mode))
  #+end_src
*** image

#+begin_src emacs-lisp
(autoload 'iimage-mode "iimage" "Support Inline image minor mode." t)
(autoload 'turn-on-iimage-mode "iimage" "Turn on Inline image minor mode." t)
;;
;; ** Display images in *Info* buffer.
;;
;; (add-hook 'info-mode-hook 'turn-on-iimage-mode)
;;
#+end_src

*** modeline

- modeline
#+begin_src emacs-lisp :tangle no
(use-package doom-modeline
  :ensure t
  :demand t
  :custom
  (doom-modeline-height 15)
  (doom-modeline-bar-width 6)
  (doom-modeline-minor-modes t)
  (doom-modeline-icon t)
  (doom-modeline-lsp t)
  (doom-modeline-github nil)
  (doom-modeline-mu4e nil)
  (doom-modeline-irc t)
  (doom-modeline-persp-name nil)
  (doom-modeline-project-detection nil)
  (doom-modeline-unicode-fallback t)
  (doom-modeline-buffer-file-name-style 'relative-from-project)
  :config
  (setq doom-modeline-minor-modes t)
  (doom-modeline-mode)
  )
#+end_src

#+begin_src emacs-lisp

(use-package minions
  :ensure t
  :demand t
  :config
  (minions-mode 1))

;; (custom-set-faces '(mode-line ((t (:height 0.85))))
;;                   '(mode-line-inactive ((t (:height 0.85)))))
#+end_src
- enable minor modes:
  #+begin_src emacs-lisp
(global-subword-mode 1)
(column-number-mode 1)      ; Show the column number
(global-hl-line-mode t)
(window-divider-mode 1)
  #+end_src

*** desktop

- to save desktop:
  #+begin_src emacs-lisp

  #+end_src
*** clipboard
- Fix WSL/WSLg copy issue.
  #+begin_src emacs-lisp
;; (setq select-active-regions nil)
  #+end_src
- cliphist
  #+begin_src emacs-lisp
(use-package cliphist
  :config
  (setq cliphist-cc-kill-ring t))
#+end_src
- copy
  #+begin_src emacs-lisp
(cond
 ((string= (getenv "XDG_SESSION_TYPE") "wayland")
  (progn
    (setq wl-copy-process nil)
    (customize-set-variable 'x-select-enable-clipboard-manager nil)
    (defun wl-copy (text)
      (setq wl-copy-process (make-process :name "wl-copy"
                                          :buffer nil
                                          :command '("wl-copy" "-f" "-n")
                                          :connection-type 'pipe
                                          :noquery t))
      (process-send-string wl-copy-process text)
      (process-send-eof wl-copy-process))
    (defun wl-paste ()
      (if (and wl-copy-process (process-live-p wl-copy-process))
          nil ; should return nil if we're the current paste owner
        (shell-command-to-string "wl-paste -n | tr -d \r")))
    (setq interprogram-cut-function 'wl-copy)
    (setq interprogram-paste-function 'wl-paste)))

 ((eq system-type 'darwin)
  (progn
    ;; Clipboard pentru macOS GUI
    ;; Forțează utilizarea clipboard-ului sistemului prin funcțiile interne
    (setq interprogram-cut-function 'gui-select-text)
    (setq interprogram-paste-function 'gui-selection-value)
    (setq select-enable-clipboard t)   ; Permite copierea către clipboard-ul sistemului
    (setq select-enable-primary t)     ; Permite utilizarea selecției primare (pentru mouse)
    (setq save-interprogram-paste-before-kill t) ; Salvează ce era în clipboard înainte de a tăia în Emacs
    (setq mouse-drag-copy-region t)    ; Copiază automat regiunea selectată cu mouse-ul
    ))

 (t
   (progn
      (setq x-select-enable-clipboard t)
      (customize-set-variable 'x-select-enable-clipboard-manager t)
      (defun xsel-cut-function (text &optional push)
        (with-temp-buffer
          (insert text)
          (call-process-region (point-min) (point-max) "xsel" nil 0 nil "--clipboard" "--input")))
      (defun xsel-paste-function()

        (let ((xsel-output (shell-command-to-string "xsel --clipboard --output")))
          (unless (string= (car kill-ring) xsel-output)
            xsel-output )))
      (setq interprogram-cut-function 'xsel-cut-function)
      (setq interprogram-paste-function 'xsel-paste-function))))

  #+end_src
*** ANSI Colors
-  translates ANSI SGR (Select Graphic Rendition) escape sequences like "Esc [ 30
  m" into EmacsOverlays, TextProperties, or XEmacsExtents with face colours,
  bold, etc.
  #+begin_src emacs-lisp
(use-package ansi-color
  :ensure nil
  :config
  (add-hook 'shell-mode-hook  #'ansi-color-for-comint-mode-on)
  (defun endless/colorize-compilation ()
    "Colorize from `compilation-filter-start' to `point'."
    (let ((inhibit-read-only t))
      (ansi-color-apply-on-region compilation-filter-start (point))))
  (add-to-list 'comint-output-filter-functions 'ansi-color-process-output)
  (add-hook 'compilation-filter-hook #'endless/colorize-compilation)
  (add-hook 'compilation-filter-hook #'ansi-color-compilation-filter)
  (add-hook 'eshell-preoutput-filter-functions 'ansi-color-filter-apply))
  #+end_src

*** pulse
#+begin_src emacs-lisp
;; add visual pulse when changing focus, like beacon but built-in
;; from from https://karthinks.com/software/batteries-included-with-emacs/
(defun pulse-line (&rest _)
  "Pulse the current line."
  (pulse-momentary-highlight-one-line (point)))

(dolist (command '(scroll-up-command scroll-down-command
                                     recenter-top-bottom other-window))
  (advice-add command :after #'pulse-line))
#+end_src
*** split vertically by default

#+begin_src emacs-lisp
(customize-set-variable 'split-width-threshold 0)
(customize-set-variable 'split-height-threshold nil)
#+end_src

* Completion
** Description
Completion should be a non-intrusive action
** Subfeatures
1. (cpl1) don't want autocomplete
2. (cpl2) after I type 3 characters I want it to propose me completions
3. (cpl3) a TAB should insert the first suggestion
4. (cpl4) several TABs should go through the suggestions
5. (cpl5) any other character should be inserted in the text
6. (cpl6) suggestions should take into account the current mode (clojure, lsp, org etc)
7. (cpl7) snippets should not have separate command
** Implementation
:PROPERTIES:
:header-args: :tangle modules/home/emacs/init.el
:END:
*** Basic completion
- enable indentation and completion with the =TAB= key.
#+begin_src emacs-lisp
(setq tab-always-indent 'complete)
#+end_src
- Cycle with the =TAB= key if there are only few candidates.
#+begin_src emacs-lisp
(setq completion-cycle-threshold 3)
#+end_src

*** Preview

#+begin_src emacs-lisp
(use-package completion-preview
  :hook
  ((comint-mode-hook
    eshell-mode-hook
    prog-mode-hook
    text-mode-hook) . completion-preview-mode)
  (minibuffer-setup-hook . completion-preview-enable-in-minibuffer)
  :bind
  (:map completion-preview-active-mode-map
        ("TAB" . completion-preview-complete)
        ("C-e" . completion-preview-insert)
        ("M-n" . completion-preview-next-candidate)
        ("M-p" . completion-preview-prev-candidate)
        ("M-i" . completion-preview-insert))
  :init
  (setq completion-preview-adapt-background-color nil)
  (setq completion-preview-minimum-symbol-length 2)
  :config
  (defun completion-preview-enable-in-minibuffer ()
    "Enable Corfu completion in the minibuffer, e.g., `eval-expression'."
    (when (where-is-internal #'completion-at-point (list (current-local-map)))
      (completion-preview-mode 1)))

  (cl-pushnew 'org-self-insert-command completion-preview-commands :test #'equal))
#+end_src
*** corfu

- enhances the default completion in region function with a completion overlay
  #+begin_src emacs-lisp
(use-package corfu
  :ensure t
  :demand t
  :commands
  (corfu-mode
   corfu-indexed-mode
   global-corfu-mode)
  :bind
  (:map corfu-map
        ([return] . nil)
        ("RET" . nil)
        ("TAB" . corfu-expand)
        ([tab] . corfu-expand)
        ("S-TAB" . corfu-previous)
        ([backtab] . corfu-previous)
        ("C-e" . corfu-complete))
  :custom
  (corfu-cycle t)
  (corfu-preselect 'first)
  :config
  (setq corfu-popupinfo-delay '(1.25 . 0.5))
  (corfu-popupinfo-mode 1) ; shows documentation after `corfu-popupinfo-delay'

  (global-corfu-mode 1)
  (defun local/corfu-enable-in-minibuffer ()
    (when (where-is-internal #'completion-at-point minibuffer-local-map)
      (setq-local corfu-auto nil) ; opțional: fără auto-complete în minibuffer
      (corfu-mode 1)))
  (add-hook 'minibuffer-setup-hook #'local/corfu-enable-in-minibuffer))
  #+end_src

*** dabbrev
- use Dabbrev with Corfu!
  #+begin_src emacs-lisp
(use-package dabbrev
  :init
  (setq dabbrev-case-replace nil)
  (setq dabbrev-ignored-buffer-regexps '("\\.\\(?:pdf\\|jpe?g\\|png\\)\\'")))
  #+end_src
*** tempel

- template system
  #+begin_src emacs-lisp
(use-package tempel
  :ensure t
  :demand t
  :commands
  (tempel-expand)
  :bind
  (("M-+" . tempel-complete)
   ("M-*" . tempel-insert))
  :init

  ;; Setup completion at point
  (defun tempel-setup-capf ()
    ;; Add the Tempel Capf to `completion-at-point-functions'.
    ;; `tempel-expand' only triggers on exact matches. Alternatively use
    ;; `tempel-complete' if you want to see all matches, but then you
    ;; should also configure `tempel-trigger-prefix', such that Tempel
    ;; does not trigger too often when you don't expect it. NOTE: We add
    ;; `tempel-expand' *before* the main programming mode Capf, such
    ;; that it will be tried first.
    (setq-local completion-at-point-functions
                (cons #'tempel-expand
                      completion-at-point-functions)))

  (add-hook 'conf-mode-hook 'tempel-setup-capf)
  (add-hook 'prog-mode-hook 'tempel-setup-capf)
  (add-hook 'text-mode-hook 'tempel-setup-capf)

  :config
  (set-face-attribute 'tempel-field nil :background 'unspecified :inherit 'default)
  (setq tempel-path (concat user-emacs-directory "templates/*.eld")))
  #+end_src

*** cape
#+begin_src emacs-lisp
(use-package cape
  :ensure t
  :demand t
  :after corfu
  :commands
  (cape-wrap-silent)
  :functions
  (cape-capf-buster
   cape-capf-super)
  :bind
  (([remap dabbrev-expand] . cape-dabbrev)
   (:prefix-map completion-prefix-map :prefix "M-P"
                ("d" . cape-dabbrev)
                ("h" . cape-history)
                ("f" . cape-file)
                ("k" . cape-keyword)
                ("M-P" . completion-at-point)
                ("p" . cape-pcomplete)
                ("s" . cape-elisp-symbol)
                ("a" . cape-abbrev)
                ("l" . cape-line)
                ("w" . cape-dict)
                ("\\" . cape-tex)
                ("&" . cape-sgml)
                ("r" . cape-rfc1345))
   (:map corfu-map
         ("C-x C-f" . cape-file)))
  :init
  ;; Use cape-dict for dictionary completion.
  (setq cape-dict-file (getenv "WORDLIST"))
  (setq text-mode-ispell-word-completion nil)
  :config
  (setq completion-at-point-functions '(cape-dabbrev cape-file cape-elisp-block))

  (defun local/cape-super-set-local (capfs &optional individual-capfs)
    "Set `completion-at-point-functions' to current value plus CAPFS.
Treat CAPFS and the default value as a super CAPF.  Then append the
INDIVIDUAL-CAPFS to the list."
    (let* ((all-for-super (append completion-at-point-functions capfs))
           (all-minus-global (delq t all-for-super))
           (cape-super (apply #'cape-capf-super all-minus-global)))
      (setq-local completion-at-point-functions (append (list cape-super) individual-capfs (list t)))))

  (defun local/cape-prog-setup ()
    "Set up Cape for programming."
    (local/cape-super-set-local '(tempel-expand) '(cape-dabbrev cape-keyword cape-file)))

  (add-hook 'prog-mode-hook #'local/cape-prog-setup)

  (defun local/cape-text-setup ()
    "Set up Cape for prose."
    (local/cape-super-set-local '(cape-dict cape-dabbrev cape-emoji) '(cape-file)))

  (add-hook 'text-mode-hook #'local/cape-text-setup)

  (defun local/cape-comint-setup ()
    "Set up Cape for comint."
    (local/cape-super-set-local '(cape-history) '(cape-dabbrev)))

  (add-hook 'comint-mode-hook #'local/cape-comint-setup)
  (add-hook 'eshell-mode-hook #'local/cape-comint-setup)

  (setf (symbol-function 'cape-pcomplete) (cape-capf-interactive #'pcomplete-completions-at-point))
  (advice-add 'pcomplete-completions-at-point :around #'cape-wrap-silent)

  ;; Org
  (with-eval-after-load 'org

    (require 'cape-keyword)
    (require 'org-roam)

    (defun local/cape-org-src-keywords ()
      "Complete keywords in Org babel source blocks.
Looks up the source block's language in `cape-keyword-list' to
provide language-specific keyword completion."
      (when-let* ((info (org-babel-get-src-block-info 'light))
                  (lang (car info))
                  (mode (org-src-get-lang-mode lang))
                  (kw (or (alist-get mode cape-keyword-list)
                          (when-let* ((remap (rassq mode major-mode-remap-alist)))
                            (alist-get (car remap) cape-keyword-list)))))
        (while (and (consp kw) (symbolp (car kw)))
          (setq kw (alist-get (car kw) cape-keyword-list)))
        (when (consp kw)
          (let ((bounds (bounds-of-thing-at-point 'symbol)))
            (when bounds
              (list (car bounds) (cdr bounds) kw
                    :annotation-function (lambda (_) " Keyword")
                    :exclusive 'no))))))

    (defun local/cape-org-setup ()
      "Set up Cape for org-mode"
      (local/cape-super-set-local '(org-roam-complete-link-at-point) '(local/cape-org-src-keywords)))

    (add-hook 'org-mode-hook #'local/cape-org-setup)))
  #+end_src

*** orderless

- space-separated matching components matching in any order.
#+begin_src emacs-lisp
(use-package orderless
  :ensure t
  :init
  (setq completion-styles '(substring orderless))
  (setq completion-category-defaults nil)
  (setq completion-category-overrides '((file (styles basic partial-completion)))))
#+end_src

*** consult

#+begin_src emacs-lisp :tangle no
(use-package consult
  :ensure t
  :demand t
  :bind
  (([remap bookmark-jump] . consult-bookmark)
   ([remap goto-line] . consult-goto-line)
   ([remap imenu] . consult-imenu)
   ([remap jump-to-register] . consult-register)
   ([remap point-to-register] . consult-register-store)
   ([remap switch-to-buffer] . consult-buffer)
   ([remap yank-pop] . consult-yank-pop)
   ("C-c k" . consult-kmacro)
   ("C-c r" . consult-recent-file)
   (:map search-map
         ("g" . consult-ripgrep)
         ("m" . consult-mark)
         ("M-m" . consult-global-mark)))
  :init
  (setq consult-preview-key "M-RET"))

(use-package consult-xref
  :after xref
  :functions
  (consult-xref)
  :init
  (setq xref-show-xrefs-function #'consult-xref)
  (setq xref-show-definitions-function #'consult-xref))

#+end_src

*** embark

#+begin_src emacs-lisp
(use-package embark
  :ensure t
  :commands
  (embark-prefix-help-command)
  :bind
  (("C-h B" . embark-bindings)
   ("M-O" . embark-dwim)
   ("M-o" . embark-act)
   (:map vertico-map ("C-SPC" . embark-select)))
  :init
  (setq prefix-help-command #'embark-prefix-help-command)
  (setq embark-indicators
        '(embark-verbose-indicator
          embark-highlight-indicator
          embark-isearch-highlight-indicator)))

(use-package embark-consult
  :ensure t
  :hook
  (embark-collect-mode . consult-preview-at-point-mode))
#+end_src
*** marginalia

#+begin_src emacs-lisp
(use-package marginalia
  :ensure t
  :defer 2
  :commands
  (marginalia-mode)
  :config
  (setq marginalia-align 'right)
  (setq marginalia-max-relative-age 0)
  (marginalia-mode 1))

#+end_src
*** vertico

#+begin_src emacs-lisp
(use-package vertico
  :ensure t
  :demand t
  :commands
  (vertico-insert
   vertico-exit)
  :init
  (defun vertico-move-end-of-line-or-insert (arg)
    "Move to end of line or insert current candidate.
   ARG lines can be used.

   When only one candidate exists exit input after insert."
    (interactive "p")
    (if (eolp)
        (progn
          (vertico-insert)
          (when (= vertico--total 1)
            (vertico-exit)))
      (move-end-of-line arg)))
  :config
  (setq vertico-cycle t)
  (setq vertico-resize nil)
  (add-hook 'minibuffer-setup #'vertico-repeat-save) ; Make sure vertico state is saved
  (add-hook 'rfn-eshadow-update-overlay #'vertico-directory-tidy) ; Clean up file path when typing
  (require 'vertico-directory)
  (require 'vertico-quick)
  (vertico-mode)
  :bind
  (:map vertico-map
    ("<backspace>"   . vertico-directory-delete-char)
    ("<escape>"      . minibuffer-keyboard-quit)
    ("?"             . minibuffer-completion-help)
    ("C-<backspace>" . vertico-directory-delete-word)
    ("C-e"           . vertico-move-end-of-line-or-insert)
    ("C-M-n"         . vertico-next-group)
    ("C-M-p"         . vertico-previous-group)
    ("TAB"           . minibuffer-complete)
    ("C-j"           . vertico-next)
    ("C-k"           . vertico-previous)
    ("C-o"           . vertico-quick-exit)
    ("C-w"           . vertico-directory-delete-word)
    ("M-F"           . vertico-multiform-flat)
    ("M-G"           . vertico-multiform-grid)
    ("M-R"           . vertico-multiform-reverse)
    ("M-RET"         . minibuffer-force-complete-and-exit)
    ("M-TAB"         . vertico-quick-insert)
    ("M-U"           . vertico-multiform-unobtrusive)
    ("M-h"           . vertico-directory-up)))

#+end_src
- minibuffer ca pop-up
  #+begin_src emacs-lisp :tangle no
(use-package vertico-posframe
  :ensure t
  :after vertico
  :config
  (vertico-posframe-mode 1)

  ;; Opțional: Personalizează poziția și aspectul
  (setq vertico-posframe-parameters
        '((left-fringe . 8)
          (right-fringe . 8)
          (internal-border-width . 2)))

  ;; Poți schimba poziția: 'center, 'top-center, etc.
  (setq vertico-posframe-poshandler #'posframe-poshandler-frame-center))
  #+end_src
*** minibuffer
- enable recursive minibuffers.
#+begin_src emacs-lisp
(setq enable-recursive-minibuffers t)
#+end_src
- do not allow the cursor in the minibuffer prompt.
#+begin_src emacs-lisp
(setq minibuffer-prompt-properties
      '(read-only t cursor-intangible t face minibuffer-prompt))
(add-hook 'minibuffer-setup-hook #'cursor-intangible-mode)
#+end_src
- give some more room to the minbuffer.
#+begin_src emacs-lisp
(setq max-mini-window-height 0.3)
(setq resize-mini-windows 'grow-only)
#+end_src
- don't show fringes in the minibuffer.
#+begin_src emacs-lisp
(defun disable-minibuffer-window-fringes (&rest _)
  "Disable the window fringes for minibuffer window."
  (set-window-fringes (minibuffer-window) 0 0 nil))
(add-hook 'minibuffer-setup-hook #'disable-minibuffer-window-fringes)
#+end_src
- track minibuffer history
#+begin_src emacs-lisp
(setq history-delete-duplicates t)
(setq history-length 500)
#+end_src

*** savehist
  #+begin_src emacs-lisp
(use-package savehist
  :ensure nil
  :demand t
  :config
  (setq savehist-file (expand-file-name "savehist" emacs-cache-dir))
  (setq history-length 500)
  (setq history-delete-duplicates t)
  (setq savehist-save-minibuffer-history t)
  (add-to-list 'savehist-additional-variables 'kill-ring)
  (savehist-mode 1))
  #+end_src

* Search and Fast Moving in Buffers
** Description

emacs has countless search commands in buffers. The problem is that there are too many and too specialized

** Subfeatures

1. (fmb1) I would like to have one search command
2. (fmb2) can search all visible buffers
3. (fmb3) to work in all modes (emacs,normal,insert,move)
4. (fmb4) can create custom commands based on it

** Implementation
:PROPERTIES:
:header-args: :tangle modules/home/emacs/init.el
:END:

*** General

- display a counter showing the number of the current and the other matches.
  #+begin_src emacs-lisp :tangle no
(setq isearch-lazy-count t
      lazy-count-prefix-format "(%s/%s) "
      lazy-count-suffix-format nil)
  #+end_src
- make regular Isearch interpret the empty space as a regular expression that matches any character between the words you give it:
  #+begin_src emacs-lisp :tangle no
(setq search-whitespace-regexp ".*?")
  #+end_src
- nu intra in debug la parasirea minibufer
  #+begin_src emacs-lisp
(add-to-list 'debug-ignored-errors 'minibuffer-quit)
#+end_src

*** goto-map

- exista o =key-map= ~goto-map~ (~M-g~) pentru deplasari
- URL handling.
#+begin_src emacs-lisp
(use-package browse-url
  :bind
  (:map goto-map
        ("u" . browse-url-at-point)
        ("U" . browse-url)))
#+end_src
- Move point through buffer-undo-list positions.
#+begin_src emacs-lisp
(use-package goto-chg
  :ensure t
  :bind
  ((:map goto-map ("SPC" . goto-last-change))
   (:repeat-map goto-chg-repeat-map
                ("SPC" . goto-last-change)
                ("[" . goto-last-change)
                ("]" . goto-last-change-reverse))))
#+end_src
- hint mode for links.
#+begin_src emacs-lisp
(use-package link-hint
  :ensure t
  :bind
  (:map goto-map
        ("l" . link-hint-open-link)
        ("L" . link-hint-copy-link)))
#+end_src

*** Buffers

- keep track of recently opened files.
#+begin_src emacs-lisp
(use-package recentf
  :defer 1
  :custom
  (recentf-exclude
        (list "/tmp/"                        ; Temp-files
              "/dev/shm"                     ; Potential secrets
              "/ssh:"                        ; Files over SSH
              "/nix/store"                   ; Files in Nix store
              "/TAGS$"                       ; Tag files
              "^/\\.git/.+$"                 ; Git contents
              "\\.?ido\\.last$"
              "\\.revive$"
              "^/var/folders/.+$"
              (concat "^" emacs-cache-dir ".+$")))
  (recentf-filename-handlers '(abbreviate-file-name))
  (recentf-max-menu-items 0)
  (recentf-max-saved-items 300)
  (recentf-auto-cleanup 'never)
  :config
  (quiet! (recentf-mode 1))
  (customize-set-variable 'recentf-save-file
                          (expand-file-name "recentf" emacs-cache-dir)))

#+end_src
- keep track of last point place to resume editing in the same file.
#+begin_src emacs-lisp
(use-package saveplace
  :defer 2
  :config
  (save-place-mode 1))
#+end_src
- some buffers should not be deleted by accident:
  #+begin_src emacs-lisp
(defvar *protected-buffers* '("*scratch*" "*Messages*")
  "Buffers that cannot be killed.")

(defun local/protected-buffers ()
  "Protects some buffers from being killed."
  (dolist (buffer *protected-buffers*)
    (with-current-buffer buffer
      (emacs-lock-mode 'kill))))

(add-hook 'after-init-hook #'local/protected-buffers)
  #+end_src
- use popper for "popups" buffers:
  #+begin_src emacs-lisp
(use-package popper
  :ensure t
  :demand t
  :init
  (setq popper-window-height 12
        popper-reference-buffers
         '("^\\*eshell\\*"
           "^vterm"
           "\\*Messages\\*"
           "Output\\*$"
           "\\*devdocs\\*"
           "\\*envrc\\*"
           "^\\*eldoc"
           help-mode
           helpful-mode
           compilation-mode
           elisp-refs-mode
           ghelp-page-mode
           (lambda (buf)
             (with-current-buffer buf
               (derived-mode-p '(compilation-mode
                                 comint-mode
                                 help-mode))))))
  (popper-mode +1)
  (popper-echo-mode +1))
  #+end_src
- use midnight mode for remove unused buffers:
  #+begin_src emacs-lisp
(use-package midnight
  :ensure nil
  :demand t
  :config
  (midnight-mode))
  #+end_src
- disable undo-tree history:
  #+begin_src emacs-lisp
(customize-set-variable 'undo-tree-auto-save-history nil)
  #+end_src
- undo-fo:
  #+begin_src emacs-lisp
(use-package undo-fu
  :ensure t
  :demand t
  :custom
  (undo-fu-allow-undo-in-region t)
  :config
  (global-unset-key (kbd "C-z"))
  ;; (global-set-key (kbd "C-z")   'undo-fu-only-undo)
  ;; (global-set-key (kbd "C-S-z") 'undo-fu-only-redo)
  (global-set-key (kbd "C-z") 'undo-fu-only-redo)
  )
  #+end_src
- revert buffers when underlying files change.
#+begin_src emacs-lisp
(use-package autorevert
  :hook
  (image-mode-hook . auto-revert-mode)
  :init
  (setq auto-revert-verbose nil))
#+end_src
- scratch
  #+begin_src emacs-lisp
(defun local/scratch-buffer ()
  "Open a new scratch buffer."
  (interactive)
  (switch-to-buffer "*scratch*"))
  #+end_src

**** buffer menu

#+begin_src emacs-lisp
(with-eval-after-load 'transient
  (transient-define-prefix local/buffer-menu ()
    "buffer menu"
    [("b" "switch buffer" consult-buffer)
     ("B" "ibuffer" ibuffer)
     ("d" "kill current buffer" kill-this-buffer)
     ("f" "display popper" popper-toggle)
     ("j" "cycle popper" popper-cycle)
     ("k" "pick & kill" kill-buffer)
     ("K" "kill regexp buffers" kill-matching-buffers-no-ask)
     ("l" "list buffers" list-buffers)
     ("r" "rename buffer" rename-buffer)
     ("s" "open scratch" local/scratch-buffer)
     ("t" "toggle popper" popper-toggle-type)]))
#+end_src

*** Directories and Files
- helper functions
  #+begin_src emacs-lisp
(defmacro make-find (functionname filename)
  (let ((funsymbol (intern (concat "find-" functionname))))
    `(defun ,funsymbol () (interactive) (find-file  ,filename))))

(make-find "config" local/config-file)
(make-find "accounts" local/accounts-file)
(make-find "contacts" local/contacts-file)
(make-find "bibtex" local/bibliography-file)

(defun find-notebook ()
  (interactive)
  (let ((dir (locate-dominating-file default-directory "Notebook.org")))
    (if dir
        (find-file-other-window (expand-file-name "Notebook.org"  dir))
      (message "No Notebook"))
    ))

(defun local/search-in-files ()
  (interactive)
  (consult-grep t))
  #+end_src
- use dired
  #+begin_src emacs-lisp
(use-package dired
  :ensure nil
  :hook
  (dired-mode-hook . auto-revert-mode)
  (dired-mode-hook . hl-line-mode)
  (dired-mode-hook . dired-hide-details-mode)
  :custom
  (dired-recursive-copies 'always)
  (dired-recursive-deletes 'always)
  (dired-isearch-filenames 'dwim)
  (dired-hide-details-hide-symlink-targets nil)
  (delete-by-moving-to-trash t)
  (dired-auto-revert-buffer t)

  (dired-dwim-target t)
  :config
  (file-name-shadow-mode 1)
  (if (eq system-type 'darwin)
    (setq dired-use-ls-dired nil)
    (setq dired-listing-switches "-AFhlv --group-directories-first"))
  (autoload 'dired-async-mode "dired-async.el" nil t))
  #+end_src
- adaptare macos:
  #+begin_src emacs-lisp
;; Folosește GNU ls pe macOS dacă este disponibil
(when (eq system-type 'darwin)
  (let ((gls (executable-find "gls")))
    (if gls
        (setq insert-directory-program gls)
      (setq dired-use-ls-dired nil)))) ; Fallback dacă gls nu e găsit
#+end_src
- editable
  #+begin_src emacs-lisp
(use-package wdired
  :after dired
  :bind
  (:map dired-mode-map ("C-c '" . wdired-change-to-wdired-mode)))
#+end_src
- use async
  #+begin_src emacs-lisp
(use-package async
  :ensure t
  :demand t
  :config
  (dired-async-mode 1))
  #+end_src
- sudo edit (using embark)
  #+begin_src emacs-lisp
(defun local/sudo-find-file (file)
  "Open FILE as root."
  (interactive "FOpen file as root: ")
  (when (file-writable-p file)
    (user-error "File is user writeable, aborting sudo"))
  (find-file (if (file-remote-p file)
                 (concat "/" (file-remote-p file 'method) ":"
                         (file-remote-p file 'user) "@" (file-remote-p file 'host)
                         "|sudo:root@"
                         (file-remote-p file 'host) ":" (file-remote-p file 'localname))
               (concat "/sudo:root@localhost:" file))))
  #+end_src
- wgrep
  #+begin_src emacs-lisp
(use-package wgrep
  :ensure t
  :demand t
  :custom
  (wgrep-auto-save-buffer t)
  (wgrep-change-readonly-file t)
  :bind ( :map grep-mode-map
          ("e" . wgrep-change-to-wgrep-mode)
          ("C-x C-q" . wgrep-change-to-wgrep-mode)
          ("C-c C-c" . wgrep-finish-edit)))

  #+end_src
- [[https://github.com/karthink/consult-dir][consult-dir]]
  #+begin_src emacs-lisp
(use-package consult-dir
  :ensure t
  :demand t
  :commands consult-dir
  :custom
  (consult-dir-shadow-filenames t)
  (consult-dir-sources '(consult-dir--source-bookmark
                         consult-dir--source-default
                         consult-dir--source-project
                         consult-dir--source-recentf)))
  #+end_src
- trashed
  #+begin_src emacs-lisp
(use-package trashed
  :ensure t
  :demand t
  :commands (trashed)
  :config
  (setq trashed-action-confirmer 'y-or-n-p)
  (setq trashed-use-header-line t)
  (setq trashed-sort-key '("Date deleted" . t))
  (setq trashed-date-format "%Y-%m-%d %H:%M:%S"))
  #+end_src

**** file menu

#+begin_src emacs-lisp
(with-eval-after-load 'transient
  (transient-define-prefix local/file-menu ()
    "file menu"
    [[("SPC" "locate" consult-locate)
      ("." "dir other window" dired-jump-other-window)
      ("/" "grep" local/search-in-files)
      ("a" "accounts" find-accounts)
      ("b" "bibtex" find-bibtex)]
     [("c" "contacts" find-contacts)
      ("d" "dired" consult-dir)
      ("e" "emacs config" find-config)
      ("f" "find file" find-file)
      ("g" "speedbar" speedbar-get-focus)
      ("l" "find library" find-library)]
     [("n" "notebook" find-notebook)
      ("p" "at point" find-file-at-point)
      ("r" "recently opened files" consult-recent-file)
      ("s" "save file" save-buffer)
      ("w" "save as" write-file)]]))
#+end_src

*** Speedbar

#+begin_src emacs-lisp
(use-package speedbar
  :ensure nil
  :commands (speedbar)
  :config
  (setq speedbar-prefer-window t)
  (setq speedbar-use-images nil)
  (setq speedbar-directory-exclude-regexp nil))
#+end_src

*** Windows

- resize
  #+begin_src emacs-lisp
(require 'windmove)

(defun local/win-move-sep-left (arg)
  "Move window splitter left."
  (interactive "p")
  (if (let ((windmove-wrap-around))
        (windmove-find-other-window 'right))
      (shrink-window-horizontally arg)
    (enlarge-window-horizontally arg)))

(defun local/win-move-sep-right (arg)
  "Move window splitter right."
  (interactive "p")
  (if (let ((windmove-wrap-around))
        (windmove-find-other-window 'right))
      (enlarge-window-horizontally arg)
    (shrink-window-horizontally arg)))

(defun local/win-move-sep-up (arg)
  "Move window splitter up."
  (interactive "p")
  (if (let ((windmove-wrap-around))
        (windmove-find-other-window 'up))
      (enlarge-window arg)
    (shrink-window arg)))

(defun local/win-move-sep-down (arg)
  "Move window splitter down."
  (interactive "p")
  (if (let ((windmove-wrap-around))
        (windmove-find-other-window 'up))
      (shrink-window arg)
    (enlarge-window arg)))

(require 'transient)
(transient-define-prefix local/win-resize ()
  "Resize windows"
  :transient-suffix     'transient--do-stay
  :transient-non-suffix 'transient--do-warn
  ["Actions"
   ("b" "balance" balance-windows :transient nil)
   ("h" "X←" local/win-move-sep-left)
   ("j" "X↓" local/win-move-sep-down)
   ("k" "X↑" local/win-move-sep-up)
   ("l" "X→" local/win-move-sep-right)])
  #+end_src
- zoom
  #+begin_src emacs-lisp
(require 'transient)
(transient-define-prefix local/win-zoom ()
  "Zoom window"
  :transient-suffix     'transient--do-stay
  :transient-non-suffix 'transient--do-warn
  ["Actions"
   ("0" "reset" local/win-zoom-reset :transient nil)
   ("-" "-" text-scale-decrease)
   ("=" "+" text-scale-increase)])
  #+end_src
- ace windows
#+begin_src emacs-lisp
(use-package ace-window
  :ensure t
  :custom
  (aw-dispatch-always t)
  :init
  (setq aw-dispatch-alist
        '((?? aw-show-dispatch-help)
          (?= local/ace-window-zoom "Zoom Text")
          (?F aw-split-window-fair "Split Fair Window")
          (?M aw-move-window "Move Window")
          (?v aw-split-window-horz "Split Horz Window")
          (?c aw-copy-window "Copy Window")
          (?e aw-execute-command-other-window "Execute Command Other Window")
          (?j aw-switch-buffer-in-window "Select Buffer")
          (?m aw-swap-window "Swap Windows")
          (?n aw-flip-window)
          (?o delete-other-windows "Delete Other Windows")
          (?r local/ace-window-resize "Resize Windows")
          (?t local/ace-window-toggle-split "Toggle Windows Split")
          (?u aw-switch-buffer-other-window "Switch Buffer Other Window")
          (?b aw-split-window-vert "Split Vert Window")
          (?x aw-delete-window "Delete Window")))
  :config
  (eval-when-compile
    (defmacro local/embark-ace-action (fn)
      `(defun ,(intern (concat "local/embark-ace-" (symbol-name fn))) ()
         (interactive)
         (with-demoted-errors "%s"
           (require 'ace-window)
           (let ((aw-dispatch-always t))
             (aw-switch-to-window (aw-select nil))
             (call-interactively (symbol-function ',fn)))))))

  (defun local/ace-window-resize (window)
    "Ace-window command to resize the WINDOW."
    (aw-switch-to-window window)
    (unwind-protect
        (local/win-resize)
      (aw-flip-window)))
  (defun local/ace-window-zoom (window)
    "Ace-window command to zoom the WINDOW text."
    (aw-switch-to-window window)
    (unwind-protect
        (local/win-zoom)
      (aw-flip-window)))
  (defun local/ace-window-toggle-split (window)
    "Ace-window command to toggle the WINDOWs split."
    (aw-switch-to-window window)
    (unwind-protect
        (local/win-toggle-split)
      (aw-flip-window)))

  (defun local/win-zoom-reset ()
    (interactive)
    (text-scale-increase 0))

  (defun local/win-toggle-split ()
    (interactive)
    (if (= (count-windows) 2)
        (let* ((this-win-buffer (window-buffer))
               (next-win-buffer (window-buffer (next-window)))
               (this-win-edges (window-edges (selected-window)))
               (next-win-edges (window-edges (next-window)))
               (this-win-2nd (not (and (<= (car this-win-edges)
                                           (car next-win-edges))
                                       (<= (cadr this-win-edges)
                                           (cadr next-win-edges)))))
               (splitter
                (if (= (car this-win-edges)
                       (car (window-edges (next-window))))
                    'split-window-horizontally
                  'split-window-vertically)))
          (delete-other-windows)
          (let ((first-win (selected-window)))
            (funcall splitter)
            (if this-win-2nd (other-window 1))
            (set-window-buffer (selected-window) this-win-buffer)
            (set-window-buffer (next-window) next-win-buffer)
            (select-window first-win)
            (if this-win-2nd (other-window 1))))))

  (defun local/swap-up-down ()
    (interactive)
    (if (window-in-direction 'above)
        (aw-swap-window (window-in-direction 'above))
      (aw-swap-window (window-in-direction 'below))))

  (defun local/swap-left-right ()
    (interactive)
    (if (window-in-direction 'right)
        (aw-swap-window (window-in-direction 'right))
      (aw-swap-window (window-in-direction 'left))))
  )
#+end_src

*** Avy                                                           :fmb1:fmb2:
- the fastest method seems to me to be the one used by =avy=
  #+begin_src emacs-lisp
(use-package avy
  :ensure t
  :demand t
  :custom
  (avy-all-windows 'all-frames)
  :config
  (defun local/avy-kill-whole-line (pt)
    (save-excursion
      (goto-char pt)
      (kill-whole-line))
    (select-window
     (cdr
      (ring-ref avy-ring 0)))
    t)

  (defun local/avy-copy-whole-line (pt)
    (save-excursion
      (goto-char pt)
      (cl-destructuring-bind (start . end)
          (bounds-of-thing-at-point 'line)
        (copy-region-as-kill start end)))
    (select-window
     (cdr
      (ring-ref avy-ring 0)))
    t)

  (defun local/avy-yank-whole-line (pt)
    (local/avy-copy-whole-line pt)
    (save-excursion (yank))
    t)

  (defun local/avy-teleport-whole-line (pt)
    (local/avy-kill-whole-line pt)
    (save-excursion (yank)) t)

  (defun local/avy-mark-to-char (pt)
    (activate-mark)
    (goto-char pt)))
(global-set-key (kbd "<f9>") #'avy-goto-char)

  #+end_src

*** Bookmarks

- save bookmarks immediately
  #+begin_src emacs-lisp
(use-package bookmark
  :ensure nil
  :init
  (setq bookmark-save-flag 1
      bookmark-default-file (expand-file-name "bookmarks" emacs-cache-dir)))
  #+end_src

* General Writing
** Implementation
:PROPERTIES:
:header-args: :tangle modules/home/emacs/init.el
:END:

*** org general settings

- org contrib
  #+begin_src emacs-lisp :tangle no
(use-package org-contrib
  :demand t
  :ensure t)
  #+end_src
- basic settings
  #+begin_src emacs-lisp
(use-package org
  :ensure nil
  ;; :demand t
  :custom
  (org-archive-location "%s_archive::")
  (org-capture-bookmark nil)
  (org-cycle-separator-lines 2)
  (org-directory local/pers-dir)
  (org-edit-src-content-indentation 2)
  (org-ellipsis " ▾")
  (org-fold-catch-invisible-edits 'smart)
  (org-fold-show-context-detail t)
  (org-fontify-quote-and-verse-blocks t)
  (org-hide-block-startup nil)
  (org-hide-emphasis-markers t)
  ;; (org-id-locations-file (expand-file-name ".org-id-locations" emacs-cache-dir))
  (org-imenu-depth 4)
  (org-mouse-1-follows-link t)
  (org-return-follows-link t)
  (org-src-fontify-natively t)
  (org-src-preserve-indentation nil)
  (org-src-tab-acts-natively t)
  (org-startup-folded 'content)
  ;; org-fold-show-context-detail '((agenda . local)
  ;;                                (bookmark-jump . lineage)
  ;;                                (isearch . lineage)
  ;; (default . canonical))
  ;; Avoid accidentally editing folded regions, say by adding text after an Org “⋯”.
  :config
  (require 'org-tempo)
  (defun local/org-mode-setup ()
    (org-indent-mode 0)
    (auto-fill-mode 0)
    (visual-line-mode 0))
  (add-hook 'org-mode-hook #'local/org-mode-setup)
  (add-hook 'auto-save-hook #'org-save-all-org-buffers)
  )
  #+end_src
- open link in the same window:
  #+begin_src emacs-lisp
(with-eval-after-load 'org
  (setf (cdr (assoc 'file org-link-frame-setup)) 'find-file))
  #+end_src
- refile
  #+begin_src emacs-lisp
(with-eval-after-load 'org
  (setq org-refile-targets '((nil :maxlevel . 1)
                             (org-agenda-files :maxlevel . 2)
                             ))

  (setq org-outline-path-complete-in-steps nil)
  (setq org-refile-use-outline-path t))
  #+end_src
- make spell-checking tool ignore some org-mode section
  #+begin_src emacs-lisp
(with-eval-after-load 'ispell
  (add-to-list 'ispell-skip-region-alist '(":\\(PROPERTIES\\|LOGBOOK\\):" . ":END:"))
  (add-to-list 'ispell-skip-region-alist '("#\\+begin_src" . "#\\+end_src")))
  #+end_src
- use bullet characters instead of asterisks
  #+begin_src emacs-lisp
(use-package org-superstar
  :ensure t
  :demand t
  :after org
  :custom
  (org-superstar-remove-leading-stars t)
  (org-superstar-headline-bullets-list '("●" "■" "►" "○" "□" "▷"))
  :config
  (add-hook 'org-mode-hook (lambda () (org-superstar-mode 1))))
  #+end_src
- helper functions
  #+begin_src emacs-lisp
(defun local/date-iso ()
  "Insert the current date, ISO format, eg. 2016-12-09."
  (interactive)
  (insert (format-time-string "%F")))

(defun local/date-iso-with-time ()
  "Insert the current date, ISO format with time, eg. 2016-12-09T14:34:54+0100."
  (interactive)
  (insert (format-time-string "%FT%T%z")))

(defun local/org-table-recalculate-all ()
  "Recalculate all values in a table."
  (interactive)
  (org-table-recalculate 'iterate))
  #+end_src
- make invisible parts of org elements appear visible.
  #+begin_src emacs-lisp
(use-package org-appear
  :ensure t
  :demand t
  :custom
  (org-hide-emphasis-markers t)
  :hook org-mode-hook)
  #+end_src

*** notes


- org-roam
  #+begin_src emacs-lisp
(use-package org-roam
  :ensure t
  :demand t
  :custom
  (org-roam-directory local/notes-dir)
  (org-roam-db-location (expand-file-name "org-roam.db" emacs-cache-dir))
  (org-roam-graph-viewer "brave")
  (org-roam-completion-everywhere nil)
  (org-roam-node-display-template   (concat "${title:*} "
                                            (propertize "${tags:20}" 'face 'org-tag)))
  :config
  (org-roam-db-autosync-mode 1)
  (require 'org-roam-protocol))
  #+end_src
- insert link
  #+begin_src emacs-lisp
(defun local/insert-roam-link ()
  "Inserts an Org-roam link."
  (interactive)
  (insert "[[roam:]]")
  (backward-char 2))

(use-package key-chord
  :ensure t
  :demand t
  :config
  (key-chord-mode 1)
  (key-chord-define-global "[[" #'local/insert-roam-link))
  #+end_src
- org-roam-ui is a frontend for exploring and interacting with org-roam notes
  #+begin_src emacs-lisp
(use-package org-roam-ui
  :ensure t
  :demand t
  :after org-roam
  :commands (org-roam-ui-mode)
  :hook org-roam-mode)
  #+end_src
  - Use =org-roam-ui-mode= to enable the global mode. It will start a web server
    on http://127.0.0.1:35901/ and connect to it via a WebSocket for real-time
    updates.
- use consult to search notes:
  #+begin_src emacs-lisp
(defun local/org-roam-rg-search ()
  "Search org-roam directory using consult-ripgrep. With live-preview."
  (interactive)
  (let ((consult-ripgrep-command "rg --null --ignore-case --type org --line-buffered --color=always --max-columns=500 --no-heading --line-number . -e ARG OPTS"))
    (consult-ripgrep org-roam-directory)))
  #+end_src
- search with orgql:
  #+begin_src emacs-lisp :tangle no
(use-package org-ql
  :ensure t
  :commands org-ql-search)
  #+end_src
- [[https://github.com/nobiot/org-transclusion][org-transclusion]]
  #+begin_src emacs-lisp
(use-package org-transclusion
  :ensure t
  :custom (org-transclusion-include-first-section t))
  #+end_src

*** conspect

- extract bibtex-entry from ISBN
  #+begin_src emacs-lisp
(require 'url)
(require 'json)

(defun local/insert-bibtex-from-isbn (isbn)
  "Interoghează Open Library și inserează o intrare BibTeX pentru ISBN-ul dat.
Cheia BibTeX generată va avea formatul autorAnCuvantTitlu (ex: knuth1997Art)."
  (interactive "sIntroduceți codul ISBN: ")
  (let* ((clean-isbn (replace-regexp-in-string "[^0-9Xx]" "" isbn))
         (url-request-extra-headers '(("User-Agent" . "Emacs-BibTeX-Generator/1.0")))
         (url (format "https://openlibrary.org/api/books?bibkeys=ISBN:%s&format=json&jscmd=data" clean-isbn))
         (response-buffer (url-retrieve-synchronously url t t))
         json-data book-data)

    (unless response-buffer
      (error "Eroare la conectarea la Open Library"))

    ;; Extragem payload-ul JSON sărind peste headerele HTTP
    (with-current-buffer response-buffer
      (goto-char (point-min))
      (re-search-forward "^$" nil 'move)
      (let ((json-object-type 'alist)
            (json-array-type 'list)
            (json-key-type 'string))
        (setq json-data (json-read)))
      (kill-buffer response-buffer))

    ;; Open Library returnează datele indexate sub cheia "ISBN:<cod>"
    (setq book-data (cdr (assoc (concat "ISBN:" clean-isbn) json-data)))

    (if (not book-data)
        (message "Nu am găsit metadate pentru ISBN: %s" clean-isbn)
      (let* ((title (cdr (assoc "title" book-data)))
             (publishers (cdr (assoc "publishers" book-data)))
             (publisher (if publishers (cdr (assoc "name" (car publishers))) ""))
             (publish-date (cdr (assoc "publish_date" book-data)))
             ;; Căutăm exact anul
             (year (if (and publish-date (string-match "\\([0-9]\\{4\\}\\)" publish-date))
                       (match-string 1 publish-date)
                     ""))
             (authors-list (cdr (assoc "authors" book-data)))
             (authors (mapconcat (lambda (a) (cdr (assoc "name" a))) authors-list " and "))
             (first-author (if authors-list (cdr (assoc "name" (car authors-list))) ""))
             ;; Numele autorului
             (author-last-name (if (not (string= first-author ""))
                                   (downcase (car (last (split-string first-author " "))))
                                 ""))

             ;; EXTRAGERE TITLU: Curățăm titlul și luăm primul cuvânt care nu e stop-word
             (title-word (if title
                             (let* ((clean-title (replace-regexp-in-string "[^a-zA-Z0-9 \t]" "" (downcase title)))
                                    (words (split-string clean-title "[ \t]+" t))
                                    (stop-words '("the" "a" "an" "of" "and" "in" "on" "to" "for" "with")))
                               (catch 'found
                                 (dolist (w words)
                                   (unless (member w stop-words)
                                     ;; Returnăm primul cuvânt valid, capitalizat
                                     (throw 'found (capitalize w))))
                                 ;; Fallback: dacă toate sunt stop-words, îl luăm pe primul
                                 (capitalize (or (car words) ""))))
                           ""))

             ;; Compunem cheia BibTeX: nume autor + an + CuvantTitlu
             (bib-key (if (and (not (string= author-last-name "")) (not (string= year "")))
                          (concat author-last-name year title-word)
                        (concat "isbn_" clean-isbn)))

             ;; Formatăm șablonul final
             (bibtex-entry (format "@book{%s,\n  title     = {%s},\n  author    = {%s},\n  publisher = {%s},\n  year      = {%s},\n  isbn      = {%s}\n}\n"
                                   bib-key
                                   (or title "")
                                   (or authors "")
                                   (or publisher "")
                                   (or year "")
                                   clean-isbn)))
        ;; Inserăm rezultatul
        (insert bibtex-entry)))))
  #+end_src
- extract bibtex-entry from DOI
  #+begin_src emacs-lisp
(defun local/insert-bibtex-from-doi (doi)
  "Get a BibTeX entry from the DOI"
  (interactive "MDOI: ")
  (let ((url-mime-accept-string "text/bibliography;style=bibtex"))
    (with-current-buffer
        (url-retrieve-synchronously
         (format "http://dx.doi.org/%s"
                 (replace-regexp-in-string "http://dx.doi.org/" "" doi)))
      (switch-to-buffer (current-buffer))
      (goto-char (point-max))
      (setq bibtex-entry
            (buffer-substring
             (string-match "@" (buffer-string))
             (point)))
      (kill-buffer (current-buffer))))
  (insert (decode-coding-string bibtex-entry 'utf-8))
  (bibtex-fill-entry))
#+end_src
- gestionarea bibliografiei
  #+begin_src emacs-lisp
(use-package citar
  :ensure t
  :demand t
  :custom
  ;; Calea către fișierul(ele) tău(tale) .bib. Trebuie să fie o listă.
  (citar-bibliography (list local/bibliography-file))
  ;; Spune-i pachetului citar unde să caute notițe
  (citar-notes-paths (list local/notes-dir))
  ;; Urmărirea citărilor folosește citar, nu procesorul de bază
  (org-cite-follow-processor 'citar)
  ;; Deschide direct notița, nu meniul citar
  (citar-default-action 'citar-open-notes)
  :hook
  ;; Activează completarea la cursor în fișierele relevante
  (org-mode . citar-capf-setup))

;; Puntea de legătură între citar și org-roam
(use-package citar-org-roam
  :ensure t
  :demand t
  :after (citar org-roam)
  :config
  ;; Activează modul global care sincronizează referințele
  (citar-org-roam-mode 1))
  #+end_src
*** spell

- set hunspell as default:
  #+begin_src emacs-lisp
(use-package ispell
  :ensure nil
  :init
  ;; Setăm DICPATH pentru ca Hunspell să găsească fișierele .aff și .dic
  (setenv "DICPATH" (concat (getenv "HOME") "/.nix-profile/share/hunspell"))
  :custom
  (ispell-program-name "hunspell")
  (ispell-dictionary "en_GB,ro_RO" "Configure English and Romanian.")
  (ispell-personal-dictionary "~/.config/emacs/.hunspell_personal")
  (text-mode-ispell-word-completion nil)
  :config
  ;; Configure `LANG`, otherwise ispell.el cannot find a 'default
  ;; dictionary' even though multiple dictionaries will be configured
  ;; in next line.
  (setenv "LANG" "en_GB")
  ;; Resetăm variabilele interne pentru a forța o scanare nouă
  (setq ispell-hunspell-dict-paths-alist nil)
  ;; Forțăm ispell să recunoască setările Hunspell
  (ispell-set-spellchecker-params)
  ;; Verificăm dacă dicționarele au fost găsite înainte de a le activa
  (if (and (boundp 'ispell-hunspell-dict-paths-alist)
           ispell-hunspell-dict-paths-alist)
      (ispell-hunspell-add-multi-dic ispell-dictionary)
    (message "Ispell Error: Nu am putut popula ispell-hunspell-dict-paths-alist. Verifica DICPATH."))
  ;; Creăm fișierul personal dacă nu există
  (unless (file-exists-p ispell-personal-dictionary)
    (write-region "" nil ispell-personal-dictionary nil 0)))
  #+end_src

*** grammarly

- install server:
  #+begin_src shell :eval no :tangle no
sudo npm install -g @emacs-grammarly/grammarly-languageserver
  #+end_src
- install flycheck version:
  #+begin_src emacs-lisp :tangle no
(use-package flycheck-grammarly
  :ensure t
  :after flycheck
  :config
  (flycheck-grammarly-setup)
  (setq flycheck-grammarly-check-time 0.8))
  #+end_src

*** whitespace

#+begin_src emacs-lisp
(require 'whitespace)
#+end_src
*** surround

- surround region with char:
  #+begin_src emacs-lisp
(defun local/surround (begin end open close)
  "Put OPEN at START and CLOSE at END of the region.
If you omit CLOSE, it will reuse OPEN."
  (interactive  "r\nsStart: \nsEnd: ")
  (when (string= close "")
    (setq close open))
  (save-excursion
    (goto-char end)
    (insert close)
    (goto-char begin)
    (insert open)))
  #+end_src
- insert = pair
  #+begin_src emacs-lisp
(add-to-list 'insert-pair-alist (list ?\= ?\=))
(add-to-list 'insert-pair-alist (list ?\~ ?\~))
(global-set-key (kbd "M-=") 'insert-pair)
(global-set-key (kbd "M-\"") 'insert-pair)
(global-set-key (kbd "M-~") 'insert-pair)
(global-set-key (kbd "M-[") 'insert-pair)
(global-set-key (kbd "M-{") 'insert-pair)
  #+end_src

*** view-mode

- pentru a intra in mod automat in modul view-mode pt bufferele readonly:
  #+begin_src emacs-lisp
(setq view-read-only t)
  #+end_src

*** csv

#+begin_src emacs-lisp
(use-package csv-mode
  :ensure t)
#+end_src

*** capture

#+begin_src emacs-lisp
(with-eval-after-load 'org
  (require 'org-capture)
  (defalias 'cape-super-capf 'cape-capf-super)
  (defvar local/org-task-template
    "* TODO %?\n%a\n"
    "Template for task.")
  (defvar local/org-note-template
    "* %T\n%?\n"
    "Template for note.")
  (defvar local/org-contact-template
    "* %(org-contacts-template-name)
  :PROPERTIES:
  :ADDRESS:
  :BIRTHDAY: %^{yyyy-mm-dd}
  :EMAIL: %(org-contacts-template-email)
  :NOTE: %^{NOTE}
  :END:"
    "Template for org-contacts.")
  (setq org-capture-templates `(("c" "Contact" entry (file+headline local/backlog-file "Contacts"),
                                 local/org-contact-template
                                 :empty-lines 1 :clock-resume t :prepend t)
                                ("n" "Note" entry (file+headline local/backlog-file "Notes"),
                                 local/org-note-template
                                 :empty-lines 1 :clock-resume t :prepend t)
                                ("t" "Task" entry (file+headline local/backlog-file "Tasks"),
                                 local/org-task-template
                                 :empty-lines 1 :clock-resume t :prepend t))))
#+end_src

*** org exports

- common export config
  #+begin_src emacs-lisp
(with-eval-after-load 'org
  (setq org-latex-pdf-process
      '("xelatex -interaction nonstopmode -output-directory %o %f"
        "xelatex -interaction nonstopmode -output-directory %o %f"
        "xelatex -interaction nonstopmode -output-directory %o %f")
        org-latex-compiler "xelatex"
        ;; org-latex-compiler "lualatex"
        org-preview-latex-default-process 'dvisvgm
        org-export-backends '(ascii html icalendar latex md odt org)
        org-latex-default-packages-alist (quote
                                          (("T1" "fontenc" t)
                                           ("" "fixltx2e" nil)
                                           ("" "graphicx" t)
                                           ("" "longtable" nil)
                                           ("" "float" nil)
                                           ("" "wrapfig" nil)
                                           ("" "rotating" nil)
                                           ("normalem" "ulem" t)
                                           ("" "amsmath" t)
                                           ("" "textcomp" t)
                                           ("" "marvosym" t)
                                           ("" "wasysym" t)
                                           ("" "amssymb" t)
                                           ;; ("" "minted" t)
                                           ("" "hyperref" nil)
                                           "\\tolerance=1000"))
        ;; org-latex-listings (quote minted)
        org-latex-minted-options (quote
                                  (("fontsize" "\\footnotesize")
                                   ("linenos" "true")
                                   ("xleftmargin" "0em"))))
  )
  #+end_src
*** Babel
- with that, I can compile many languages with =org-mode=.
  #+begin_src emacs-lisp
(use-package ox-json
  :ensure t)
;; (use-package ox-epub
;;   :ensure t)
;; (use-package ox-jira
;;   :ensure t)
(with-eval-after-load 'org
  (require 'org-src)
  (setq org-src-tab-acts-natively t
        org-src-fontify-natively t
        org-src-window-setup 'split-window-right
        org-src-preserve-indentation t)
  (org-babel-do-load-languages
   'org-babel-load-languages
   (append org-babel-load-languages
           '((C . t)
             (css . t)
             (ditaa . t)
             (gnuplot . t)
             (java . t)
             (js . t)
             (latex . t)
             (makefile . t)
             (org . t)
             (python . t)
             (scheme . t)
             (sqlite . t)
             (sql . t)
             ;; (xml . t)
             ))))
  #+end_src

*** Diagrams

**** PlantUML
  #+begin_src emacs-lisp
(use-package plantuml-mode
  :ensure t
  :after org
  :mode "\\.\\(plantuml\\|puml\\)\\'"
  :custom
  ;; (plantuml-jar-path "~/.local/lib/plantuml.jar")
  ;; (org-plantuml-jar-path plantuml-jar-path)
  ;; (plantuml-defaultexec-mode 'jar)
  (plantuml-default-exec-mode 'executable)
  (plantuml-executable-path "~/.nix-profile/bin/plantuml")
  :config
  (add-to-list 'org-src-lang-modes '("plantuml" . plantuml))
  (require 'ob-plantuml)
  (with-eval-after-load 'org
    (add-to-list 'org-babel-load-languages '(plantuml . t))
    (setq org-plantuml-exec-mode 'plantuml
          org-plantuml-executable-path plantuml-executable-path)))
  #+end_src

**** Graphiz
  #+begin_src emacs-lisp
(use-package graphviz-dot-mode
  :ensure t
  :demand t
  :hook
  (graphviz-dot-mode . flycheck-mode)
  :custom
  (graphviz-dot-indent-width 4)
  (graphviz-dot-preview-extension "svg")
  :config
  (with-eval-after-load 'org
    (add-to-list 'org-src-lang-modes '("dot" . graphviz-dot))
    (org-babel-do-load-languages
     'org-babel-load-languages
     '((dot . t)))))
#+end_src

**** Mermaid

- mermaid-mode
  #+begin_src emacs-lisp
(use-package mermaid-mode
  :ensure t
  :mode "\\.mmd\\'"
  :bind (:map mermaid-mode-map
              ("C-c C-p" . local/mermaid-preview))
  :config
  (defun local/mermaid-preview ()
    "Render the current mermaid buffer to PNG via mmdc and display it.
Works with both file-visiting buffers and temp buffers (e.g. *mermaid-edit*)."
    (interactive)
    (let* ((input (or (buffer-file-name)
                      (let ((f (make-temp-file "mermaid-" nil ".mmd")))
                        (write-region (point-min) (point-max) f nil 'silent)
                        f)))
           (output (concat (file-name-sans-extension input) ".png")))
      (let ((exit-code (call-process "mmdc" nil (get-buffer-create "*mmdc-errors*") t
                                     "-i" input
                                     "-o" output
                                     "--scale" "2"
                                     "-q")))
        (if (and (eq exit-code 0) (file-exists-p output))
            (progn
              (kill-buffer "*mmdc-errors*")
              (find-file-other-window output))
          (user-error "mmdc failed (exit %d): %s" exit-code
                      (with-current-buffer "*mmdc-errors*"
                        (buffer-string))))))))
  #+end_src

 - babel
  #+begin_src emacs-lisp
(use-package ob-mermaid
  :ensure t
  :after org
  :config
  (add-to-list 'org-src-lang-modes '("mermaid" . mermaid))
  (with-eval-after-load 'org
    (org-babel-do-load-languages
     'org-babel-load-languages
     '((mermaid . t)))))
  #+end_src

- specific menu
  #+begin_src emacs-lisp
(with-eval-after-load 'transient
  (transient-define-prefix local/mermaid-menu ()
    "mermaid menu"
    [("'" "jump source" org-edit-src-exit)
     ("m" "edit mermaid block" local/markdown-edit-mermaid)
     ("v" "view mermaid block" local/mermaid-preview)
     ("j" "jump" local/jump-menu)]))
  #+end_src

*** TOC

- add table of content:
  #+begin_src emacs-lisp
(use-package org-make-toc
  :ensure t
  :custom
  (org-make-toc-insert-custom-ids t))
  #+end_src

*** Org Specific Menus
**** notes menu
  #+begin_src emacs-lisp
(with-eval-after-load 'transient
  (transient-define-prefix local/notes-menu ()
    "notes menu"
    [["Commands"
      ("/" "search" local/org-roam-rg-search)
      ("a" "add alias" org-roam-alias-add)
      ("b" "switch-to-buffer" org-roam-buffer-toggle)
      ("c" "capture" org-roam-capture)
      ("f" "find" org-roam-node-find)
      ("i" "create id" org-id-get-create)
      ("n" "insert node" org-roam-node-insert)
      ;; ("q" "ql search" org-ql-search)
      ]
     ["References"
      ("ra" "add ref" org-roam-ref-add)
      ("rb" "add bib ref" citar-org-roam-ref-add)
      ("ri" "insert citation" citar-insert-citation)
      ("ro" "open citar" citar-open)
      ("rr" "insert reference" citar-insert-reference)
      ]
     ["Transclude"
      ("ta" "add" org-transclusion-add)
      ("tA" "add all" org-transclusion-add-all)
      ("tl" "link" org-transclusion-make-from-link)
      ("tm" "mode" org-transclusion-mode)]
     ;; ["Journal"
     ;;  ("jd" "date" org-roam-dailies-goto-date)
     ;;  ("jj" "journal" org-roam-dailies-capture-today)]
     ["Server"
      ("sd" "sync db" org-roam-db-sync)
      ("si" "sync id" org-roam-update-org-id-locations)
      ;; ("sg" "graph" org-roam-graph)
      ("ss" "start" org-roam-ui-mode)]]))

  #+end_src
**** bibtex menu
  #+begin_src emacs-lisp
(with-eval-after-load 'transient
  (transient-define-prefix local/bibtex-menu ()
    "bibtex menu"
    [("b" "from isbn" local/insert-bibtex-from-isbn)
      ("d" "from doi" local/insert-bibtex-from-doi)]))
#+end_src
**** header menu

#+begin_src emacs-lisp
(defun local/goto-first-header ()
  "Jump backward to the first header in the buffer."
  (interactive)
  (goto-char (point-min))
  (org-next-visible-heading 1))

(defun local/goto-last-header ()
  "Jump forward to the last header in the buffer."
  (interactive)
  (goto-char (point-max))
  (org-previous-visible-heading 1))

(defun local/goto-first-child ()
  "Jump forward to first child of this header."
  (interactive)
  (outline-show-children 1)
  (outline-next-visible-heading 1))

(with-eval-after-load 'transient
  (transient-define-prefix local/header-menu ()
    "header menu"
    :transient-suffix     'transient--do-stay
    :transient-non-suffix 'transient--do-warn
    [["Cursor"
      ("j" "down" org-forward-heading-same-level)
      ("k" "up" org-backward-heading-same-level)
      ("l" "forward" local/goto-first-child)
      ("h" "backward" outline-up-heading)
      ("0" "first header" local/goto-first-header)
      ("$" "last header" local/goto-last-header)]
     ["Move"
      ("-" "sort" org-sort-entries)
      ("J" "move down" org-move-subtree-down)
      ("K" "move up" org-move-subtree-up)
      ("L" "move right" org-shiftmetaright)
      ("H" "move left" org-shiftmetaleft)]
     ["Edit"
      ("~" "toggle" org-toggle-heading)
      ("i" "new" org-insert-heading-after-current  :transient nil)]
     ["Misc"
      ("/" "search" imenu)
      ("a" "show all" org-show-all)
      ("f" "toggle folding" org-cycle)
      ("F" "toggle global visibility" org-shifttab)]]))
#+end_src
**** src menu

#+begin_src emacs-lisp

(with-eval-after-load 'transient
  (defun src-first-src ()
    "Jump backward to the first src in the buffer."
    (interactive)
    (goto-char (point-min))
    (org-babel-next-src-block))

  (defun src-last-src ()
    "Jump forward to the last src in the buffer."
    (interactive)
    (end-of-buffer)
    (org-babel-previous-src-block))

  (transient-define-prefix local/src-menu ()
    "src menu"
    :transient-suffix     'transient--do-stay
    :transient-non-suffix 'transient--do-warn
    [["Cursor"
      ("h" "goto src head" org-babel-goto-src-block-head)
      ("j" "down" org-babel-next-src-block)
      ("k" "up" org-babel-previous-src-block)
      ("n" "goto named src" org-babel-goto-named-src-block)
      ("-" "first src" src-first-src)
      ("$" "last src" src-last-src)]
     ["Edit"
      ("'" "edit special" org-edit-special :transient nil)
      ("a" "header arg" org-babel-insert-header-arg)
      ("s" "split src block" org-babel-demarcate-block :transient nil)]
     ["Misc"
      ("t" "tangle" org-babel-tangle  :transient nil)
      ;; ("e" "eval" org-babel-execute-src)
      ("r" "switch to code" org-babel-switch-to-session-with-code)
      ("?" "info" org-babel-view-src-block-info)
      ("!" "check" org-babel-check-src-block)]]))
#+end_src

**** Main Org Menu
#+begin_src emacs-lisp
(with-eval-after-load 'transient
  (transient-define-prefix local/org-menu ()
    "org menu"
    [["Edit1"
      ("'" "edit special" org-edit-special)
      ("-" "sort" org-sort)
      ("c" "cycle bullets" org-cycle-list-bullet :transient t)
      ("i" "item" org-insert-item)
      ("ef" "footnote" org-footnote-action)
      ("eg" "tags" org-set-tags-command)
      ("eh" "heading" org-toggle-heading)]
     ["Edit2"
      ("ei" "item" org-toggle-item)
      ("el" "link"  (lambda ()
                      (interactive)
                      (call-interactively 'org-insert-link)))
      ("ep" "property" org-set-property)
      ;; ("er" "reference" org-ref-insert-link)
      ("ew" "drawer" org-insert-drawer)
      ("ex" "id" org-id-get-create)]
     ["Misc"
                                        ;("h" "header" local/header-menu)
                                        ;("g" "send to chatgpt" gptel-send )
      ("o" "open at point" org-open-at-point)
      ("O" "jump back" org-mark-ring-goto)
                                        ;("s" "src" local/src-menu)
      ("vm" "preview latex" org-latex-preview)
      ("vi" "preview images" org-display-inline-images)]
     ["SubMenus"
      ("h" "header" local/header-menu)
      ("s" "src" local/src-menu)]
     ["Tools"
      ("ta" "archive" org-archive-subtree)
      ("tc" "recalculate" local/org-table-recalculate-all)
      ("td" "detangle" org-babel-detangle)
      ("te" "eval sexp" eval-last-sexp)
      ("tr" "refile" org-refile)
      ("tt" "tangle" org-babel-tangle)
      ("tx" "export" org-export-dispatch)]]))
#+end_src
- local hook
  #+begin_src emacs-lisp
(defun local/org-settings-hook ()
  (local-set-key (kbd "C-c k") 'local/org-menu))

(add-hook 'org-mode-hook #'local/org-settings-hook)
  #+end_src

* Dayly Tools
** Implementation
:PROPERTIES:
  :header-args: :tangle modules/home/emacs/init.el
:END:

*** Agenda

- =org-agenda= allows me to be organized with daily tasks
  #+begin_src emacs-lisp
(with-eval-after-load 'org
  (require 'org-agenda)
  (setq org-agenda-dim-blocked-tasks t
        org-agenda-span 1
        org-clock-continuously t
        org-agenda-start-on-weekday nil
        org-agenda-start-day "-0d"
        org-agenda-files  (list
                           local/plan-dir
                           local/contacts-file)
        calendar-set-date-style 'iso))
  #+end_src
- helper functions for plan files
  #+begin_src emacs-lisp
(defmacro make-goto (functionname filename)
  (let ((funsymbol (intern (concat "goto-" functionname))))
    `(defun ,funsymbol () (interactive) (find-file (expand-file-name ,filename local/plan-dir)))))

(make-goto "pers" "Pers.org")
(make-goto "work" "Work.org")
(make-find "backlog" local/backlog-file)
  #+end_src
- get plan file function
  #+begin_src emacs-lisp
(defun local/get-plan (plan-file)
  (interactive
  (list (read-file-name "Plan file: " local/plan-dir)))
  (find-file (expand-file-name plan-file local/plan-dir)))
  #+end_src

- keywords
  #+begin_src emacs-lisp
(with-eval-after-load 'org
  (customize-set-variable 'org-todo-keywords
                          '((sequence "TODO(t)" "INPROGRESS(i)" "|" "DONE(d)")
                            (sequence "WAITING(w)" "|")
                            (sequence "|" "CANCELLED(c)")))
  (customize-set-variable 'org-agenda-skip-scheduled-if-done t)
  (customize-set-variable 'org-agenda-skip-deadline-if-done  t)
  (require 'org-faces)
  (customize-set-variable 'org-todo-keyword-faces
                          '(("TODO"       :foreground "#7c7c75" :weight normal :underline t)
                            ("WAITING"    :foreground "#9f7efe" :weight normal :underline t)
                            ("INPROGRESS" :foreground "#0098dd" :weight normal :underline t)
                            ("DONE"       :foreground "#50a14f" :weight normal :underline t)
                            ("CANCELLED"  :foreground "#ff6480" :weight normal :underline t)))
  (customize-set-variable 'org-priority-faces
                          '((?A :foreground "#e45649")
                            (?B :foreground "#da8548")
                            (?C :foreground "#0098dd")))
  (custom-set-faces '(org-done ((t (:weight bold :strike-through t))))
                    '(org-headline-done ((((class color) (min-colors 16)
                                           (background dark)) (:strike-through t)))))

  )
  #+end_src
- clock
  #+begin_src emacs-lisp
(with-eval-after-load 'org
  (require 'org-clock)
  ;; Save the running clock and all clock history when exiting Emacs, load it on startup
  (customize-set-variable 'org-clock-persist t)
  ;; Resume clocking task on clock-in if the clock is open
  (customize-set-variable 'org-clock-in-resume t)
  ;; Change task state to INPROGRESS when clocking in
  (customize-set-variable 'org-clock-in-switch-to-state "INPROGRESS")
  ;; Separate drawers for clocking and logs
  (customize-set-variable 'org-drawers (quote ("PROPERTIES" "LOGBOOK")))
  ;; Sometimes I change tasks I'm clocking quickly - this removes clocked tasks with 0:00 duration
  (customize-set-variable 'org-clock-out-remove-zero-time-clocks t)
  ;; Clock out when moving task to a done state
  (customize-set-variable 'org-clock-out-when-done t)
  ;; Enable auto clock resolution for finding open clocks
  (customize-set-variable 'org-clock-auto-clock-resolution (quote when-no-clock-is-running))
  ;; Include current clocking task in clock reports
  (customize-set-variable 'org-clock-report-include-clocking-task t)
  (customize-set-variable 'org-clock-continuously nil)
  (customize-set-variable 'org-clock-persist-file (expand-file-name (format "%s/emacs/org-clock-save.el" xdg-cache)))
  (customize-set-variable 'org-show-notification-handler (lambda (msg) (alert msg)))
  (add-hook 'kill-emacs-hook #'org-clock-save)

  (defun local/start-task ()
    (interactive)
    (let ((current-prefix-arg 4))
      (call-interactively 'org-clock-in)))
  )
  #+end_src
- contacts
  #+begin_src emacs-lisp
(with-eval-after-load 'org
  (require 'org-contacts)
  (customize-set-variable 'org-contacts-files (list local/contacts-file)))
  #+end_src

**** agenda menu

#+begin_src emacs-lisp
(transient-define-prefix local/agenda-menu ()
  "agenda menu"
  [["View"
    ("a" "agenda" org-agenda-list)
    ("D" "day" org-agenda-day-view)
    ("W" "week" org-agenda-week-view)
    ("M" "month" org-agenda-month-view)]
   ["Agenda"
    ("r" "refile" org-refile)
    ("s" "schedule" org-schedule)
    ("t" "todo" org-todo)]
   ["Clock"
    ("i" "in" org-agenda-clock-in)
    ("o" "out" org-agenda-clock-out)
    ("c" "cancel" org-clock-cancel)]
   ["Files"
    ("b" "backlog" find-backlog)
    ("f" "find plan file" local/get-plan)
    ("p" "pers" goto-pers)
    ("w" "work" goto-work)]])
#+end_src

*** Ent

#+begin_src emacs-lisp
(use-package ent
  :ensure t
  :vc (:url "https://github.com/dpom/ent" :lisp-dir "lisp")
  :demand t)

(defalias 'convert-ent
  (kmacro "C-s t a s k <return> f : <return> <escape> u <backspace> w M-\" f ' <backspace> d d <return> i : d o c SPC M-c t <backspace> <escape> f \" 1 <left> <return> i : a c t i o n SPC <escape>"))

#+end_src

*** Git

- use magit
  #+begin_src emacs-lisp
(use-package magit
  :ensure t
  :demand t
  :commands (magit-status magit-blame)
  ;; :hook
  ;; (magit-pre-refresh . diff-hl-magit-pre-refresh)
  ;; (magit-post-refresh . diff-hl-magit-post-refresh)
  )

(use-package diff-hl
  :ensure t
  :commands (diff-hl-mode diff-hl-dired-mode)
  ;; :autoload (diff-hl-magit-pre-refresh diff-hl-magit-post-refresh)
  :hook
  ((prog-mode conf-mode) . diff-hl-mode))

(use-package smerge-mode
    :ensure nil
  :commands smerge-mode)
  #+end_src
- see the changes made by previous commits.
  #+begin_src emacs-lisp
(use-package git-timemachine
    :ensure t)
  #+end_src
- github API:
  #+begin_src emacs-lisp
  (use-package forge
    :ensure t
    :demand t
    :after magit
    :custom
    (forge-database-file (expand-file-name "forge-database.sqlite" emacs-cache-dir)))
;; (with-eval-after-load 'magit
;;   (require 'forge))
  #+end_src
*** Docker/Podman

- docker mode
  #+begin_src emacs-lisp
(defcustom lemacs-docker-executable 'docker
  "The executable to be used with docker-mode."
  :type '(choice
           (const :tag "docker" docker)
           (const :tag "podman" podman))
  :group 'lemacs)

(use-package docker
  :defer t
  :ensure t
  :bind ("C-c d" . docker)
  :config
  (pcase lemacs-docker-executable
    ('docker
     (setf docker-command "docker"
           docker-compose-command "docker-compose"))
    ('podman
     (setf docker-command "podman"
           docker-compose-command "podman-compose"))))

(use-package dockerfile-mode
  :defer t
  :ensure t
  :config
  (pcase lemacs-docker-executable
    ('docker
     (setq dockerfile-mode-command "docker"))
    ('podman
     (setq dockerfile-docker-command "podman"))))

  #+end_src
- install lsp with =lsp-install-server= =dockerfile-ls=

**** Reference

1. https://www.rahuljuliato.com/posts/emacs-docker-podman

*** Finance

- I use ledger for finance
  #+begin_src emacs-lisp
(use-package ledger-mode
  :ensure t
  :mode "\\.lgr\\'"
  :custom
   (ledger-use-iso-dates t)
   (ledger-reports '(("bal" "%(binary) -f %(ledger-file) bal")
                    ("bal this quarter" "%(binary) -f %(ledger-file) --period \"this quarter\" bal")
                    ("bal last quarter" "%(binary) -f %(ledger-file) --period \"last quarter\" bal")
                    ("reg" "%(binary) -f %(ledger-file) reg")
                    ("payee" "%(binary) -f %(ledger-file) reg @%(payee)")
                    ("account" "%(binary) -f %(ledger-file) reg %(account)"))))
  #+end_src

*** Credential Management (auth)

- auth sources:
  #+begin_src emacs-lisp
(setq auth-sources '(password-store
                     "~/.authinfo.gpg"))
  #+end_src
- I use [[https://www.passwordstore.org/][pass]] to manage all of my passwords locally
  #+begin_src emacs-lisp
(use-package pass
  :ensure t
  :demand t
  :commands pass
  :custom
   (pass-show-keybindings nil)
   (pass-username-fallback-on-filename t)
   :config
   (require 'password-store)
   (defun local/pass-kill-recursiv ()
     (interactive)
     (let ((entry (pass-directory-at-point)))
       (when (yes-or-no-p (format "Do you want remove the entry %s? " entry))
         (password-store-remove entry)
         (pass-update-buffer)))))
  #+end_src
- I also use [[https://github.com/DamienCassou/auth-password-store][auth-source-pass]] as the primary =auth-source= provider so that all passwords are stored in a single place.
  #+begin_src emacs-lisp
(require 'auth-source-pass)
(auth-source-pass-enable)
  #+end_src
- pinentry
  #+begin_src emacs-lisp
(use-package pinentry
  :ensure t
  :demand t
  :config
  (setq epa-pinentry-mode 'loopback)
  (when (fboundp 'pinentry-start)
    (pinentry-start)))
  #+end_src
- epa
  #+begin_src emacs-lisp
(require 'epa-file)
(epa-file-enable)
  #+end_src
- sops
  #+begin_src emacs-lisp :tangle no
(use-package sops
  :ensure t
  :demand t
  :bind (("C-c C-c" . sops-save-file)
         ("C-c C-k" . sops-cancel)
         ("C-c C-d" . sops-edit-file))
  :init
  (global-sops-mode 1))

  #+end_src
*** EMail
Dupa o cercetare prealabila am descoperit ca cel mai bun client de email este
=mu4e=. El este o interfata pentru =mu= care la randul lui este doar un motor de
cautare care lucreaza pe directoare de email (maildir). Exista mai multe
aplicatii care aduc email-urile local. S-ar parea (7) ca cea mai buna este
=mbsync=.

#+begin_src emacs-lisp
(use-package mu4e
  :ensure nil
  :custom
  (user-mail-address   "dan.pomohaci@pm.me")
  (user-full-name      "Dan Pomohaci")
  (mu4e-sent-folder    "/Proton/Sent")
  (mu4e-drafts-folder  "/Proton/Drafts")
  (mu4e-trash-folder   "/Proton/Trash")
  (mu4e-refile-folder  "/Proton/Archive")
  ;; Trimitere mesaje
  (message-send-mail-function 'smtpmail-send-it)
  (smtpmail-default-smtp-server  "127.0.0.1")
  (smtpmail-smtp-server  "127.0.0.1")
  (smtpmail-smtp-service  1025)

  ;; actualizare automata si indexare
  (mu4e-maildir "~/Maildir")
  (mu4e-get-mail-command "mbsync -V -a")
  (mu4e-update-interval (* 10 60) "update every 10 minutes")
  (mu4e-change-filenames-when-moving t "work better for mbsync")
  (mu4e-index-cleanup t)
  (mu4e-index-lazy-check nil)

  ;; setari interfata
  (mu4e-attachment-dir "~/Downloads")
  (mu4e-html2text-command "pandoc -f html -t plain")
  (mu4e-view-show-images t)
  (mu4e-show-images t)
  (mu4e-view-image-max-width 800)
  (mu4e-image-max-width 800)
  (mu4e-confirm-quit nil)
  (mu4e-headers-auto-update t)
  (mu4e-compose-signature-auto-include nil)
  (mu4e-sent-messages-behavior 'delete)
  (message-kill-buffer-on-exit t)
  (mu4e-compose-dont-reply-to-self t)
  (mu4e-view-show-addresses t)
  (mu4e-use-fancy-chars t)
  (mu4e-headers-results-limit 500)

  ;; bookmarks
  (mu4e-bookmarks '((:name  "Unread messages"
                            :query "flag:unread AND NOT flag:trashed"
                            :key ?u)
                    (:name "INBOX"
                           :query "maildir:/Proton/INBOX"
                           :key ?b)
                    (:name "Today's messages"
                           :query "maildir:/Proton/01_Plan_Today"
                           :key ?t)
                    (:name "Last week"
                           :query "maildir:/Proton/02_Plan_Week"
                           :key ?w)
                    (:name "Last month"
                           :query "maildir:/Proton/03_Plan_Month"
                           :key ?m)
                    (:name "Last year"
                           :query "maildir:/Proton/04_Plan_Year"
                           :key ?a)))
  ;; (mu4e-maildir-shortcuts '((:maildir "/gmail/INBOX" :key ?i)
  ;;                           (:maildir "/gmail/Spam"  :key ?s)
  ;;                           (:maildir "/drafts"      :key ?d)
  ;;                           (:maildir "/gmail/year"  :key ?a)
  ;;                           (:maildir "/gmail/month" :key ?m)
  ;;                           (:maildir "/gmail/week"  :key ?w)
  ;;                           (:maildir "/gmail/today" :key ?t)))
  )


;; (use-package mu4e-alert
;;   :ensure t
;;   :config
;;   (when (executable-find "notify-send")
;;     (mu4e-alert-set-default-style 'libnotify))
;;   (add-hook 'after-init #'mu4e-alert-enable-notifications)
;;   (add-hook 'after-init #'mu4e-alert-enable-mode-line-display)
;; ;; view
;; <<email-view>>
;; ;; compose
;; <<email-compose>>
;; ;; spell check
;; )
#+end_src

- better htmlize:
  #+begin_src emacs-lisp :tangle no
(use-package w3m
  :ensure t
  :after mu4e
    :custom
     (mu4e-html-renderer 'w3m)
    (mu4e-html2text-command "w3m -dump -T text/html"))
  #+end_src

- compose
  #+begin_src emacs-lisp :tangle no
;; (add-hook 'mu4e-compose-mode-hook
;;           (defun my-do-compose-stuff ()
;;             "My settings for message composition."
;;             (set-fill-column 72)
;;             (flyspell-mode)))
;; (setq message-send-mail-function 'smtpmail-send-it) ;; tell message-mode how to send mail


;; ;; if offline queuing the messages
;; (setq smtpmail-queue-mail nil  ;; start in queuing mode
;;       smtpmail-queue-dir   "~/Maildir/queue/cur")
  #+end_src

*** IRC


- use erc:
  #+begin_src emacs-lisp :tangle no
(use-package erc
  :ensure t
  :commands (erc)
  :custom
  (erc-server "irc.libera.chat")
  (erc-nick "dpom")
  (erc-user-full-name "Dan Pomohaci")
  (erc-track-shorten-start 8)
  (erc-autojoin-channels-alist '(("irc.libera.chat" "#systemcrafters" "#emacs")))
  (erc-kill-buffer-on-part t)
  (erc-auto-query 'bury)
  (erc-fill-column 120)
  (erc-fill-function 'erc-fill-static)
  (erc-fill-static-center 10)
  (erc-track-exclude '("#emacs"))
  (erc-track-exclude-types '("JOIN" "NICK" "QUIT" "MODE" "AWAY" "PART"))
  (erc-hide-list '("JOIN" "NICK" "QUIT" "MODE" "AWAY" "PART"))
  (erc-track-exclude-server-buffer t)
  :config
  (add-to-list 'erc-modules 'notifications))
  #+end_src
- colorize nicknames:
  #+begin_src emacs-lisp :tangle no
(use-package erc-hl-nicks
  :after erc
  :config
  (add-to-list 'erc-modules 'hl-nicks))
  #+end_src
- display images
  #+begin_src emacs-lisp :tangle no
(use-package erc-image
  :ensure t
  :after erc
  :config
  (setq erc-image-inline-rescale 300)
  (add-to-list 'erc-modules 'image))
  #+end_src
- emoji
  #+begin_src emacs-lisp :tangle no
(use-package emojify
  :ensure t
  :hook (erc-mode . emojify-mode)
  :commands emojify-mode)
  #+end_src
- activate modules
    #+begin_src emacs-lisp :tangle no
 (erc-update-modules)
    #+end_src

*** AI

- define a local group for ai:
  #+begin_src emacs-lisp
(defgroup ai nil
  "Local AI group."
  :tag "AI"
  :group 'local)

  #+end_src

**** gptel

- referinta :: [[roam:gptel]]

#+begin_src emacs-lisp
 (defun local/get-ollama-models ()
  "Return a list of ollama model names present in the system."
  (interactive)
 (let* ((output (shell-command-to-string "ollama list"))
         (lines (split-string output "\n" t))
         (models '()))
    ;; Skip the header line
    (dolist (line (cdr lines))
      (when (string-match "^\\([^ ]+\\)" line)

        (push (intern (match-string 1 line)) models)))
    (nreverse models)))

(defun local/get-gemini-key ()
    "Extrage cheia API pentru Gemini din ~/.authinfo"
    (let ((match (auth-source-search :host "api.google.com" :user "apikey")))
      (if match
          (let ((secret (plist-get (car match) :secret)))
            (if (functionp secret) (funcall secret) secret))
        (error "Nu am găsit cheia API în ~/.authinfo"))))

(use-package gptel
  :ensure t
  :demand t
  :commands (gptel gptel-send)
  :config
  (require 'subr-x)
  (setq gptel-playback t
        gptel-default-mode 'org-mode
        gptel-model 'gemma4:e4b
        gptel-default-model 'gemma4:e4b
        gptel-cache '(message system tool)
        gptel-track-media t
        gptel-ollama-backend (gptel-make-ollama "Ollama"
                        :host "localhost:11434"
                        :stream t
                        :models (local/get-ollama-models)))
  (gptel-make-gemini "Gemini"
    :stream t
    :key #'local/get-gemini-key
    :models '(gemini-2.5-flash
            gemini-2.5-pro))
  (setq gptel-backend gptel-ollama-backend))

  (with-eval-after-load 'gptel
      (global-set-key (kbd "<f5>") 'gptel-send)
      (global-set-key (kbd "<f6>") 'gptel-menu)
      (global-set-key (kbd "<f7>") 'gptel-abort)

      (require 'gptel-integrations))
  #+end_src
**** gptel-prompts

#+begin_src emacs-lisp
  (use-package gptel-prompts
    :after (gptel)
    :vc (:url "https://github.com/jwiegley/gptel-prompts")
    :ensure t
    :demand t
    :custom
    (gptel-prompts-directory (expand-file-name "ai-prompts/" local/pers-dir))
    :config
    (gptel-prompts-update))

#+end_src
**** ob-gptel

- reference :: https://github.com/jwiegley/ob-gptel
  #+begin_src emacs-lisp :tangle no
(use-package ob-gptel
  :after org
  :hook ((org-mode . ob-gptel-install-completions))
  :defines ob-gptel-install-completions
  :config
  (add-to-list 'org-babel-load-languages '(gptel . t))
  ;; Optional, for better completion-at-point
  (defun ob-gptel-install-completions ()
    (add-hook 'completion-at-point-functions
              'ob-gptel-capf nil t)))
#+end_src
**** emacs tools

- llm-tool-collections (https://github.com/skissue/llm-tool-collection)
  #+begin_src emacs-lisp
(use-package llm-tool-collection
  :ensure t
  :vc (:url "https://github.com/skissue/llm-tool-collection")
  :demand t
  :after gptel)
  #+end_src
- ragmacs (https://github.com/positron-solutions/ragmacs)
  #+begin_src emacs-lisp
(use-package ragmacs
  :ensure t
  :vc (:url "https://github.com/positron-solutions/ragmacs")
  :after gptel)
  #+end_src
- Return README for an Emacs package
  #+begin_src emacs-lisp
(with-eval-after-load 'gptel
  (defun local/extract-emacs-package-readme (package-name)
    "Extract and return the README file for package PACKAGE-NAME.
This version attempts to robustly find the source directory for
packages, including those managed by straight.el.
Return =nil' if no README was found."
    (if (stringp package-name)
        (let* (;; 1. Get the path to the library file as Emacs knows it (e.g., .../straight/build/PKG/PKG.el)
               (library-file-in-load-path (find-library-name package-name))

               ;; 2. Get the canonical, true path to this library file.
               ;; For straight.el, if library-file-in-load-path is a symlink like
               ;; .../build/PKG/PKG.el -> .../repos/PKG/PKG.el,
               ;; this will resolve to .../repos/PKG/PKG.el.
               (true-library-file-path (when library-file-in-load-path
                                         (file-truename library-file-in-load-path)))

               ;; 3. Get the directory containing the true library file.
               ;; This should be the actual source directory (e.g., .../straight/repos/PKG/).
               (package-source-dir (when true-library-file-path
                                     (file-name-directory true-library-file-path)))

               ;; 4. Locate the README within this source directory using your helper.
               ;; local/locate-readme-in-directory returns an absolute path.
               (readme-full-path (when (and package-source-dir (file-directory-p package-source-dir))
                                   (local/locate-readme-in-directory package-source-dir))))

          (if readme-full-path
              (with-temp-buffer
                (goto-char (point-min))
                (insert (format "README file for package %s (from directory %s):\n\n"
                                package-name
                                ;; Show the directory where the README was actually found
                                (file-name-directory readme-full-path))) ; This is package-source-dir
                (insert-file-contents readme-full-path)
                (buffer-string))
            (progn
              ;; More detailed warning for debugging
              (warn (format (concat "No README file found for package '%s'.\n"
                                    "  Searched in directory: %s\n"
                                    "  Library file in load-path: %s\n"
                                    "  Resolved true library file path: %s")
                            package-name
                            (or package-source-dir "unknown or not a directory")
                            (or library-file-in-load-path "not found by find-library-name")
                            (or true-library-file-path "could not be resolved by file-truename")))
              nil)))
      (progn
        (warn "PACKAGE-NAME argument must be the package name as a string.")
        nil)))

  (gptel-make-tool
   :name "emacs_package_readme"
   :description "Return the README file for a package - please use this to understand what a package does prior to deciding whether to pull the package source code."
   :category "emacs"
   :include t
   :function #'local/extract-emacs-package-readme
   :args (list '(:name "package_name"
                       :type string
                       :description "Name of the Emacs package."
                       :optional nil))))
#+end_src
- Search for and return source code for an Emacs package:
  #+begin_src emacs-lisp
(with-eval-after-load 'gptel
  (defun local/extract-emacs-package-source (package &optional FULL)
    "Extract and return a simple structured text document with the primary source for package PACKAGE.
If FULL is not nil, return all source files."
    (if (stringp package)
        (let* ((library-path (find-library-name package))
               (all-elisp (directory-files (f-dirname library-path) t ".*\\.el\\(\\.gz\\)?$")))
          (with-temp-buffer
            ;; run through the list of .el files
            ;; start with the "primary" .el file, returned by =find-library-name=

            (goto-char (point-min))
            (insert (format "\n* file %s (primary)\n" library-path))
            (insert (concat "#+begin" "_src emacs-lisp\n"))
            (insert-file library-path)
            (goto-char (point-max))
            (insert (concat "\n#+end" "_src\n"))
            (when FULL
              (dolist (file (remove library-path all-elisp))
                (insert (format "\n* file %s\n" file))
                (insert (concat "#+begin" "_src emacs-lisp\n"))
                (insert-file file)
                (goto-char (point-max))
                (insert (concat "\n#+end" "_src\n"))))
            (buffer-string)))
      (warn "PACKAGE must be the package name as a string.")))

  (gptel-make-tool
   :name "emacs_package_source"
   :description "Fetch all source code for the given Emacs package, using `find-library'."
   :category "emacs"
   :include nil
   :function #'local/extract-emacs-package-source
   :args (list '(:name "package_name"
                       :type string
                       :description "Name of the Emacs package."
                       :optional nil)
               '(:name "full_source"
                       :type boolean
                       :description "If true/t, return source from ALL source code files in the package, not just the primary source file. Let this default in most cases to save on tokens!"
                       :optional t))))
#+end_src
- Return function source:
  #+begin_src emacs-lisp
(with-eval-after-load 'gptel
  (defun local/extract-function-source (function-name)
    "Extract and return the source code of a callable FUNCTION-NAME, if possible."
    (when (fboundp (intern function-name))
      (let ((source))
        (condition-case err
            ;; `find-function-noselect' returns the buffer and position.
            (let ((buf-pos (find-function-noselect (intern function-name))))
              (when buf-pos
                (let ((buffer (car buf-pos))
                      (pos (cdr buf-pos)))
                  (with-current-buffer buffer
                    (save-excursion
                      (goto-char pos)
                      (let ((start (point)))
                        ;; Move to the end of the function definition.
                        (end-of-defun)
                        ;; Extract source code.
                        (setq source (buffer-substring-no-properties start (point)))))))))
          (error
           ;; Handle errors gracefully by printing a message.
           (message "Error finding source for %s: %s" function-name (error-message-string err))))
        source)))

  ;; Usage example
  ;; (my-extract-callable-source 'your-function-name)

  (gptel-make-tool
   :name "emacs_function_source"
   :include t
   :function #'local/extract-function-source
   :description "Return source code for Emacs functions, be they written in Emacs Lisp (Elisp) or C"
   :category "emacs"
   :args (list '(:name "function_name"
                       :type string
                       :description "the function name"
                       :optional nil))))
#+end_src
- Return Emacs variable value and documentation
  #+begin_src emacs-lisp
(with-eval-after-load 'gptel
  (get 'gptel-tools 'variable-documentation)

  (gptel-make-tool
   :name "emacs_variable_properties"
   :include t
   :function (lambda (variable)
               (let ((variable (if (symbolp variable)
                                   variable
                                 (intern variable)
                                 )))
                 (if (boundp variable)
                     (symbol-plist variable)
                   (format "Variable %s is not bound" variable))))

   :description "Get properties on an Emacs variable.  Use this to get documentation string for variables, as well as more obscure properties such as safety as local variable etc."
   :category "emacs"
   :args (list '(:name "variable"
                       :type string
                       :description "the symbol"))))
#+end_src
- Summarize all installed Info manuals
  #+begin_src emacs-lisp
(with-eval-after-load 'gptel
  (defun local/get-info-manuals-with-description ()
    "Return text of all Info manuals with their simple descriptions.
This is what you see when you evoke C-h i or run (info)."
    (with-temp-buffer
      (Info-insert-dir)
      (buffer-substring-no-properties (point-min) (point-max))))

  (gptel-make-tool
   :name "emacs_info_manuals"
   :include nil
   :function #'local/get-info-manuals-with-description
   :description "Get text showing all known Info manuals with their description. Format is human-readable manual name, info manual short file name in parens, description."
   :category "emacs"))
#+end_src
- Find list of man pages on system:
  #+begin_src emacs-lisp
(with-eval-after-load 'gptel
  (defun local/list-linux-man-pages (&optional s)
    "Return text showing installed Linux man pages with descriptions - optionally provide a substring match to limit the number of results."
    (let ((s (or s ""))
          (shell-command-dont-erase-buffer nil))
      (with-current-buffer "*man-pages*"
        (delete-region (point-min) (point-max))
        (shell-command (format "LANG=en_US.UTF-8 /usr/bin/man -k \"%s\"" s) t)
        (buffer-string)
        )))

  (gptel-make-tool
   :name "list_man_pages"
   :description "Return list of installed Linux man pages with descriptions - optionally provide a substring match to limit the number of results."
   :include nil
   :function #'local/list-linux-man-pages
   :category "emacs"
   :args (list '(:name "search_substring"
                       :type string
                       :optional t
                       :description "A substring to limit results of all man pages.  e.g. \"media\" or \"office\""))))
#+end_src
- Cheat sheet for Org Mode syntax:
  #+begin_src emacs-lisp
(with-eval-after-load 'gptel
  (gptel-make-tool
   :name "org_mode_cheatsheet"
   :description "Quick and easy to read cheat sheet for Org Mode syntax - refer to this whenever you start a project or session requiring org mode syntax production, and whenver you want to make use of advanced features."
   :include t
   :function (lambda ()
               (with-temp-buffer
                 (insert-file-contents "~/pers/ai-prompts/org-mode-syntax-cheat-sheet-for-llms.txt")
                 (buffer-string)))
   :category: "emacs"))
#+end_src

**** mcp

- referinta ::  [[id:ade17774-4c86-4731-a90b-e5fb6ae4396e][mcp]]
  #+begin_src emacs-lisp
(use-package mcp
  :ensure t
  :demand t
  :after gptel
  :custom (mcp-hub-servers
           `(("clj" .
              (:command "clojure"
               :args ("-Sdeps",
               (concat "{:deps"
                       " {"
                       " org.slf4j/slf4j-nop {:mvn/version \"2.0.16\"}"
                       " com.bhauman/clojure-mcp {:git/url \"https://github.com/bhauman/clojure-mcp\" :git/sha \""
                       "89feeb0be877e06e129aa84ce16522f8b0a36c38" ; mcp sha code
                       "\"}}"
                       " :aliases {:mcp {:exec-fn clojure-mcp.main/start-mcp-server}}}"),
                "-X:mcp",
                ":port",
                "7888")))
             ("github" .
               (:command "docker"
                :args ("run" "-i" "--rm"
                         "-e" "GITHUB_PERSONAL_ACCESS_TOKEN"
                         "ghcr.io/github/github-mcp-server")
                :env (:GITHUB_PERSONAL_ACCESS_TOKEN ,(lambda () (auth-source-pass-get 'secret "github.com/personal-api-key")))))
              ("duckduckgo" . (:command "uvx" :args ("duckduckgo-mcp-server")))
              ("nixos" . (:command "nix" :args ("run" "github:utensils/mcp-nixos" "--")))
              ("fetch" . (:command "uvx" :args ("mcp-server-fetch")))
              ("filesystem" . (:command "npx" :args ("-y" "@modelcontextprotocol/server-filesystem" ,(getenv "HOME"))))
              ("sequential-thinking" . (:command "npx" :args ("-y" "@modelcontextprotocol/server-sequential-thinking")))
             ))
  :config (require 'mcp-hub))
  #+end_src

**** gptel presets

- helper
  #+begin_src emacs-lisp
(defun get-ai-prompt (filename)
      (with-temp-buffer
        (insert-file-contents filename)
        (buffer-string)))

  #+end_src
- introspection:
  #+begin_src emacs-lisp
(with-eval-after-load 'gptel
  (gptel-make-preset 'introspect
    :pre (lambda () (require 'ragmacs))
    :system (get-ai-prompt (expand-file-name "introspection.md" gptel-prompts-directory))
    :tools '("introspection")))
  #+end_src
- ollama:
  #+begin_src emacs-lisp
(with-eval-after-load 'gptel
  (gptel-make-preset 'ollama
    :description "ollama"
    :pre (lambda () (require 'llm-tool-collection))
    :backend "Ollama"
    :model 'gpt-oss:latest
    :highlight-mode 't
    :confirm-tool-calls 'auto
    :include-tool-results 't)
  )
  #+end_src
- elisp-help:
  #+begin_src emacs-lisp
(with-eval-after-load 'gptel
  (gptel-make-preset 'elisp
    :description "helper for elisp"
    :pre (lambda () (progn
            (require 'llm-tool-collection)
            (require 'ragmacs)))
    :backend "Ollama"
    :model 'gpt-oss:latest
    :system "You are an Emacs maven. Reply only with the most appropiate built-in Emacs or cl-lib command for the task I specify. Do NOT generate any additional details or comments."
    :tools '("emacs" "introspection")
    :confirm-tool-calls nil
    :include-reasoning nil                ;sets gptel-include-reasoning
    :include-tool-results nil)
  )

  #+end_src
- codex:
  #+begin_src emacs-lisp
(with-eval-after-load 'gptel
  (gptel-make-preset 'codex
    :description "local coding agent"
    :pre (lambda () (require 'llm-tool-collection))
    :backend "Ollama"
    :model 'qwen2.5-coder:latest
    :system "You are Codex, a highly capable coding agent. Help the user
write correct, idiomatic, well-structured code. When asked to implement
something, think step by step, consider edge cases, and provide complete
solutions. Use the available tools to search, read, and understand the
codebase before making changes."
    :highlight-mode 't
    :confirm-tool-calls 'auto
    :include-tool-results 't)
  )
  #+end_src
- commit message:
  #+begin_src emacs-lisp
(with-eval-after-load 'gptel
  (defcustom local/commit-msg-system
    "You generate Git commit messages from diffs. Analyze the diff carefully and describe what changed and why.

Format: conventional commits: type(scope): subject

<body>

Types: feat, fix, docs, style, refactor, perf, test, build, ci, chore, revert.

Rules:
- Subject: max 50 chars, imperative mood, no period
- Body: wrap at 72 chars, explain motivation
- Output ONLY the commit message, nothing else"
    "System prompt for git commit message generation."
    :type 'string
    :group 'ai)

  (gptel-make-preset 'commit-message
    :description "preset for commit messages"
    :backend "Ollama"
    :model 'qwen2.5-coder:7b
    :system local/commit-msg-system
    :stream 't
    :temperature 0.7)

(defun local/generate-commit-message ()
  "Generate a git commit message from staged changes via gptel/Ollama.
Inserts the generated message at point."
  (interactive)
  (let* ((git-root-dir (locate-dominating-file default-directory ".git"))
         (diff (when git-root-dir
                 (shell-command-to-string "git diff --cached"))))
    (unless git-root-dir
      (user-error "Not inside a Git repository"))
    (when (string-empty-p diff)
      (user-error "No staged changes to commit"))
    (let* ((gptel-buf (get-buffer-create "*gptel-commit-msg*")))
      (with-current-buffer gptel-buf
        (setq-local gptel-backend (gptel-get-backend "Ollama"))
        (setq-local gptel-model 'qwen2.5-coder:7b))
      (gptel-request
          (format "Generate a commit message for this diff:\n\n%s" diff)
        :buffer gptel-buf
        :system local/commit-msg-system
        :context (current-buffer)
        :callback (lambda (response info)
                    (if (stringp response)
                        (with-current-buffer (plist-get info :context)
                          (insert response))
                      (message "gptel error: %s"
                               (plist-get info :status)))))))))
  #+end_src

**** gptel-quick


#+begin_src emacs-lisp :tangle no
(use-package posframe
  :ensure t)

(use-package gptel-quick
  :ensure t
  :after gptel
  :commands (gptel-quick))

(global-set-key (kbd "C-<f5>") 'gptel-quick)

#+end_src

**** gptel-agent

#+begin_src emacs-lisp
(use-package gptel-agent
  :ensure t
  :after gptel
  :config (gptel-agent-update))         ;Read files from agents directories

  #+end_src

**** eca

- referinta :: https://github.com/editor-code-assistant/eca-emacs

#+begin_src emacs-lisp
(use-package eca
  :ensure t
  :demand t
  :config
  (setq eca-extra-args '("--verbose")))
#+end_src

**** Traducator

- un traducator automat bidirectional RO <-> EN:
  #+begin_src emacs-lisp
(with-eval-after-load 'gptel
  ;; modele de llm: TranslateGemma:4b llama3.1:8b
  (defcustom local/translate-llm "TranslateGemma:4b"
    "LLM for translations."
    :type 'string
    :group 'ai)

  (defun local/translate (replace)
    "Automatically translate between RO and EN using Ollama.
With a prefix (C-u), replace the selected region."
    (interactive "P")
    (if (use-region-p)
        (let* ((text (buffer-substring-no-properties (region-beginning) (region-end)))
               (system-msg "You are a professional translator. The text is in Romanian and translate it to English.  Provide ONLY the English translation, no chatter.")
               ;; Setăm modelul aici
               (gptel-model local/translate-llm)
               (gptel-backend (gptel-get-backend "Ollama")))
          (gptel-request text
            :system system-msg
            :callback (lambda (response info)
                        (if response
                            (with-current-buffer (plist-get info :buffer)
                              (delete-region (region-beginning) (region-end))
                              (insert response))
                          (message "Error: %s" info)))))
    (message "Please select a text first!"))))
  #+end_src

**** org-mode format directive

#+begin_src emacs-lisp
(defcustom local/response-format
  (concat "Format all the response exclusively in org-mode syntax\n"
          "- Use titles with asterisks (*, **, ***).\n"
          "- Use code blocks like " (format "#+begin%src clojure ... #+end%src" "_" "_") " for examples.\n"
          "- Use Org tables for performance comparisons if applicable.\n"
          "- Put keywords between tildes (~code~).")
  "Fragment of the system prompt to format the response."
  :type 'string
  :group 'ai)
#+end_src
**** agent-shell

#+begin_src emacs-lisp
(use-package agent-shell
  :ensure t
  :demand t
  :vc (:url "https://github.com/xenodium/agent-shell")
  :config
  (setq agent-shell-google-authentication
      (agent-shell-google-make-authentication :login t))
  (setq agent-shell-prefer-viewport-interaction t))
#+end_src
**** specific menu

#+begin_src emacs-lisp
(with-eval-after-load 'transient
  (transient-define-prefix local/ai-menu ()
    "ai menu"
    [["agent-shell"
      ("aa" "agent" agent-shell)
      ("ad" "add-dwim" agent-shell-send-dwim)
      ("ae" "edit prompt" agent-shell-prompt-compose)
      ("af" "add file" agent-shell-send-file)
      ("ar" "add-region" agent-shell-send-region)]
      ["gptel"
      ("d" "add" gptel-add)
      ("f" "add file" gptel-add-file)
      ("u" "main" gptel)
      ("m" "menu" gptel-menu)
      ;; ("o" "org prop" gptel-org-set-properties)
      ("q" "quit" gptel-abort)
      ("r" "rewrite" gptel-rewrite)
      ("s" "send" gptel-send)
      ;; ("t" "topic" gptel-org-set-topic)
      ]
     ["mcp"
      ("ps" "start" mcp-hub-start-all-server)
      ("pc" "connect" gptel-mcp-connect)
      ("po" "close" mcp-hub-close-all-server)
      ("pl" "log" mcp-hub-view-log)]]))
  #+end_src

*** pdf-tools

- pdf-tools: https://github.com/vedang/pdf-tools
  #+begin_src emacs-lisp
(use-package pdf-tools
  :ensure t
  :demand t
  :mode ("\\.pdf\\'" . pdf-view-mode)
  :config
  ;; Activează pdf-tools. :no-query evită întrebările despre compilare pe NixOS
  (pdf-tools-install :no-query)
  ;; Opțional: afișează PDF-ul adaptat lățimii paginii implicit
  (setq-default pdf-view-display-size 'fit-page)
  (setq pdf-annot-activate-created-annotations t)
  (define-key pdf-view-mode-map (kbd "G") 'pdf-view-goto-page)
  (define-key pdf-view-mode-map (kbd "!") 'pdf-view-position-to-register)
  (define-key pdf-view-mode-map (kbd "@") 'pdf-view-jump-to-register))
  #+end_src

*** RSS

- elfeed:
  #+begin_src emacs-lisp
  (use-package elfeed
    :ensure t
    :demand t
    :custom
    (elfeed-db-directory
     (expand-file-name "elfeed" emacs-cache-dir))
     (elfeed-show-entry-switch 'display-buffer))
  #+end_src
- Configure Elfeed with org mode
  #+begin_src emacs-lisp
  (use-package elfeed-org
    :ensure t
    :demand t
    :config
    (elfeed-org)
    :custom
    (rmh-elfeed-org-files (list (expand-file-name "elfeed.org" local/private-dir))))

  #+end_src
- Scoring the articles
  #+begin_src emacs-lisp
(use-package elfeed-score
  :ensure t
  :after elfeed
  :config
  ;; 1. Activează motorul de calcul al scorurilor
  (elfeed-score-enable)

  ;; 2. Indică-i pachetului de unde să încarce fișierul tău cu reguli
  (elfeed-score-load-score-file (expand-file-name "elfeed.score" local/private-dir))

  ;; 3. (Opțional dar recomandat) Înlocuiește funcția standard de afișare
  ;; pentru a arăta scorul fiecărui articol direct în lista elfeed-search
  (setq elfeed-search-print-entry-function #'elfeed-score-print-entry)

  ;; 4. Adaugă o scurtătură în interfața de căutare pentru a apela meniul elfeed-score
  (define-key elfeed-search-mode-map "=" elfeed-score-map))
  #+end_src

* Programming
** Implementation
:PROPERTIES:
:header-args: :tangle modules/home/emacs/init.el
:END:
*** Common
**** direnv

- direnv support (https://github.com/wbolster/emacs-direnv):
  #+begin_src emacs-lisp
(use-package direnv
  :ensure t
  :demand t
  :config
  (direnv-mode))
  #+end_src

**** Automatically clean whitespace

- cleanup space only on writing the buffer (remove cleanup set by rational-editing module)
  #+begin_src emacs-lisp
(customize-set-variable 'whitespace-action '(auto-cleanup))
(add-hook 'before-save-hook 'whitespace-cleanup)
  #+end_src

**** Documentation

#+begin_src emacs-lisp
(use-package eldoc
  :demand t
  :config
  (global-eldoc-mode)
  (keymap-set help-map "k" #'eldoc-doc-buffer))
#+end_src

- generic help system
  #+begin_src emacs-lisp
(use-package helpful
  :ensure t
  :demand t
  :bind
  (:map help-map
        ("h" . helpful-at-point)
        ("C" . helpful-command)
        ("M" . helpful-macro)))
#+end_src
- lookup documentation via DevDocs.
#+begin_src emacs-lisp
(use-package devdocs
  :ensure t
  :bind
  (:map goto-map ("K" . devdocs-lookup)))
#+end_src

**** Parentheses
- auto-insert
  #+begin_src emacs-lisp
(electric-pair-mode 1) ; auto-insert matching bracket
  #+end_src
- show matching parens
  #+begin_src emacs-lisp
(show-paren-mode 1)    ; turn on paren match highlighting
(customize-set-variable 'show-paren-when-point-inside-paren t)
(customize-set-variable 'show-paren-when-point-in-periphery t)
(add-hook 'prog-mode-hook 'show-paren-mode)
(setq show-paren-context-when-offscreen t)
  #+end_src
- rainbow-delimiters is a "rainbow parentheses"-like mode which highlights
  delimiters such as parentheses, brackets or braces according to their
  depth. Each successive level is highlighted in a different color. This makes
  it easy to spot matching delimiters, orient yourself in the code, and tell
  which statements are at a given depth.
  #+begin_src emacs-lisp
(use-package rainbow-delimiters
  :ensure t
  :vc (:url "https://github.com/Fanael/rainbow-delimiters")
  :demand t
  ;; :commands rainbow-delimiters-mode
  :custom (rainbow-delimiters-max-face-count 5)
  :config
  (add-hook 'prog-mode-hook  'rainbow-delimiters-mode))
  #+end_src

**** Indent Guides

- Show indent guides. Similar to the package included with doom but allows indent guide characters instead of just setting the background Link [[github:DarthFennec/highlight-indent-guides][DarthFennec/highlight-indent-guides]]
  #+BEGIN_SRC emacs-lisp
(defun local/enable-indent-guides-safely ()
  "Activează highlight-indent-guides, exceptând bufferele invizibile org-src."
  (unless (string-match-p "\\` \\*org-src-fontification" (buffer-name))
    (highlight-indent-guides-mode 1)))

(use-package highlight-indent-guides
  :ensure t
  :demand t
  ;; Am înlocuit apelul direct cu funcția noastră de siguranță
  :hook (prog-mode . local/enable-indent-guides-safely)
  :custom
  (highlight-indent-guides-method 'character) ; use characters for indent guidesg
  (highlight-indent-guides-responsive t); highlight indentation based on current line
  (highlight-indent-guides-character ?\|); set character
  (highlight-indent-guides-auto-enabled 'top))
  #+END_SRC
- agrresive indent
  #+begin_src emacs-lisp
(use-package aggressive-indent
  :ensure t
  :config
  ;; (global-aggressive-indent-mode 1)
  (add-to-list 'aggressive-indent-excluded-modes 'python-mode)
  (add-to-list 'aggressive-indent-excluded-modes 'python-ts-mode)
  )
  #+end_src

**** Compilation

Set up the =compile= package and ensure that compilation output automatically scrolls.

#+begin_src emacs-lisp
(use-package compile
  :custom (compilation-scroll-output t))
#+end_src

**** Tree-sitter

- set tree-siter

  #+begin_src emacs-lisp
(use-package treesit-auto
  :ensure t
  :demand t
  :custom
  (treesit-auto-install nil)
  :config
  (treesit-auto-add-to-auto-mode-alist 'all)
  (global-treesit-auto-mode))


(dolist (mapping
           '((bash-mode . bash-ts-mode)
             (c++-mode . c++-ts-mode)
             (c-mode . c-ts-mode)
             (conf-toml-mode . toml-ts-mode)
             (css-mode . css-ts-mode)
             (css-mode . css-ts-mode)
             (go-mode . go-ts-mode)
             (html-mode. html-ts-mode)
             (js-json-mode . json-ts-mode)
             (js2-mode . js-ts-mode)
             (json-mode . json-ts-mode)
             (python-mode . python-ts-mode)
             (rust-mode . rust-ts-mode)
             (typescript-mode . typescript-ts-mode)
             (yaml-mode . yaml-ts-mode)))
    (add-to-list 'major-mode-remap-alist mapping))

(setq treesit-extra-load-path
      (list (expand-file-name "tree-sitter" user-emacs-directory)
            ;; Adaugă calea din profilul tău Nix (valabil pentru Home Manager sau System)
            "/run/current-system/sw/lib/tree-sitter"
            "~/.nix-profile/lib/tree-sitter"))

(defun run-non-ts-hooks ()
  (let ((major-name (symbol-name major-mode)))
    (when (string-match-p ".*-ts-mode" major-name)
      (run-hooks (intern (concat (replace-regexp-in-string "-ts" "" major-name) "-hook"))))))

(add-hook 'prog-mode-hook 'run-non-ts-hooks)
(setq treesit-font-lock-level 4)
  #+end_src
- evalueaza expresia si lanseaza =M-x treesit-install-language-grammar= sau
  #+begin_src emacs-lisp :tangle no
(mapc #'treesit-install-language-grammar (mapcar #'car treesit-language-source-alist))
  #+end_src

**** Folding

- hideshow
  #+begin_src emacs-lisp
(use-package hideshow
  :ensure nil
  :functions
  (hs-fold-overlay-ellipsis)
  :hook
  (prog-mode . hs-minor-mode)
  :init
  (setq hs-hide-comments-when-hiding-all nil)
  (setq hs-allow-nesting t)
  (setq hs-set-up-overlay #'hs-fold-overlay-ellipsis)
  :config
  (defun hs-fold-overlay-ellipsis (ov)
    (when (eq 'code (overlay-get ov 'hs))
      (overlay-put
       ov 'display (propertize " … " 'face 'font-lock-comment-face))))
  (defun local/toggle-fold ()
    (interactive)
    (save-excursion
      (end-of-line)
      (hs-toggle-hiding)))
  (defun local/hide-level ()
    (interactive)
    (hs-hide-level 1)))
  #+end_src

- fold-dwim
  #+begin_src emacs-lisp
(use-package fold-dwim
  :ensure t
  :demand t
  :config
  (global-set-key (kbd "<f8>")      'fold-dwim-toggle)
  (global-set-key (kbd "<M-f8>")    'fold-dwim-hide-all)
  (global-set-key (kbd "<S-M-f8>")  'fold-dwim-show-all))
  #+end_src

- ts-fold
  #+begin_src emacs-lisp :tangle no
;; (use-package tree-sitter
;;   :ensure t)
(use-package treesit-fold
  :ensure t
  :hook
  (prog-mode-hook . treesit-fold-mode)
  :config
  (global-set-key (kbd "<f8>")      'treesit-fold-toggle)
  (global-set-key (kbd "<M-f8>")    'treesit-fold-hide-all)
  (global-set-key (kbd "<S-M-f8>")  'treesit-fold-show-all))
  #+end_src



***** References
1. http://wikemacs.org/wiki/Folding
2. [[https://github.com/gregsexton/origami.el][origami]]
3. https://www.reddit.com/r/emacs/comments/9vy257/fastest_code_folding_mode/
4. https://github.com/alexmurray/evil-vimish-fold

**** Linters

- flycheck
  #+begin_src emacs-lisp
(use-package flycheck
  :ensure t
  :demand t
  :commands (flycheck-previous-error
             flycheck-next-error
             flycheck-first-error)
  :config
  (global-flycheck-mode)
  (setq-default flycheck-disabled-checkers '(org-lint)))
  #+end_src

**** Formaters

- apheleia
  #+begin_src emacs-lisp
(use-package apheleia
  :ensure t
  :demand t
  :config
  ;; 1. Define the elisp-autofmt command for Apheleia
  ;; We use 'inplace' or 'stdout' flags if the tool supports them
  (setf (alist-get 'elisp-autofmt apheleia-formatters)
        '("elisp-autofmt" "--stdin" "--stdout"))

  ;; 2. Map the major mode to our new formatter
  (setf (alist-get 'emacs-lisp-mode apheleia-mode-alist) 'elisp-autofmt)
(dolist (formatter '((nix . ("nix" "fmt" "--" "-"))
                       (xmllint . ("xmllint" "--format" "-"))
                       (rufo . ("rufo" "--simple-exit"))))
    (cl-pushnew formatter apheleia-formatters :test #'equal))
  (apheleia-global-mode +1))

(add-to-list 'safe-local-variable-values '(apheleia-formatter . treefmt))
  #+end_src

**** jump (xref)

- display line number:
  #+begin_src emacs-lisp
(add-hook 'prog-mode-hook 'display-line-numbers-mode)
  #+end_src
- settings
  #+begin_src emacs-lisp
(use-package xref
  :commands
  (xref-show-definitions-completing-read)
  :bind
  (:map goto-map ("o" . xref-find-definitions-other-window))
  :config
  (setq xref-search-program 'ripgrep)
  (remove-hook 'xref-backend-functions #'etags--xref-backend))
  #+end_src
- don't ask about keeping current list of tags tables.
#+begin_src emacs-lisp
(use-package etags
  :init
  (setq tags-add-tables nil))
#+end_src
- dumb-jump
#+begin_src emacs-lisp
(use-package dumb-jump
  :ensure t
  :hook
  (xref-backend-functions . dumb-jump-xref-activate)
  :init
  (setq dumb-jump-default-project user-emacs-directory)
  (setq dumb-jump-selector 'completing-read))
#+end_src

- specific menu
  #+begin_src emacs-lisp
(with-eval-after-load 'transient
  (transient-define-prefix local/jump-menu ()
      "jump menu"
      [("a" "apropos" xref-find-apropos)
       ("b" "back" xref-go-back)
       ("d" "definition" xref-find-definitions)
       ("g" "first-error" flycheck-first-error)
       ("j" "next-ref" xref-next-line)
       ("k" "prev-ref" xref-prev-line)
       ("r" "references" xref-find-references)
       ;; ("p" "prev-error" flymake-goto-prev-error)
       ("p" "prev-error" flycheck-previous-error)
       ("o" "open" org-open-at-point)
       ;; ("n" "next-error" flymake-goto-next-error)
       ("n" "next-error" flycheck-next-error)
       ("N" "ns" cider-find-ns)]))
  #+end_src

**** Language Server Support (LSP)

***** lsp-mode

    #+begin_src emacs-lisp
(use-package lsp-mode
    :ensure t
    :demand t
    :hook (lsp-mode . lsp-enable-which-key-integration)
    :config
    ;; (add-hook 'prog-mode-hook
    ;;         (lambda ()
    ;;           (unless (derived-mode-p 'emacs-lisp-mode)
    ;;             (lsp-deferred))))
    )

(use-package lsp-ui
    :ensure t
    :demand t)
;; (use-package lsp-treemacs
;;     :ensure t)
;; (lsp-treemacs-sync-mode 1)
(use-package consult-lsp
    :ensure t)
(with-eval-after-load 'transient
  (transient-define-prefix local/lsp-menu ()
    "lsp menu"
    [["Server"
      ("l" "start" lsp)
      ("sd" "disconnect" lsp-disconnect)
      ("sh" "describe session" lsp-describe-session)
      ("sq" "quit" lsp-workspace-shutdown)
      ("sr" "restart" lsp-workspace-restart)]
     ["Format"
      ("==" "buffer" lsp-format-buffer)
      ("=r" "region" lsp-format-region)]
     ["Toggles"
      ("td" "ui doc-mode" lsp-ui-doc-mode)
      ("tf" "type formating" lsp-toggle-on-type-formatting)
      ("th" "type highlight" lsp-toggle-symbol-highlight)
      ("ti" "log io" lsp-toggle-trace-io)
      ("tn" "signature" lsp-toggle-signature-auto-activate)
      ("ts" "sideline" lsp-ui-sideline-mode)
      ;; ("tt" "treemacs" lsp-treemacs-sync-mode)
      ("tu" "ui-mode" lsp-ui-mode)
      ]
     ["Jump"
      ("j/" "search project" consult-lsp-symbols)
      ("j?" "search local" consult-lsp-file-symbols)
      ("ja" "apropos" xref-find-apropos)
      ("jd" "declaration" lsp-find-declaration)
      ;; ("je" "error list" lsp-treemacs-errors-list)
      ("jj" "definition" lsp-find-definition)
      ("jJ" "peek definitions" lsp-ui-peek-find-definitions)
      ;; ("jh" "hierarchy" lsp-treemacs-call-hierarchy)
      ("ji" "implementation" lsp-find-implementation)
      ("jI" "peek implementations" lsp-ui-peek-find-implementation)
      ("jr" "references" lsp-find-references)
      ("jR" "peek references" lsp-ui-peek-find-references)
      ("jt" "type def" lsp-find-type-definition)
      ("jS" "peek workspace symbol" lsp-ui-peek-find-workspace-symbol)]
     ["Help"
      ("hg" "glance symbol" lsp-ui-doc-glance)
      ("hh" "thing at point" lsp-describe-thing-at-point)
      ("hs" "signature" lsp-signature-activate)]
     ["Refactor"
      ("ro" "organize imports" lsp-organize-imports)
      ("rr" "rename" lsp-rename)]
     ["Action"
      ("aa" "code actions" lsp-execute-code-action)
      ("ah" "highlight symbol" lsp-document-highlight)
      ]]))
    #+end_src


***** eglot

Generic Language Server Protocol integration via ~eglot~.
#+begin_src emacs-lisp :tangle no
(use-package eglot
  :defer 3
  :init
  (setq eglot-autoshutdown t)
  (setq eglot-code-action-indications nil)
  (setq eglot-confirm-server-edits nil)
  (setq eglot-sync-connect nil)
  (setq eglot-connect-timeout nil)
  )

;; local menu
(with-eval-after-load 'transient
(transient-define-prefix local/lsp-menu ()
  "lsp menu"
  [("l" "start" eglot)
   ("a" "actions" eglot-code-actions)
   ("f" "format" eglot-format)
   ("r" "rename" eglot-rename)
   ("q" "reconect" eglot-reconnect)
   ("Q" "shutdown" eglot-shutdown)]))
    #+end_src

**** Project

  - using project
    #+begin_src emacs-lisp
(require 'project)
(setq project-list-file (expand-file-name "projects" emacs-cache-dir))
(setq project-switch-commands 'project-dired)
  #+end_src
  - add project-x:
    #+begin_src emacs-lisp :tangle no
  (use-package project-x
    :ensure t
    :demand t
    :after project
    :custom
  (project-x-local-identifier '(".ent.el" "deps.edn" "project.clj" "platformio.ini" ".project"))
  :config
      (add-hook 'project-find-functions 'project-x-try-local 90)
      (add-hook 'kill-emacs-hook 'project-x--window-state-write)
      (add-to-list 'project-switch-commands
                  '(?j "Restore windows" project-x-windows) t))
  #+end_src
  - use my templates to create new projects:
    #+begin_src emacs-lisp
(defun local/mynew ()
  "Create PROJECT layout based on one of my templates."
  (interactive)
  (let ((template (completing-read "Template: "
                                   '( "cljproj" "default" "lpyproj" "pyproj"))))
    (shell-command (format "nix flake init --refresh -t git+https://github.com/dpom/mynixpkgs#%s" template))))
    #+end_src
  - project menu
#+begin_src emacs-lisp
(with-eval-after-load 'transient
  (transient-define-prefix local/project-menu ()
    "project menu"
    [("/" "search" consult-git-grep)
     ("b" "switch to buffer" project-switch-to-buffer)
     ("f" "find file" project-find-file)
     ;; ("j" "load state" project-x-window-state-load)
     ("k" "kill buffers" project-kill-buffers)
     ("n" "new" local/mynew)
     ("p" "switch" project-switch-project)
     ("r" "replace" project-query-replace-regexp)
     ;; ("w" "save state" project-x-window-state-save)
     ]))
#+end_src
- just
  #+begin_src emacs-lisp
(use-package just-mode
  :ensure t
  :demand t
  :mode "justfile")
#+end_src

**** Display images

#+begin_src emacs-lisp
(defun local/display-image-from-file (temp-file)
  "Citește imaginea dintr-un fișier temporar și o afișează."
  (let* ((buffer-name "*Steno Preview*")
         (buffer (get-buffer-create buffer-name))
         (img (create-image temp-file nil nil))) ; nil la început înseamnă că e cale de fișier
    (with-current-buffer buffer
      (let ((inhibit-read-only t))
        (erase-buffer)
        (insert-image img)
        (image-mode)))
    (display-buffer buffer '((display-buffer-reuse-window
                             display-buffer-at-bottom)))))


                             #+end_src

**** prog menu

#+begin_src emacs-lisp
(with-eval-after-load 'transient
  (transient-define-prefix local/prog-menu ()
    "prog menu"
    [("'" "jump source" org-edit-src-exit)
     ("l" "lsp" local/lsp-menu)
     ("f" "format" apheleia-format-buffer)
     ("j" "jump" local/jump-menu)]))
#+end_src


*** Elisp

- help
    #+begin_src emacs-lisp
(use-package helpful
  :ensure t
  :demand t
  :config
    (global-set-key [remap describe-command] #'helpful-command)
    (global-set-key [remap describe-key] #'helpful-key))
  #+end_src
- linter
    #+begin_src emacs-lisp
  (use-package elisp-lint
      :ensure t)
  #+end_src
- formater
    #+begin_src emacs-lisp
(use-package elisp-autofmt
  :ensure t
  :demand t
  :vc (:url "https://github.com/emacsmirror/elisp-autofmt")
  :commands (elisp-autofmt-mode elisp-autofmt-buffer))
  #+end_src
- Elisp Repo Kit
    #+begin_src emacs-lisp
(use-package erk
  :ensure nil)
#+end_src

- code review with AI
  #+begin_src emacs-lisp
(with-eval-after-load 'gptel

  (defcustom local/elisp-review-llm 'qwen2.5-coder:32b
    "LLM for elisp coder review."
    :type 'symbol
    :group 'ai)

  (gptel-make-preset 'elisp-review
    :description "preset for elisp review"
    :pre (lambda () (progn
                      (require 'llm-tool-collection)
                      (require 'ragmacs)))
    :backend "Ollama"
    :model 'local/elisp-review-llm
    :system 'elisp-expert2
    :highlight-mode 't
    :stream 't
    :temperature 1.0
    :tools '("emacs" "introspection")
    :confirm-tool-calls 'auto
    :include-tool-results 't
    :include-reasoning 't)
  )

(defun local/review-elisp ()
  "Review the current Emacs Lisp region or defun using gptel."
  (interactive)
  (let* ((bounds (if (use-region-p)
                     (cons (region-beginning) (region-end))
                   (bounds-of-thing-at-point 'defun)))
         (code (when bounds (buffer-substring-no-properties (car bounds) (cdr bounds)))))
    (unless bounds
      (user-error "No code found at point to review"))
    (let* ((prompt (format "@elisp-review You are an Emacs Lisp expert. Please review the following code for:
1. Logic errors or bugs.
2. Performance improvements.
3. Idiomatic Elisp style (use of built-ins, cl-lib, or dash).
4. Documentation and naming clarity.

Code:
```elisp
%s
```
%s
" code local/response-format))
               (gptel-model  local/elisp-review-llm)
               (gptel-backend (gptel-get-backend "Ollama")))
      (gptel-request prompt
        :callback (lambda (response info)
                    (if response
                        (with-current-buffer (get-buffer-create "*Elisp Review*")
                          (erase-buffer)
                          (org-mode)
                          (insert response)
                          (display-buffer (current-buffer)))
                      (message "Error: %s" info)))))))
  #+end_src
- specific menu
  #+begin_src emacs-lisp
(with-eval-after-load 'transient
  (transient-define-prefix local/elisp-menu ()
  "elisp menu"
  [["Eval"
    ("eb" "buffer"
     eval-buffer)
    ("ef" "function" eval-defun)
    ("ee" "last sexp" eval-last-sexp)
    ("em" "macro" emacs-lisp-macroexpand)
    ("er" "region" eval-region)]
   ["Project"
    ("pf" "find" erk-find)
    ("pj" "jump" erk-jump-defs)
    ("pm" "manual" erk-preview-manual)
    ("pp" "reload project" erk-reload-project-package)
    ("pr" "readme" erk-preview-readme)
    ("pt" "reload tests" erk-reload-project-tests)]
   ["Tools"
    ("=" "check parens" check-parens)
    ("'" "jump source" org-edit-src-exit)
    ;; ("f" "format" elisp-autofmt-buffer)
    ("r" "ielm" ielm)
    ("t" "test" ert)
    ("j" "jump" local/jump-menu)
    ("u" "ai review" local/review-elisp)]]))
    #+end_src

*** Clojure

**** linter
  #+begin_src emacs-lisp
(use-package flycheck-clj-kondo
  :ensure t
  :demand t)
  #+end_src
**** main clojure config:
    #+begin_src emacs-lisp
(use-package clojure-mode
  :ensure t
  :mode
   "\\.\\(clj\\|edn\\|bb\\|ply\\)\\'"
   ("\\.cljc\\'" . clojurec-mode)
   ("\\.cljs\\'" . clojurescript-mode)
  :custom
  (clojure-indent-style 'align-arguments)
  (clojure-indent-keyword-style 'align-arguments)
  :config
  ;; (setq lsp-clojure-custom-server-command '("bash" "-c" "clojure-lsp"))
  (require 'flycheck-clj-kondo)
  (cl-pushnew '("src/\\([^/]+\\)\\.clj\\'" "test/\\1_test.clj") find-sibling-rules :test #'equal)
  (cl-pushnew '("test/\\([^/]+\\)_test\\.clj\\'" "src/\\1.clj") find-sibling-rules :test #'equal))
;; (add-to-list 'major-mode-remap-alist '(clojure-mode . clojure-mode)) ; for clojure files default is clojure-mode

(use-package ob-clojure
  :ensure nil
  :after org
  :demand t
  :config
  (add-to-list 'org-babel-load-languages '(clojure . t)))


    #+end_src
**** set ts-mode:

#+begin_src emacs-lisp
(use-package clojure-ts-mode
  :ensure nil
  :vc (:url "https://github.com/clojure-emacs/clojure-ts-mode")
  :mode "\\.\\(clj\\|cljs\\|cljc\\|edn\\|bb\\|ply\\)\\'"
  :custom
  (clojure-ts-indent-style 'semantic)
  (clojure-ts-comment-macro-font-lock-body nil)
  (clojure-ts-toplevel-inside-comment-form t)
  :config
  (setopt clojure-ts-auto-remap t)
  ;; (require 'flycheck-clj-kondo)
  )
(add-to-list 'major-mode-remap-alist '(clojure-mode . clojure-ts-mode)) ; for clojure files default is clojure-mode
(setq clojure-verify-major-mode nil)
#+end_src

**** cider

- useful functions (from =https://github.com/jpmonettas/elisp-utils/blob/master/clojure.el=):
  #+begin_src emacs-lisp
(use-package cider
  :ensure t
  :demand t
  :hook
  ;; (clojure-ts-mode . cider-mode)
  (clojure-mode . cider-mode)
  :custom
  (cider-inject-jack-in-dependencies-at-jack-in t)
  (cider-overlays-use-font-lock t)
  (cider-preferred-build-tool 'clojure-cli)
  (cider-repl-buffer-size-limit 100000)
  (cider-repl-display-help-banner nil)
  (cider-repl-display-in-current-window nil)
  (cider-repl-pop-to-buffer-on-connect nil)
  (cider-repl-result-prefix ";; => ")
  (cider-repl-use-pretty-printing t)
  (cider-switch-to-repl-on-insert nil)
  (nrepl-use-ssh-fallback-for-remote-hosts t)
  :config
  (with-eval-after-load 'popper
    (cl-pushnew 'cider-test-report-mode popper-reference-buffers :test #'equal))
  (defun local/kit-reset ()
    (interactive)
    (cider-insert-in-repl "(reset)" t))

  (defun local/cider-tap-last-and-show-debugger ()
    (interactive)
    (cider-interactive-eval "(tap> *1)")
    (shell-command "i3-msg '[title=\"Flowstorm debugger\"] scratchpad show'"))

  (defun local/clj-dev-tool-bench ()
    (interactive)
    (let* ((current-ns (cider-current-ns))
           (form (cider-last-sexp))
           (clj-cmd (format "(do (require 'criterium.core) (criterium.core/quick-bench %s))" form)))
      (cider-interactive-eval clj-cmd nil nil `(("ns" ,current-ns)))))

  (defun local/clj-dev-tool-profile ()
    (interactive)
    (let* ((current-ns (cider-current-ns))
           (form (cider-last-sexp))
           (clj-cmd (format "(do (require 'clj-async-profiler.core) (clj-async-profiler.core/profile %s))" form)))
            (cider-interactive-eval clj-cmd nil nil `(("ns" ,current-ns)))
            (shell-command "xdg-open \"file:///tmp/clj-async-profiler/results/\""))))
    #+end_src
**** format
  #+begin_src emacs-lisp
(with-eval-after-load 'apheleia
  (setf (alist-get 'cljfmt apheleia-formatters)
        '("cljfmt" "fix" file))
  (setf (alist-get 'clojure-mode apheleia-mode-alist) 'cljfmt))
  #+end_src
**** error messages
    #+begin_src emacs-lisp
    (defvar cljtest-error-regexp
    '(cljtest "FAIL in (.+) (\\(.+\\):\\([0-9,]+\\))" 1 2))
    (defvar kibit-error-regexp
    '(kibit "At \\(.+\\):\\([0-9,]+\\):" 1 2))
    (defvar eastwood-error-regexp
    '(eastwood "Directory: \\(.+\\)" 1))
    (defvar kondo-error-regexp
    '(kondo "\\(.+\\):\\([0-9,]+\\):" 1 2))

    (with-eval-after-load 'compile
    (add-to-list 'compilation-error-regexp-alist-alist cljtest-error-regexp)
    (add-to-list 'compilation-error-regexp-alist 'cljtest)

    (add-to-list 'compilation-error-regexp-alist-alist kibit-error-regexp)
    (add-to-list 'compilation-error-regexp-alist 'kibit)

    (add-to-list 'compilation-error-regexp-alist-alist kondo-error-regexp)
    (add-to-list 'compilation-error-regexp-alist 'kondo)

    (add-to-list 'compilation-error-regexp-alist-alist eastwood-error-regexp)
    (add-to-list 'compilation-error-regexp-alist 'eastwood))
    #+end_src

**** safe local variables
    #+begin_src emacs-lisp
  (add-to-list 'safe-local-variable-values
              '(org-babel-clojure-backend . cider))
  (add-to-list 'safe-local-variable-values
                '(cider-lein-parameters . "shadow-srv :headless :host localhost"))
  (add-to-list 'safe-local-variable-values
              '(cider-ns-refresh-after-fn . "integrant.repl/resume"))
  (add-to-list 'safe-local-variable-values
              '(cider-ns-refresh-before-fn . "integrant.repl/suspend"))

    #+end_src

**** [[https://github.com/dpom/html-to-hiccup][html-to-hiccup]]

- (my opinated version)
    #+begin_src emacs-lisp
    (use-package html-to-hiccup
        :ensure t
      ;; :init
      ;; (local/vc-install :repo "dpom/html-to-hiccup")
    :commands html-to-hiccup-convert-region)
    #+end_src
**** document
- with [[https://github.com/p3r7/clojure-essential-ref][clojure-essential-ref]]:
  #+begin_src emacs-lisp :tangle no
(use-package clojure-essential-ref-nov
  :ensure t
  :commands clojure-essential-ref
  :init
  (use-package nov
      :ensure t)
  (setq clojure-essential-ref-nov-epub-path "~/.local/share/emacs/Clojure_The_Essential_Reference_v31.epub"))
  #+end_src
**** clerk notebook:
  #+begin_src emacs-lisp
(defun local/clerk-show ()
  (interactive)
  (when-let
      ((filename
        (buffer-file-name)))
    (save-buffer)
    (cider-interactive-eval
     (concat "(nextjournal.clerk/show! \"" filename "\")"))))
  #+end_src
**** clay
  #+begin_src emacs-lisp
(use-package clay
  :ensure t
  :demand t)
#+end_src
**** ai

#+begin_src emacs-lisp
(with-eval-after-load 'gptel

  (defcustom local/clojure-review-llm 'deepseek-coder:6.7b
    "LLM for clojure coder review."
    :type 'symbol
    :group 'ai)

  (gptel-make-preset 'clojure-review
    :description "preset for clojure review"
    :backend "Ollama"
    :model 'local/clojure-review-llm
    :system 'clojure-expert
    :highlight-mode 't
    :stream 't
    :temperature 1.0
    :confirm-tool-calls 'auto
    :include-tool-results 't
    :include-reasoning 't)

  (defun local/review-clojure ()
    "Send the Clojure code from the region or buffer to Ollama for code review.
Interactive usage: Mark a region and invoke this command; otherwise, it will process the entire buffer."
    (interactive)
    (let ((gptel-backend (gptel-get-backend "Ollama"))
          (gptel-model local/clojure-review-llm)
          (system-msg (concat "You are a functional programming and Clojure expert.
Analyze the following code and provide suggestions regarding:
1. Idiomaticity (correct use of core functions, threading macros -> and ->>).
2. Performance (avoiding reflection, proper use of lazy sequences).
3. Clarity and style (naming, structure)." local/response-format)))
      (gptel-request
          (if (use-region-p)
              (buffer-substring-no-properties (region-beginning) (region-end))
            (buffer-substring-no-properties (point-min) (point-max)))
        :system system-msg
        :callback (lambda (response info)
                    (if response
                        (with-current-buffer (get-buffer-create "*Clojure Review*")
                          (let ((inhibit-read-only t))
                            (erase-buffer)
                            (org-mode)
                            (insert "* Code Review Clojure\n\n")
                            (insert response)
                            (display-buffer (current-buffer))))
                      (message "Eroare la obținerea review-ului: %s" info))))))

  (defun local/generate-clojure-tests ()
    "Generează teste unitare pentru funcția Clojure selectată (sau buffer) folosind Ollama."
    (interactive)
    (let ((gptel-backend (gptel-get-backend "Ollama"))
          (gptel-model local/clojure-review-llm)
           (system-msg (concat
                        "Ești un expert în testare Clojure.\n"
                        "Analizează codul sursă și generează un set complet de teste unitare folosind `clojure.test`.\n"
                        "Reguli:\n"
                        "1. Include cazuri de succes (happy path) și cazuri de eroare (edge cases).\n"
                        "2. Dacă funcția este pură, folosește `is (= ...)` intensiv.\n"
                        "3. Formatează totul în Org-mode cu blocuri "
                        (format "#+begin%src clojure." "_") "\n"
                        "4. Explică pe scurt ce testează fiecare caz folosind subtitluri Org-mode (*).")))
      (gptel-request
          (if (use-region-p)
              (buffer-substring-no-properties (region-beginning) (region-end))
            (buffer-substring-no-properties (point-min) (point-max)))
        :system system-msg
        :callback (lambda (response info)
                    (if response
                        (with-current-buffer (get-buffer-create "*Clojure Tests*")
                          (let ((inhibit-read-only t))
                            (erase-buffer)
                            (org-mode)
                            (insert "#+TITLE: Unit Tests Generated\n\n")
                            (insert response)
                            (display-buffer (current-buffer))))
                      (message "Eroare la generare: %s" info)))))))

#+end_src

**** specific menu
  #+begin_src emacs-lisp
;; (require 'cider)
;; (use-package cljstyle-format
;;     :ensure t)

(with-eval-after-load 'transient
  (transient-define-prefix local/clojure-menu ()
  "clojure menu"
  [["Eval"
    ("ea" "all" cider-load-all-project-ns)
    ("eb" "buffer" cider-load-buffer)
    ("ee" "form before cursor" cider-eval-last-sexp)
    ("e;" "comment eval form" cider-pprint-eval-last-sexp-to-comment)
    ("eE" "print eval form" cider-pprint-eval-last-sexp)
    ("ef" "top level" cider-eval-defun-at-point)
    ("ei" "interrupt" cider-interrupt)
    ;; ("em" "macro" cider-macroexpand-1)
    ("en" "ns" cider-eval-ns-form)
    ("er" "region" cider-eval-region)]
   ["Help"
    ;; ("ha" "apropos" cider-apropos)
    ;; ("hc" "classpath" cider-classpath)
    ("he" "inspect last res" cider-inspect-last-result)
    ("hh" "doc" cider-doc)
    ("hj" "javadoc" cider-javadoc)
    ("hn" "namespace" cider-browse-ns)
    ;; ("hr" "reference book" clojure-essential-ref)
    ("hs" "spec" cider-browse-spec)]
   ["REPL"
    ("rc" "connect" cider-connect-clj)
    ("re" "inspect last eval" cider-inspect-last-result)
    ;; ("rd" "clear" cider-clear-repl-buffer)
    ("rj" "jack in" cider-jack-in)
    ("rh" "info" sesman-info)
    ("rx" "exit" sesman-quit)
    ("rs" "switch" cider-switch-to-repl-buffer)
    ("rt" "tap" local/cider-tap-last-and-show-debugger)
    ;; ("rl" "reload" cider-ns-reload)
    ("kr" "reset" local/kit-reset)]
   ["Test"
    ("ta" "all tests" cider-test-run-project-tests)
    ("tn" "namespace tests" cider-test-run-ns-tests)
    ("tt" "test at point" cider-test-run-test)
    ("tu" "generate tests" local/generate-clojure-tests)]
   ["Clay"
    ("cc" "save clay" clay-make-ns-html)
    ("ce" "eval" clay-make-last-sexp)
    ("cs" "start clay" clay-start)]
   ["Tools"
    ("SPC" "align" clojure-align)
    ("=" "check parens" check-parens)
    ("'" "jump source" org-edit-src-exit)
    ("u" "ai review" local/review-clojure)
    ("b" "benchmarks" local/clj-dev-tool-bench)
    ;; ("c" "clerk" local/clerk-show)
    ("f" "format" apheleia-format-buffer)
    ("l" "lsp" local/lsp-menu)
    ("p" "profile" local/clj-dev-tool-profile)
    ("j" "jump" local/jump-menu)]])
  )
  #+end_src
*** YAML

  - yaml-mode
    #+begin_src emacs-lisp
    (use-package yaml-mode
      :ensure t
      :mode "\\.ya?ml\\'")
    #+end_src
  - install lsp server with: =M-x lsp-install-server RET yamlls RET=.
 - specific menu
   #+begin_src emacs-lisp
(with-eval-after-load 'transient
  (transient-define-prefix local/yaml-menu ()
  "yaml menu"
  [("'" "jump source" org-edit-src-exit)
   ;; ("l" "lsp" local/lsp-menu)
   ("j" "jump" local/jump-menu)]))
   #+end_src
***

*** JS and JSON

  - use js2 and prettier
    #+begin_src emacs-lisp
(use-package js2-mode
  :ensure t
  :mode "\\.jsx?\\'"
  :custom (js2-mode-show-strict-warnings nil)
  :config
  (defun local/set-js-indentation ()
    (setq-default js-indent-level 2)
    (setq-default tab-width 2))

  ;; Use js2-mode for Node scripts
  (add-to-list 'magic-mode-alist '("#!/usr/bin/env node" . js2-mode))
  ;; Don't use built-in syntax checking

  (add-hook 'local/set-js-indentation 'js2-imenu-extras-mode)
  (add-hook 'json-mode-hook 'local/set-js-indentation))
    #+end_src
  - json
    #+begin_src emacs-lisp
(use-package json-mode
  :ensure t
  :mode "\\.json\\'"
  :config
  (defun local/json-array-of-numbers-on-one-line (encode array)
    "Prints the arrays of numbers in one line."
    (let* ((json-encoding-pretty-print
            (and json-encoding-pretty-print
                 (not (cl-loop for x across array always (numberp x)))))
           (json-encoding-separator (if json-encoding-pretty-print "," ", ")))
      (funcall encode array)))
  (advice-add 'json-encode-array :around #'local/json-array-of-numbers-on-one-line))
    #+end_src
  - path
    #+begin_src emacs-lisp
    ;; get json path
    (use-package json-snatcher
        :ensure t)
    #+end_src

  - format
    #+begin_src emacs-lisp
(use-package json-reformat
  :ensure t)
    #+end_src

  - specific menu
  #+begin_src emacs-lisp
(with-eval-after-load 'transient
  (transient-define-prefix local/js-menu ()
  "js menu"
  [("'" "jump source" org-edit-src-exit)
   ("f" "format" json-reformat-region)
   ("l" "lsp" local/lsp-menu)
   ("j" "jump" local/jump-menu)
   ("s" "snatch" jsons-print-path)]))
  #+end_src
*** Scheme

- use geiser for scheme development:
  #+begin_src emacs-lisp :tangle no
(use-package geiser
    :ensure t)
(use-package geiser-guile
    :ensure t)
  #+end_src

*** Shell

- vterm:
    #+begin_src emacs-lisp
    (use-package vterm
      :ensure t
    :custom (vterm-max-scrollback 10000))
    #+end_src
- Execution rights, the snippet below ensures that the execution right is automatically granted to save a shell script file that begins with a #! shebang:
    #+begin_src emacs-lisp
    (require 'sh-script)
    (add-hook 'after-save 'executable-make-buffer-file-executable-if-script-p)
    #+end_src
- install lsp server: =lsp-install-server= =bash-lsp=
- babel:
  #+begin_src emacs-lisp
(with-eval-after-load 'org
  (add-to-list 'org-babel-load-languages '(shell . t)))
  #+end_src
*** SQL

  - for usage see [[id:51df3d77-18c9-4c09-a21a-8904f69dff02][sql in emacs]]
  - emacsql:
    #+begin_src emacs-lisp
    (use-package emacsql
        :ensure t)
    #+end_src
  - uppercase sql words
    #+begin_src emacs-lisp
    (defun upcase-sql-keywords ()
      (interactive)
    (save-excursion
        (dolist (keywords sql-mode-postgres-font-lock-keywords)
        (goto-char (point-min))
        (while (re-search-forward (car keywords) nil t)
            (goto-char (+ 1 (match-beginning 0)))
            (when (eql font-lock-keyword-face (face-at-point))
            (backward-char)
            (upcase-word 1)
            (forward-char))))))
    #+end_src
  - format:
    - install the bin:
        #+begin_src shell :tangle no
    pip install --user sqlparse
        #+end_src
    - sqlformat package:
        #+begin_src emacs-lisp
    (use-package sqlformat
      :ensure t
      :config
      (setq sqlformat-command 'pgformatter)
      (setq sqlformat-args '("-s2" "-g")))
        #+end_src
  - emacs function to use outside sql-mode:
      #+begin_src emacs-lisp
  (defun remove-trailing-newline (point)
  (if (= (char-before point) ?\n)
      (- point 1)
      point))

  (defun local/sql-format (start end)
  "Formats the selected sql `sqlformat'"
  (interactive "r")
  (shell-command-on-region
  ;; beginning and end of buffer
  start
  (remove-trailing-newline end)
  ;; command and parameters
  "sqlformat -k upper -r -s -"
  ;; output buffer
  (current-buffer)
  ;; replace?
  t
  ;; name of the error buffer
  "*Sqlformat Error Buffer*"
  ;; show error buffer?
  t))
      #+end_src
  - safe variables
    #+begin_src emacs-lisp
    (put 'sql-product 'safe-local-variable #'symbolp)
    (put 'sql-sqlite-login-params 'safe-local-variable (lambda (_) t))
    #+end_src
  - ejc-sql
    #+begin_src emacs-lisp :tangle no
    (use-package ejc-sql
      :ensure t
      :custom
    (clomacs-httpd-default-port 8090 "Use a port other than 8080")
    (ejc-complete-on-dot t)
    :config
    (require 'ejc-company)
    (add-hook 'ejc-sql-minor-mode-hook
                (lambda ()
                (ejc-eldoc-setup))))
    #+end_src
- specific menu
  #+begin_src emacs-lisp
(with-eval-after-load 'transient
  (transient-define-prefix local/sql-menu ()
  "sql menu"
  [["Eval"
    ("eb" "buffer" sql-send-buffer)
    ("ee" "string" sql-send-string)
    ("ef" "paragraf" sql-send-paragraph)
    ("er" "region" sql-send-region)]
   ["Help"
    ("ha" "all" sql-list-all)
    ("ht" "table" sql-list-table)]
   ["REPL"
    ("rc" "connect" sql-product-interactive)
    ("rs" "switch" sql-show-sqli-buffer)
    ]
   ["Tools"
    ("'" "jump source" org-edit-src-exit)
    ("f" "format" sqlformat)
    ;; ("l" "lsp" local/lsp-menu)
    ("j" "jump" local/jump-menu)]]))
  #+end_src
*** HTML

- request
  #+begin_src emacs-lisp
(use-package request
  :ensure t
  :demand t)

#+end_src
- web-mode
  #+begin_src emacs-lisp
(use-package web-mode
  :ensure t
  :mode "(\\.\\(html?\\|ejs\\|tsx\\|jsx\\)\\'"
  :custom
  (web-mode-code-indent-offset 2)
  (web-mode-markup-indent-offset 2)
  (web-mode-attribute-indent-offset 2)
  (web-mode-enable-css-colorization t)
  (web-mode-enable-auto-pairing t))

;; 1. Start the server with `httpd-start'
;; 2. Use `impatient-mode' on any buffer
(use-package skewer-mode
    :ensure t)
(use-package impatient-mode
    :ensure t)
(use-package rainbow-mode
  :ensure t
  :demand t
  :config
  (dolist (hook '(css-mode-hook
                  html-mode-hook
                  org-mode))
    (add-hook hook (lambda () (rainbow-mode t)))) )

  #+end_src
- install lsp with: =lsp-install-server= =html-ls=
- web-beautify
  #+begin_src emacs-lisp
(use-package web-beautify
    :ensure t)
  #+end_src
  it also need:
  #+begin_src shell :tangle no
sudo npm -g install js-beautify
  #+end_src
- specific menu
  #+begin_src emacs-lisp
(with-eval-after-load 'transient
  (transient-define-prefix local/html-menu ()
  "html menu"
  [("'" "jump source" org-edit-src-exit)
   ("f" "format" web-beautify-html)
   ("i" "impatient" impatient-mode)
   ("j" "jump" local/jump-menu)
   ;; ("l" "lsp" local/lsp-menu)
   ("s" "start server" httpd-start)]))
  #+end_src
- for tailwindcss:
  #+begin_src emacs-lisp
(use-package lsp-tailwindcss
  :ensure t
  :init
  (setq lsp-tailwindcss-add-on-mode t))
  #+end_src
*** HTTP Client

  - restclient:
    #+begin_src emacs-lisp
(use-package restclient
  :ensure t)

(use-package ob-restclient
  :ensure t
  :config
  (add-to-list 'org-babel-load-languages '(restclient . t)))

(use-package ob-http
  :ensure t
  :config
  (add-to-list 'org-babel-load-languages '(http . t)))

;; (use-package company-restclient
;;   :ensure t)

;; (with-eval-after-load 'cape
;;     (add-to-list 'completion-at-point-functions
;;                  (cape-company-to-capf #'company-restclient)))
    #+end_src
  - fix functions using lexical binding:
    #+begin_src emacs-lisp
    (with-eval-after-load 'restclient
    (defun restclient-get-var (var-name)
        (let ((buf-name (buffer-name (current-buffer)))
            (buf-point (point)))
        (restclient-get-var-at-point var-name buf-name buf-point)))

    (defun restclient-elisp-result-function (args offset)
        (goto-char offset)
        (let ((form (read (current-buffer))))
        (lambda ()
            (eval form)))))
    #+end_src

*** Python

- python-mode
    #+begin_src emacs-lisp
(use-package python
  :demand t
  :mode ("\\.py\\'" . python-mode)
  :init
  (add-to-list 'major-mode-remap-alist '(python-mode . python-mode))
  :custom
  (python-indent-guess-indent-offset-verbose nil)
  (python-shell-completion-native-enable nil)
  :config
  (defun local/python-shell-send-line ()
    "Send the current line to shell"
    (interactive)
    (let ((python-mode-hook nil)
          (start (point-at-bol))
          (end (point-at-eol)))
      (python-shell-send-region start end)))
  (defun local/python-shell-send-buffer ()
    "Send buffer content to shell and switch to it in insert mode."
    (interactive)
    (let ((python-mode-hook nil))
      (python-shell-send-buffer)))

  (defun local/python-shell-send-region (start end)
    "Send region content to shell and switch to it in insert mode."
    (interactive "r")
    (let ((python-mode-hook nil))
      (python-shell-send-region start end)))

  (defun local/python-format-buffer ()
    "Bind possible python formatters."
    (interactive)
    (pcase python-formatter
      ('yapf (yapfify-buffer))
      ('black (blacken-buffer))
      (code (message "Unknown formatter: %S" code))))

  (defun local/python-eval-print-last-sexp ()
    "Print result of evaluating current line into current buffer."
    (interactive)
    (let ((res (python-shell-send-string-no-output
                ;; modify to get a different sexp
                (buffer-substring (line-beginning-position)
                                  (line-end-position))))
          (standard-output (current-buffer)))
      (when res
        (terpri)
        (princ res)
        (terpri))))
  )

    #+end_src
- poetry
  #+begin_src emacs-lisp
(use-package poetry
 :ensure t)
  #+end_src
- safe variables
    #+begin_src emacs-lisp
    (put 'python-shell-interpreter 'safe-local-variable #'stringp)
    #+end_src
- py-vterm
  #+begin_src emacs-lisp
(use-package py-vterm-interaction
  :hook (python-mode . py-vterm-interaction-mode)
  :hook (python-ts-mode . py-vterm-interaction-mode)
  :config
  ;;; Suggested:
  (setq-default py-vterm-interaction-repl-program "ipython")
  (setq-default py-vterm-interaction-silent-cells t)
  )
  #+end_src
- specific menu
  #+begin_src emacs-lisp
(with-eval-after-load 'transient
  (transient-define-prefix local/python-menu ()
  "python menu"
  [["Eval"
    ;; ("eb" "buffer" local/python-shell-send-buffer)
    ;; ("ee" "line" local/python-shell-send-line)
    ;; ("e;" "line" local/python-eval-print-last-sexp)
    ;; ("er" "region" local/python-shell-send-region)
    ("eb" "buffer" py-vterm-interaction-send-buffer)
    ("ee" "line" py-vterm-interaction-send-region-or-current-line)
    ]
   ["Help"
    ("ha" "all" python-describe-at-point)]
   ["REPL"
    ;; ("rj" "run" run-python)
    ;; ("rs" "switch" python-shell-switch-to-shell)
    ("rs" "switch" py-vterm-interaction-switch-to-repl-buffer)
    ]
   ["Tools"
    ("'" "jump source" org-edit-src-exit)
    ("f" "format" local/python-format-buffer)
    ("j" "jump" local/jump-menu)
    ;; ("l" "lsp" local/lsp-menu)
    ("p" "poetry" poetry)]]))
  #+end_src

*** XML

- use LSP for xml:
  - install server =M-x lsp-install-server xmlls=
  - activate it
    #+begin_src emacs-lisp
(use-package nxml-mode
  :ensure nil
  :mode "\\.xml\\'"
  :config
  ;; (add-hook 'nxml-mode-hook #'lsp-deferred)
  ;; (remove-hook 'nxml-mode-hook #'lsp-deferred)

  (add-hook 'nxml-mode-hook (lambda() (hs-minor-mode 1)))
  (add-to-list 'hs-special-modes-alist
               '(nxml-mode
                 "<!--\\|<[^/>]*[^/]>" ;; regexp for start block
                 "-->\\|</[^/>]*[^/]>" ;; regexp for end block
                 "<!--"
                 nxml-forward-element
                 nil))
  (defun local/toggle-level ()
    "mainly to be used in nxml mode"
    (interactive)
    (hs-show-block)
    (hs-hide-level 1))
  (define-key nxml-mode-map "<mouse-3>" 'local/toggle-level))
  #+end_src

*** EBNF

#+begin_src emacs-lisp
(use-package ebnf-mode
    :ensure t
  :config
  (require 'ebnf2ps))
#+end_src

*** Arduino
- C settings
  #+begin_src emacs-lisp
(defun local/c-settings ()
    (c-set-style "bsd")
    (setq indent-tabs-mode nil
          c-basic-offset 2))
  #+end_src
- C++
  #+begin_src emacs-lisp
(use-package cc-mode
  :ensure nil
  :config
  (add-hook 'c++-mode-hook #'local/c-settings))
  #+end_src
- Arduino
  #+begin_src emacs-lisp
(use-package arduino-mode
  :ensure t
  :mode ("\\.ino\\'" . arduino-mode)
  :config
  (add-hook 'arduino-mode-hook #'local/c-settings))
#+end_src
- platformio - a better solution for Arduino development (I'm using my template for project layout)
  #+begin_src shell :tangle no
pip install platformio
  #+end_src
  #+begin_src emacs-lisp :tangle no
(use-package irony
    :ensure t)
(use-package irony-eldoc
    :ensure t)
(use-package flycheck-irony
    :ensure t)
(use-package platformio-mode
    :ensure t)
  ;; edit ino files with adruino mode.
  (add-to-list 'auto-mode-alist '("\\.ino$" . arduino-mode))
  ;; Enable irony for all c++ files, and platformio-mode only
  ;; when needed (platformio.ini present in project root).
  (add-hook 'c++-mode-hook (lambda ()
                             (irony-mode)
                             (irony-eldoc)
                             (platformio-conditionally-enable)))

  ;; Use irony's completion functions.
  (add-hook 'irony-mode-hook
            (lambda ()
              (define-key irony-mode-map [remap completion-at-point]
                'irony-completion-at-point-async)

              (define-key irony-mode-map [remap complete-symbol]
                'irony-completion-at-point-async)

              (irony-cdb-autosetup-compile-options)))
  #+end_src
*** Nix
- official nix-mode
  #+begin_src emacs-lisp
(use-package nix-mode
  :ensure t
  :mode ("\\.nix\\'" "\\.nix.in\\'"))

(use-package ob-nix
  :ensure t
  :after org
  :demand t
  :config
  (add-to-list 'org-babel-load-languages '(nix . t)))

(use-package nix-drv-mode
  :ensure nix-mode
  :mode "\\.drv\\'")

(use-package nix-shell
  :ensure nix-mode
  :commands (nix-shell-unpack nix-shell-configure nix-shell-build))

(use-package nix-repl
  :ensure nix-mode
  :commands (nix-repl))
  #+end_src
- lsp with [[https://github.com/nix-community/nixd][nixd]]
  #+begin_src emacs-lisp
;; (add-hook 'prog-mode-hook
;;           (lambda ()
;;             (add-hook 'before-save-hook 'eglot-format nil t)))

(with-eval-after-load 'eglot
  (dolist (mode '((nix-mode . ("nixd"))))
    (add-to-list 'eglot-server-programs mode)))
  #+end_src
- nix3
  #+begin_src emacs-lisp :tangle no
(use-package nix3
  :ensure t
  :demand t
  :custom
  (nix3-flake-remote-wait 20)
  (nix3-registry-list-completion-options (list :add-to-registry t
                                               :require-match nil)))

#+end_src
*** GraphQL

- graphql-mode
  #+begin_src emacs-lisp
(use-package graphql-mode
    :ensure t)
  #+end_src
- org
  #+begin_src emacs-lisp
(use-package ob-graphql
    :ensure t
    :after org
    :config
    (add-to-list 'org-babel-load-languages '(graphql . t)))
  #+end_src

*** Markdown

#+begin_src emacs-lisp
(use-package markdown-mode
  :ensure t
  :bind (:map markdown-mode-map
              ("C-c C-p" . local/markdown-preview)
              ("C-c '" . local/markdown-edit-mermaid))
  :config
  (setq markdown-command "marked")
  (dolist (face '((markdown-header-face-1 . 1.2)
                  (markdown-header-face-2 . 1.1)
                  (markdown-header-face-3 . 1.0)
                  (markdown-header-face-4 . 1.0)
                  (markdown-header-face-5 . 1.0)))
    (set-face-attribute (car face) nil :weight 'normal :height (cdr face)))
  (defun local/markdown-preview ()
    "Render the current Markdown buffer to HTML with mermaid diagrams and preview in eww."
    (interactive)
    (let* ((temp-dir (make-temp-file "md-preview-" t))
           (img-count 0)
           (md-file (expand-file-name "content.md" temp-dir))
           (html-file (expand-file-name "preview.html" temp-dir)))
      (write-region (point-min) (point-max) md-file nil 'silent)
      (with-temp-buffer
        (insert-file-contents md-file)
        (goto-char (point-min))
        (while (re-search-forward "^```mermaid[ \t]*\n" nil t)
          (let* ((opening-start (match-beginning 0))
                 (diagram-start (point))
                 (diagram-end (re-search-forward "^```[ \t]*$" nil t))
                 mmd-file img-file diagram exit-code)
            (unless diagram-end
              (user-error "Unclosed mermaid code block"))
            (cl-incf img-count)
            (setq mmd-file (format "%s/diagram-%d.mmd" temp-dir img-count)
                  img-file (format "%s/diagram-%d.png" temp-dir img-count)
                  diagram (buffer-substring-no-properties diagram-start
                                                          (- diagram-end 4)))
            (with-temp-buffer
              (insert diagram)
              (write-region (point-min) (point-max) mmd-file nil 'silent))
            (setq exit-code (call-process "mmdc" nil (get-buffer-create "*mmdc-errors*") nil
                                           "-i" mmd-file "-o" img-file "--scale" "2" "-q"))
            (if (not (and (eq exit-code 0) (file-exists-p img-file)))
                (user-error "mmdc failed (exit %d): %s" exit-code
                            (with-current-buffer "*mmdc-errors*" (buffer-string))))
            (kill-buffer "*mmdc-errors*")
            (delete-region opening-start (point))
            (insert (format "\n<img src=\"%s\">\n" img-file))))
        (write-region (point-min) (point-max) md-file nil 'silent))
      (let ((exit-code (call-process "pandoc" nil (get-buffer-create "*pandoc-errors*")
                                     nil md-file "-o" html-file "-s")))
        (if (not (and (eq exit-code 0) (file-exists-p html-file)))
            (user-error "pandoc failed (exit %d): %s" exit-code
                        (with-current-buffer "*pandoc-errors*" (buffer-string))))
        (kill-buffer "*pandoc-errors*"))
      (eww-open-file html-file)))
  (defvar-local local/markdown-edit-parent nil
    "Cons (PARENT-BUFFER . OPENING-LINE) for mermaid edit session.")
  (defun local/markdown-edit-mermaid ()
    "Edit the mermaid code block at point in a dedicated mermaid-mode buffer.
  In markdown-mode: extracts the block and opens it for editing.
  In mermaid-mode (edit buffer): saves content back and closes."
    (interactive)
    (if (derived-mode-p 'mermaid-mode)
        (local/mermaid-edit-done)
      (local/markdown-edit-mermaid-start)))
  (defun local/markdown-edit-mermaid-start ()
    "Open mermaid code block at point in a new mermaid-mode buffer."
    (let* ((orig (point))
           (open-pos (and (derived-mode-p 'markdown-mode)
                          (save-excursion
                            (re-search-backward "^```mermaid[ \t]*\n" nil t))))
           bounds)
      (unless open-pos
        (user-error "Point is not in a mermaid code block"))
      (save-excursion
        (let* ((block-start (match-end 0))
               (open-line (line-number-at-pos (match-beginning 0))))
          (goto-char block-start)
          (let ((close-pos (re-search-forward "^```[ \t]*$" nil t)))
            (unless (and close-pos (<= block-start orig) (>= (point) orig))
              (user-error "Point is not in a mermaid code block"))
            (setq bounds (list open-line block-start (match-beginning 0))))))
      (let ((content (buffer-substring-no-properties (nth 1 bounds) (nth 2 bounds)))
            (parent-buffer (current-buffer))
            (edit-buffer (generate-new-buffer "*mermaid-edit*")))
        (with-current-buffer edit-buffer
          (mermaid-mode)
          (insert (string-trim-right content))
          (goto-char (point-min))
          (setq-local local/markdown-edit-parent
                      (cons parent-buffer (nth 0 bounds))))
        (switch-to-buffer-other-window edit-buffer)
        (message "Edit mermaid block. %s to save and return."
                 (substitute-command-keys "\\[local/markdown-edit-mermaid]")))))
  (defun local/mermaid-edit-done ()
    "Save mermaid edit buffer content back to the parent markdown buffer."
    (interactive)
    (unless local/markdown-edit-parent
      (user-error "Not editing a mermaid block"))
    (let* ((content (buffer-string))
           (parent-buffer (car local/markdown-edit-parent))
           (open-line (cdr local/markdown-edit-parent))
           (edit-buffer (current-buffer)))
      (with-current-buffer parent-buffer
        (save-excursion
          (goto-char (point-min))
          (forward-line (1- open-line))
          (if (looking-at "^```mermaid")
              (progn
                (forward-line)
                (let ((start (point)))
                  (re-search-forward "^```[ \t]*\n")
                  (delete-region start (point))
                  (insert (string-trim-right content))
                  (insert "\n```\n")))
            (user-error "Mermaid block no longer exists at line %d" open-line))))
      (kill-buffer edit-buffer)
      (switch-to-buffer parent-buffer)
      (message "Mermaid block updated"))))
#+end_src

**** specific menu

#+begin_src emacs-lisp
(with-eval-after-load 'transient
  (transient-define-prefix local/markdown-menu ()
    "markdown menu"
    [("'" "edit mermaid block" local/markdown-edit-mermaid)
     ("v" "preview" local/markdown-preview)
     ("j" "jump" local/jump-menu)]))
#+end_src

** References

  1. https://www.flycheck.org/en/latest/user/flycheck-versus-flymake.html
  2. https://www.gnu.org/software/emacs/manual/html_node/flymake/index.html
  3. https://github.com/magoyette/openapi-yaml-mode
  4. https://github.com/OAI/OpenAPI-Specification
  5. https://github.com/swagger-api/swagger-codegen
  6. https://orgmode.org/worg/org-contrib/babel/languages/ob-doc-sqlite.html
  7. https://www.emacswiki.org/emacs/SqlMode
  8. https://skeptric.com/formatting-sql/
  9. https://github.com/rememberYou/.emacs.d/blob/master/config.org#python
  10. https://medium.com/analytics-vidhya/my-python-development-and-daily-usage-setup-af8633ddef78
  11. https://medium.com/analytics-vidhya/managing-a-python-development-environment-in-emacs-43897fd48c6a
  12. https://www.emacswiki.org/emacs/SetupEl
  13. https://conda.io/projects/conda/en/latest/user-guide/index.html
  14. [[https://www.youtube.com/watch?v=OB9vFu9Za8w&t=1145s][The Emacs Ipython Notebook- John Miller (Honeywell UOP)]]
  15. https://github.com/millejoh/emacs-ipython-notebook
  16. https://github.com/nnicandro/emacs-jupyter
  17. https://martinralbrecht.wordpress.com/2020/08/23/conda-jupyter-and-emacs/
  18. https://github.com/hlissner/doom-emacs/tree/91ced7997537cc692e2a06294a428c5b4037d687/modules/lang/python
  19. https://realpython.com/emacs-the-best-python-editor/#additional-python-language-features
  20. https://docs.platformio.org/en/latest/integration/ide/emacs.html
  21. https://github.com/ZachMassia/PlatformIO-Mode

* Contextual Keybindings
** Description

Keybindings occupy a central place in emacs optimization. I'd like a coherent, easy-to-remember system where the functionality of the keys depends on the context.

** Subfeatures

1. (ckb1) System based on the [[id:8fb57274-1b5b-4d7b-8bed-a128dd52b271][vi]] philosophy.
2. (ckb2) Global menu with keys valid in all modes
3. (ckb3) main modes specific menus with similar keys for similar functions

** Implementation
:PROPERTIES:
  :header-args: :tangle modules/home/emacs/init.el
:END:

*** which-key

#+begin_src emacs-lisp
(use-package which-key
  :ensure t
  :demand t
  :custom (which-key-sort-order 'which-key-prefix-then-key-order)
  :config
  (which-key-mode 1))
#+end_src

*** [[https://github.com/magit/transient][transient]]
#+begin_src emacs-lisp
(use-package transient
  :ensure t
  :demand t
  :config
  (setq transient-default-level 5)
  (transient-bind-q-to-quit))
#+end_src

*** Specific Menus

#+begin_src emacs-lisp
 (defun local/specific-menu-command ()
  "call different menus depending on what's current major mode."
  (interactive)
  (cond
   ((string-equal major-mode "bibtex-mode") (local/bibtex-menu))
   ((string-equal major-mode "clojure-mode") (local/clojure-menu))
   ((string-equal major-mode "clojure-ts-mode") (local/clojure-menu))
   ((string-equal major-mode "clojurec-mode") (local/clojure-menu))
   ((string-equal major-mode "clojurescript-mode") (local/clojure-menu))
   ((string-equal major-mode "emacs-lisp-mode") (local/elisp-menu))
   ((string-equal major-mode "js-mode") (local/js-menu))
   ((string-equal major-mode "json-mode") (local/js-menu))
   ((string-equal major-mode "markdown-mode") (local/markdown-menu))
   ((string-equal major-mode "mermaid-mode") (local/mermaid-menu))
   ((string-equal major-mode "org-mode") (local/org-menu))
   ((string-equal major-mode "python-mode") (local/python-menu))
   ((string-equal major-mode "python-ts-mode") (local/python-menu))
   ((string-equal major-mode "sql-mode") (local/sql-menu))
   ((string-equal major-mode "web-mode") (local/html-menu))
   ((string-equal major-mode "yaml-mode") (local/yaml-menu))

   ;; if nothing match, use generic prog menu
   (t (local/prog-menu))))
(define-key mode-specific-map "\\" 'local/specific-menu-command)
(keymap-global-set "C-." 'local/specific-menu-command)
#+end_src

**** git menu

#+begin_src emacs-lisp
(with-eval-after-load 'transient
  (transient-define-prefix local/git-menu ()
    "git menu"
    [("b" "blame" magit-blame)
     ("c" "clone" magit-clone )
     ("y" "status" magit-status)
     ("i" "init" magit-init )
     ("l" "log (current file)" magit-log-buffer-file)
     ("L" "log (project)" magit-log-current)
     ("m" "generate message" local/generate-commit-message)
     ("t" "timemachine" git-timemachine)]))
#+end_src

**** help menu

#+begin_src emacs-lisp
(with-eval-after-load 'transient
(transient-define-prefix local/help-menu ()
  "help menu"
  [("a" "apropos" apropos)
   ("A" "apropos doc" apropos-documentation)
   ("b" "bindings" describe-bindings)
   ("f" "function" describe-function)
   ("k" "key" describe-key)
   ("m" "mode" describe-mode)
   ("n" "minor mode" describe-minor-mode)
   ("v" "variable" describe-variable)]))
#+end_src

**** toggle menu

#+begin_src emacs-lisp
(with-eval-after-load 'transient
  (transient-define-prefix local/toggle-menu ()
    "toggle menu"
    [["General"
      ("SPC" "whitespace mode" whitespace-mode)
      ("e" "debug on error" toggle-debug-on-error)
      ("f" "folding" hs-minor-mode)
      ;; ("f" "folding" treesit-fold-mode)
      ("q" "debug on quit" toggle-debug-on-quit)
      ("m" "minor modes" minions-minor-modes-menu)
      ("o" "set font" fontaine-set-preset)
      ("r" "read-only" read-only-mode)
      ("s" "font size" local/iw-set-font-size)
      ]
     ["Programming"
      ("p|" "indent guide" highlight-indent-guides-mode)
      ("pa" "aggresive indent" aggressive-indent-mode)
      ("pn" "line number" display-line-numbers-mode)
      ("pm" "smerge" smerge-mode)
      ;; ("pd" "side dir" dirvish-side)
      ]
     ["Writing"
      ("wi" "input method" set-input-method)
      ("wt" "truncate lines" toggle-truncate-lines)
      ("wy" "flyspel" flyspell-mode)]]))
#+end_src

*** Main Menu

#+begin_src emacs-lisp
(define-key mode-specific-map "'"  'org-capture)
(define-key mode-specific-map "+"  'local/translate)
(define-key mode-specific-map "-"  'sort-lines)
(define-key mode-specific-map "/"  'consult-line)
(define-key mode-specific-map "A"  'agent-shell)
(define-key mode-specific-map "C"  'calendar)
(define-key mode-specific-map "E"  'eshell)
(define-key mode-specific-map "M"  'mu4e)
(define-key mode-specific-map "O"  'org-clock-out)
(define-key mode-specific-map "R"  'elfeed)
(define-key mode-specific-map "S"  'local/start-task)
(define-key mode-specific-map "T"  'vterm)
(define-key mode-specific-map "W"  'pass)
(define-key mode-specific-map "a"  'local/agenda-menu)
(define-key mode-specific-map "b"  'local/buffer-menu)
(define-key mode-specific-map "d"  'local/date-iso)
(define-key mode-specific-map "f"  'local/file-menu)
(define-key mode-specific-map "i"  'consult-imenu)
(define-key mode-specific-map "j"  'local/jump-menu)
(define-key mode-specific-map "l"  'org-store-link)
(define-key mode-specific-map "n"  'local/notes-menu)
(define-key mode-specific-map "p"  'local/project-menu)
(define-key mode-specific-map "s"  'local/scratch-buffer)
(define-key mode-specific-map "t"  'local/toggle-menu)
(define-key mode-specific-map "u"  'local/ai-menu)
(define-key mode-specific-map "w"  'ace-window)
(define-key mode-specific-map "y"  'local/git-menu)
(define-key mode-specific-map "z"  'ent-run)

#+end_src
*** meow

**** Normal


#+TBLNAME: normal-keybindings
| key      | command                     |
|----------+-----------------------------|
| <escape> | ignore                      |
| `        | local/surround              |
| !        | bookmark-set                |
| @        | bookmark-jump               |
| #        | meow-comment                |
| $        | repeat                      |
| %        | meow-query-replace          |
| &        | meow-query-replace-regexp   |
| '        | repeat                      |
| (        | meow-expand-1               |
| )        | meow-expand-2               |
| *        | goto-last-change            |
| +        | meow-expand-4               |
| /        | meow-search                 |
| =        | indent-region               |
| ?        | meow-cheatsheet             |
| [        | meow-beginning-of-thing     |
| ]        | meow-end-of-thing           |
| {        | meow-expand-5               |
| }        | meow-expand-3               |
| \        | local/specific-menu-command |
| 1        | meow-expand-1               |
| 2        | meow-expand-2               |
| 3        | meow-expand-3               |
| 4        | meow-expand-4               |
| 5        | meow-expand-5               |
| 6        | meow-expand-6               |
| 7        | meow-expand-7               |
| 8        | meow-expand-8               |
| 9        | meow-expand-9               |
| 0        | meow-expand-0               |
| -        | negative-argument           |
| ;        | meow-reverse                |
| ,        | meow-inner-of-thing         |
| .        | meow-bounds-of-thing        |
| <        | meow-beginning-of-thing     |
| >        | meow-end-of-thing           |
| a        | meow-append                 |
| A        | meow-open-below             |
| b        | meow-back-word              |
| B        | meow-back-symbol            |
| c        | meow-change                 |
| d        | meow-delete                 |
| D        | meow-backward-delete        |
| e        | meow-next-word              |
| E        | meow-next-symbol            |
| f        | meow-find                   |
| g        | meow-cancel-selection       |
| G        | meow-grab                   |
| h        | meow-left                   |
| H        | meow-left-expand            |
| i        | meow-insert                 |
| I        | meow-open-above             |
| j        | meow-next                   |
| J        | meow-next-expand            |
| k        | meow-prev                   |
| K        | meow-prev-expand            |
| l        | meow-right                  |
| L        | meow-right-expand           |
| m        | meow-join                   |
| n        | meow-search                 |
| o        | meow-block                  |
| O        | meow-to-block               |
| p        | meow-yank                   |
| P        | meow-yank-pop               |
| q        | meow-quit                   |
| Q        | meow-goto-line              |
| r        | meow-replace                |
| R        | meow-swap-grab              |
| s        | meow-kill                   |
| t        | meow-till                   |
| u        | meow-undo                   |
| U        | meow-undo-in-selection      |
| v        | meow-visit                  |
| w        | meow-mark-word              |
| W        | meow-mark-symbol            |
| x        | meow-line                   |
| X        | meow-goto-line              |
| y        | meow-save                   |
| z        | meow-pop-selection          |
**** Motion

#+TBLNAME: motion-keybindings
| key      | command   |
|----------+-----------|
| <escape> | ignore    |
| j        | meow-next |
| k        | meow-prev |

**** Leader

#+tblname: leader-keybindings
| key | command                  |
|-----+--------------------------|
|   1 | meow-digit-argument      |
|   2 | meow-digit-argument      |
|   3 | meow-digit-argument      |
|   4 | meow-digit-argument      |
|   5 | meow-digit-argument      |
|   6 | meow-digit-argument      |
|   7 | meow-digit-argument      |
|   8 | meow-digit-argument      |
|   9 | meow-digit-argument      |
|   0 | meow-digit-argument      |
|   ? | meow-keypad-describe-key |
|   e | dispatch: C-x C-e        |

**** setup

#+header: :var normal-keybindings=normal-keybindings :var motion-keybindings=motion-keybindings :var leader-keybindings=leader-keybindings
#+begin_src emacs-lisp
  (defun meow-setup ()
    (let ((parse-def (lambda (x)
                       (cons (format "%s" (car x))
                             (if (string-prefix-p "dispatch:" (cadr x))
                                 (string-trim (substring (cadr x) 9))
                               (intern (cadr x)))))))
      (apply #'meow-normal-define-key (mapcar parse-def normal-keybindings))
      (apply #'meow-motion-overwrite-define-key (mapcar parse-def motion-keybindings))
      (apply #'meow-leader-define-key (mapcar parse-def leader-keybindings))))
#+end_src

#+begin_src emacs-lisp
(use-package meow
  :ensure t
  :custom (meow-char-thing-table '((?\( . round)
                                   (?\[ . square)
                                   (?\{ . curly)
                                   (?\" . string)
                                   (?e . symbol)
                                   (?w . window)
                                   (?b . buffer)
                                   (?p . paragraph)
                                   (?l . line)
                                   (?v . visual-line)
                                   (?d . defun)
                                   (?. . sentence)))
  :config
  ;; custom indicator
  (setq meow-replace-state-name-list '((normal . "🅝")
                                       (beacon . "🅑")
                                       (insert . "🅘")
                                       (motion . "🅜")
                                       (keypad . "🅚")))
  ;; custom variables
  (setq meow-esc-delay 0.1)
  (meow-thing-register 'angle '(pair ("<")
                                     (">"))
                       '(pair ("<")
                              (">")))
  (add-to-list 'meow-char-thing-table '(?< . angle))
  (add-to-list 'meow-mode-state-list '(cargo-process-mode . motion))
  (add-to-list 'meow-mode-state-list '(emms-playlist-mode . motion))
  (add-to-list 'meow-mode-state-list '(agent-shell-mode . insert))
  (add-to-list 'meow-mode-state-list '(agent-shell-viewport-view-mode . motion))
  (add-to-list 'meow-mode-state-list '(agent-shell-viewport-edit-mode . insert))
  (meow-setup)
  (meow-setup-indicator)
  (meow-global-mode 1)
  )
  #+end_src
* Server
** Description

Emacs general behaviour

** Implementation
:PROPERTIES:
  :header-args: :tangle modules/home/emacs/init.el
:END:

*** server

#+begin_src emacs-lisp
(server-start)
#+end_src