Emacs config, org-mode style.

(let ((bootstrap-file (concat user-emacs-directory "straight/repos/straight.el/bootstrap.el"))
      (bootstrap-version 3))
  (unless (file-exists-p bootstrap-file)
    (with-current-buffer
        (url-retrieve-synchronously
         "https://raw.githubusercontent.com/raxod502/straight.el/develop/install.el"
         'silent 'inhibit-cookies)
      (goto-char (point-max))
      (eval-print-last-sexp)))
  (load bootstrap-file nil 'nomessage))

(setq straight-use-package-by-default t)
(straight-use-package 'use-package)
(use-package git)

(setq custom-file (make-temp-file ""))

(defvar my/org-path-name (expand-file-name "~/lab-notebook/"))

(defun my/make-org-file-name (file-name)
  (concat my/org-path-name file-name))

(defvar my/notes-file-name (my/make-org-file-name "notes.org"))

(defvar my/template-directory (concat my/org-path-name "templates"))

(defun my/make-template-file-name (file-name)
  (concat my/template-directory file-name))

(add-to-list 'Info-directory-list (concat user-emacs-directory "info/"))

(require 'json)
(let ((json-object-type 'plist))
  (setq  my/secrets (json-read-file (concat user-emacs-directory "secrets.json"))))

  (use-package ef-themes
   :defer
   :straight (ef-themes :type git :host github :repo "protesilaos/ef-themes")
   :bind ("<f5>" . ef-themes-toggle)
   :config
   (defun my-ef-themes-hl-todo-faces ()
  "Configure `hl-todo-keyword-faces' with Ef themes colors.
The exact color values are taken from the active Ef theme."
  (ef-themes-with-colors
    (setq hl-todo-keyword-faces
          `(("HOLD" . ,yellow)
            ("TODO" . ,red)
            ("NEXT" . ,blue)
            ("THEM" . ,magenta)
            ("PROG" . ,cyan-warmer)
            ("OKAY" . ,green-warmer)
            ("DONT" . ,yellow-warmer)
            ("FAIL" . ,red-warmer)
            ("BUG" . ,red-warmer)
            ("DONE" . ,green)
            ("NOTE" . ,blue-warmer)
            ("KLUDGE" . ,cyan)
            ("HACK" . ,cyan)
            ("TEMP" . ,red)
            ("FIXME" . ,red-warmer)
            ("XXX+" . ,red-warmer)
            ("REVIEW" . ,red)
            ("DEPRECATED" . ,yellow)))))

(add-hook 'ef-themes-post-load-hook #'my-ef-themes-hl-todo-faces)
   (setq ef-themes-to-toggle (list 'ef-deuteranopia-light 'ef-deuteranopia-dark)))

(use-package solar
:straight (:type built-in)
:config
(setq calendar-latitude (plist-get my/secrets :home-latitude)
      calendar-longitude (plist-get my/secrets :home-longitude)))

(use-package circadian
  :after solar
  :config
  (setq circadian-themes '((:sunrise .  ef-deuteranopia-light)
                           (:sunset  .  ef-deuteranopia-dark)))
  (circadian-setup))

 ;; (add-to-list 'default-frame-alist '(font . "Menlo 10"))
     (when (eq system-type 'darwin)
       (add-to-list 'default-frame-alist '(font . "JetBrainsMono Nerd Font Mono 12"))
       )
 (when (eq system-type 'gnu/linux)
 (add-to-list 'default-frame-alist '(font . "JetBrainsMono Nerd Font Mono 10"))
)

 ;; (add-to-list 'default-frame-alist '(font . "NotoSansMono 10"))
 ;; (add-to-list 'default-frame-alist '(font . "NotoMonoNerdFont 10"))
 ;; (setq nerd-icons-font-family "Noto Mono Nerd Font")

(defun diff-kill-this-buffer ()
  (interactive)
  (catch 'quit
    (save-window-excursion
      (let (done)
        (when (and buffer-file-name (buffer-modified-p))
          (while (not done)
            (let ((response (read-char-choice
                             (format "Save file %s? (y, n, d, q) " (buffer-file-name))
                             '(?y ?n ?d ?q))))
              (setq done (cond
                          ((eq response ?q) (throw 'quit nil))
                          ((eq response ?y) (save-buffer) t)
                          ((eq response ?n) (set-buffer-modified-p nil) t)
                          ((eq response ?d) (diff-buffer-with-file) nil))))))
        (kill-buffer (current-buffer))))))

(global-set-key [remap kill-buffer] 'diff-kill-this-buffer)

(use-package all-the-icons
:config (require 'all-the-icons))

(use-package ws-butler
  :straight (ws-butler :type git
             :host github
             :repo "lewang/ws-butler")
  :hook ((org-mode markdown-mode yaml-ts-mode) . ws-butler-mode)
  )

;; (require 'ws-butler)
;; enable for programming modes
;; (add-hook 'org-mode-hook #'ws-butler-mode)
;; (add-hook 'markdown-mode-hook #'ws-butler-mode)
;; or enable everywhere
;; (ws-butler-global-mode)

(use-package avy
  ;; :straight (avy :type git :host nil :repo "https://github.com/abo-abo/avy.git")
  :config
  (defun grym/avy-goto-after-char-timer ()
    ;; put point _after_ selected char, not before
    (interactive)
    (avy-goto-char-timer)
    (forward-symbol 1))
  (global-set-key (kbd "C-;") 'avy-goto-char-timer)
  (global-set-key (kbd "C-M-;") 'grym/avy-goto-after-char-timer)
  (global-unset-key (kbd "C-'"))
  (global-set-key (kbd "C-'") 'avy-goto-line)
  (global-set-key (kbd "M-g w") 'avy-goto-word-1)
  )

(use-package dimmer
 :straight (dimmer :type git :host nil :repo "https://github.com/gonewest818/dimmer.el")
 :config
 (dimmer-configure-which-key)
 (dimmer-configure-magit)
(setq dimmer-adjustment-mode :background)
(setq dimmer-fraction 0.05)
;; (add-to-list 'dimmer-exclusion-regexp-list "^\\*imenu-list\\*$")
(setq dimmer-use-colorspace :rgb)
 (dimmer-mode t)
 )

(use-package with-editor
  :straight (with-editor :type git :host nil :repo "https://github.com/magit/with-editor")
  :config

  (cl-defun with-editor-export-editor-eat (process &optional (envvar "EDITOR"))
    "Like `with-editor-export-editor', but for `eat-exec-hook'."
    (cond
     ((derived-mode-p 'eat-mode)
      (if with-editor-emacsclient-executable
          (let ((with-editor--envvar envvar)
                (process-environment process-environment))
            (with-editor--setup)
            (while (accept-process-output process 0.1))
            (when-let ((v (getenv envvar)))
              (eat-term-send-string eat-terminal (format " export %s=%S" envvar v))
              (eat-self-input 1 'return))
            (when-let ((v (getenv "EMACS_SERVER_FILE")))
              (eat-term-send-string eat-terminnal (format " export EMACS_SERVER_FILE=%S" v))
              (eat-self-input 1 'return))
            (eat-term-send-string eat-terminal "clear")
            (eat-self-input 1 'return))
        (error "Cannot use sleeping editor in this buffer")))
     (t (error "Cannot export environment variables in this buffer")))
    (message "Successfully exported %s" envvar))

  (add-hook 'eat-exec-hook #'with-editor-export-editor-eat)

  (keymap-global-set "<remap> <async-shell-command>"
                     #'with-editor-async-shell-command)
  (keymap-global-set "<remap> <shell-command>"
                     #'with-editor-shell-command)
  )

(use-package whisper
  :straight (whisper :type git :host nil :repo "https://github.com/natrys/whisper.el")
  :bind ("<XF86Launch9>" . whisper-run)
  :config
  (setq whisper-install-whispercpp 'manual)
  (setq whisper-install-directory "~/.local/bin/"))

(use-package info-colors
  :config
  (add-hook 'Info-selection-hook 'info-colors-fontify-node)
 )

(use-package windmove)
(use-package transpose-frame)
(use-package ace-window
  ;; :bind* (("C-<tab>" . ace-window))  ;; bind* overrides other bindings, i think
  :config (setq aw-scope 'frame))
;; (require 'windmove)
;; (require 'ace-window)

(use-package switchy-window
  :ensure t
  :custom (switchy-window-delay 1.5) ;; That's the default value.
  :bind (:map switchy-window-minor-mode-map
                        ;; Bind to separate key...
                        ;; ...or as `other-key' substitute (C-x o).
                        ;; ("<remap> <other-window>" . switchy-window))
                        ("C-<tab>" . switchy-window))

  :init
  (switchy-window-minor-mode))

(use-package beacon
 :config
 (beacon-mode t
 ))

(use-package breadcrumb
 :straight (breadcrumb :type git :host nil :repo "https://github.com/joaotavora/breadcrumb")
 :config
 (breadcrumb-mode
 )
 )

(use-package casual
 :straight (casual :type git :host nil :repo "https://github.com/kickingvegas/casual")
 ;; :after (ibuffer calc dired)
 :bind ((:map dired-mode-map ("C-o" . casual-dired-tmenu))
        (:map calc-mode-map ("C-o" . casual-calc-tmenu))
        (:map Info-mode-map ("C-o" . casual-info-tmenu))
        (:map isearch-mode-map ("<f2>" . casual-isearch-tmenu))
        (:map ibuffer-mode-map
              ("C-o" . casual-ibuffer-tmenu)
              ("F" . casual-ibuffer-filter-tmenu)
              ("s" . casual-ibuffer-sortby-tmenu))
        )
 :config
 ;; (global-set-key (kbd"C-c o") 'casual-editkit-main-tmenu)
 )

(use-package comment-dwim-2
  :straight (comment-dwim-2 :type git :host github :repo "remyferre/comment-dwim-2")
  :config
 (global-set-key (kbd "M-;") 'comment-dwim-2)
 (define-key org-mode-map (kbd "M-;") 'org-comment-dwim-2))

(use-package crux
  :straight (crux :type git
                  :host github
                  :repo "bbatsov/crux")
  :config
    (global-set-key (kbd "C-<backspace>") #'crux-kill-line-backwards)
    (global-set-key (kbd "C-a") #'crux-move-beginning-of-line)
    (global-set-key (kbd "C-M-j") #'crux-eval-and-replace))

(use-package devil
 :straight (devil :type git :host nil :repo "https://github.com/susam/devil")
 :config
  (global-devil-mode)
  (global-set-key (kbd "C-,") 'global-devil-mode))

(use-package diff-hl
 :straight (diff-hl :type git
                    :host github
                    :repo "dgutov/diff-hl")
 :config (global-diff-hl-mode))

(use-package doom-modeline
 :straight (doom-modeline :type git :host github :repo "seagle0128/doom-modeline")
 :init (doom-modeline-mode 1)
 :defer 1
 :config
 (setq doom-modeline-icon t)
 (setq doom-modeline-unicode-fallback t)
 (setq doom-modeline-vcs-max-length 24)
 ;; (setq doom-modeline-enable-word-count nil)
 ;; (setq doom-modeline-gnus nil)
 ;; (setq doom-modeline-irc nil)
 ;; (setq doom-modeline-env-version nil)
 )

(use-package
  dwim-shell-command
  :straight (dwim-shell-command
             :type git
             :host github
             :repo "xenodium/dwim-shell-command")
  :config

  (defun grym/dwim-shell-command-thumbnail-with-ffmpeg ()
    "Generate a thumbnail with ffmpeg."
    (interactive)
    (dwim-shell-command-on-marked-files
     "Thumbnail with ffmpeg"
     " ffmpeg -i '<<f>>' -vf  \"thumbnail,scale=640:360\" -frames:v 1 '<<td>>/<<fne>>.png'"
     :utils "ffmpeg"
     :silent-success t))

  (defun grym/dwim-shell-command-feh-marked-files ()
    "View all marked files with feh."
    (interactive)
    (dwim-shell-command-on-marked-files
     "View with feh"
     " feh --auto-zoom --scale-down '<<*>>'"
     :utils "feh"
     :silent-success t))

  (defun grym/dwim-shell-command-oxo-marked-files ()
    "Upload all marked files to 0x0.st"
    (interactive)
    (when (y-or-n-p "upload with oxo?")
    (dwim-shell-command-on-marked-files
     "upload with oxo"
     "oxo files '<<*>>'"
     :utils "oxo")))

  (defun grym/dwim-shell-command-dragon-marked-files ()
    "Share all marked files with dragon."
    (interactive)
    (dwim-shell-command-on-marked-files
     "Share with dragon"
     " dragon --on-top '<<*>>'"
     :utils "dragon"
     :silent-success t))
  )

 (use-package eat
  :straight (eat :type git :host nil :repo "https://codeberg.org/akib/emacs-eat" :files (:defaults "integration"))
  :after with-editor
  :config
(setq eat-query-before-killing-running-terminal 'auto)
(setq eat-kill-buffer-on-exit t)
(setq eat-term-scrollback-size nil))

  (use-package emojify
  :config
  (when (member "Noto Color Emoji" (font-family-list))
    (set-fontset-font
     t 'symbol (font-spec :family "Noto Color Emoji") nil 'prepend))
  (setq emojify-display-style 'unicode)
  (setq emojify-emoji-styles '(unicode))
  (bind-key* (kbd "C-c e") #'emojify-insert-emoji))


;; (use-package
;;     emojify
;;     ;; :hook (after-init . global-emojify-mode)
;;     :bind ("C-c e" . 'emojify-insert-emoji)
;;     :config (setq emojify-display-style
;;                   'unicode))
;; (setq emojify-emoji-styles)
;; '(unicode))

(define-minor-mode long-s-mode
  "Minor mode for inserting 'ſ' characters")

(defconst +long-s+ ?ſ)
(defconst +short-s+ ?s)

(defun long-s-p (char)
  (char-equal char +long-s+))

(defun short-s-p (char)
  (or (char-equal char +short-s+)))

(defun s-char-p (char)
  (or (long-s-p char)
      (short-s-p char)))

(defun alpha-char-p (char)
  (memq (get-char-code-property char 'general-category)
        '(Ll Lu Lo Lt Lm Mn Mc Me Nl)))

(defun long-s-insert-short-s ()
  (interactive)
  (if (long-s-p (preceding-char))
      (insert-char +short-s+)
    (insert-char +long-s+)))

(defun long-s-insert-space ()
  (interactive)
  (if (long-s-p (preceding-char))
      (progn (delete-backward-char 1)
             (insert-char +short-s+))
    (save-excursion
      (while (not (alpha-char-p (preceding-char)))
        (backward-char))
      (when (long-s-p (preceding-char))
        (delete-backward-char 1)
        (insert-char +short-s+))))
  (insert-char ?\ ))

(defvar long-s-mode-map
  (let ((map (make-sparse-keymap)))
    (set-keymap-parent map (current-global-map))
    (define-key map (kbd "s") #'long-s-insert-short-s)
    (define-key map (kbd "SPC") #'long-s-insert-space)
    map))

(setq long-s-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map (kbd "s") #'long-s-insert-short-s)
    (define-key map (kbd "SPC") #'long-s-insert-space)
    map))

(unless (seq-some #'(lambda (x) (eq (car x) 'long-s-mode))
                 minor-mode-map-alist)
  (push (cons 'long-s-mode long-s-mode-map)
        minor-mode-map-alist))

(provide 'long-s-mode)

  (use-package exec-path-from-shell
  :init
  (setq exec-path-from-shell-check-startup-files nil)
  :config (exec-path-from-shell-initialize)
)

  (when (eq system-type 'darwin)
       (use-package flx-rs
          :after fussy
          :straight
          (flx-rs
           :type git
           :host nil
           :repo "https://github.com/jcs-elpa/flx-rs"
           :files (:defaults "bin"))
          :config
          (setq fussy-score-fn 'fussy-flx-rs-score)
          (flx-rs-load-dyn))

  )
(when (eq system-type 'gnu/linux)
    (use-package sublime-fuzzy
      :after fussy
      :straight
      (sublime-fuzzy
       :type git
       :host nil
       :repo  "https://github.com/jcs-elpa/sublime-fuzzy"
       :files (:defaults "bin"))
      :config
      (setq fussy-score-fn 'fussy-sublime-fuzzy-score)
      (sublime-fuzzy-load-dyn))
  )



          (use-package fussy
           :straight (fussy :type git :host nil :repo "https://github.com/jojojames/fussy")
           :after company
           :config
           (push 'fussy completion-styles)

           ;; (setq fussy-score-fn 'fussy-flx-rs-score)
          (setq
           ;; For example, project-find-file uses 'project-files which uses
           ;; substring completion by default. Set to nil to make sure it's using
           ;; flx.
           completion-category-defaults nil
           completion-category-overrides nil)

          (defun j-company-capf (f &rest args)
        "Manage `completion-styles'."
        (if (length= company-prefix 0)
            ;; Don't use `company' for 0 length prefixes.
            (let ((completion-styles (remq 'fussy completion-styles)))
              (apply f args))
          (let ((fussy-max-candidate-limit 5000)
                (fussy-default-regex-fn 'fussy-pattern-first-letter)
                (fussy-prefer-prefix nil))
            (apply f args))))

      (defun j-company-transformers (f &rest args)
        "Manage `company-transformers'."
        (if (length= company-prefix 0)
            ;; Don't use `company' for 0 length prefixes.
            (apply f args)
          (let ((company-transformers '(fussy-company-sort-by-completion-score)))
            (apply f args))))

      (advice-add 'company-auto-begin :before 'fussy-wipe-cache)
      (advice-add 'company--transform-candidates :around 'j-company-transformers)
      (advice-add 'company-capf :around 'j-company-capf)


      (with-eval-after-load 'eglot
        (add-to-list 'completion-category-overrides
                     '(eglot (styles fussy basic))))

           )

;; https://github.com/Wilfred/helpful
(use-package helpful
  :after transient
  :init
  (transient-define-prefix helpful-transient ()
    "Helpful commands"
    [["Helpful"
      ("f" "callable" helpful-callable)
      ("v" "variable" helpful-variable)
      ("k" "key" helpful-key)
      ("c" "command" helpful-command)
      ("d" "thing at point" helpful-at-point)]])
  :bind ("M-C-h" . helpful-transient))

 (use-package indent-bars
  :straight (indent-bars :type git :host nil :repo "https://github.com/jdtsmith/indent-bars")
  :hook ((python-mode yaml-mode) . indent-bars-mode)
:custom
(indent-bars-treesit-support t)
(indent-bars-no-descend-string t)
(indent-bars-treesit-ignore-blank-lines-types '("module"))
 (indent-bars-treesit-wrap '((python argument_list parameters ; for python, as an example
                                     list list_comprehension
                                     dictionary dictionary_comprehension
                                     parenthesized_expression subscript)))
 :config

  )


 ;; )

(use-package jinx
  :straight (:host github :repo "minad/jinx" :files (:defaults "jinx-mod.c" "emacs-module.h"))
  :bind (([remap ispell-word] . #'jinx-correct))
  :hook (emacs-startup-hook . global-jinx-mode)
  )

(use-package region-bindings-mode
  :config (region-bindings-mode-enable))

(use-package expreg
 :straight (expreg :type git :host nil :repo "https://github.com/casouri/expreg")
 :bind* (("M-2" . expreg-expand)
         ("M-3" . expreg-contract))
 :config
 )

(use-package multiple-cursors
  :after region-bindings-mode
  :bind (:map region-bindings-mode-map
              ("a" . mc/mark-all-like-this)
              ("p" . mc/mark-previous-like-this)
              ("n" . mc/mark-next-like-this)
              ("P" . mc/unmark-previous-like-this)
              ("N" . mc/unmark-next-like-this)
              ("[" . mc/cycle-backward)
              ("]" . mc/cycle-forward)
              ("m" . mc/mark-more-like-this-extended)
              ("h" . mc-hide-unmatched-lines-mode)
              ("\\" . mc/vertical-align-with-space)
              ("#" . mc/insert-numbers) ; use num prefix to set the starting number
              ("^" . mc/edit-beginnings-of-lines)
              ("$" . mc/edit-ends-of-lines))
  )
(global-set-key (kbd "C-M-SPC") 'set-rectangular-region-anchor)

(use-package
  olivetti
  :hook (Info-mode . olivetti-mode)
  :config (setq olivetti-body-width 120)
  )

(use-package jira
 :straight ( :type git :host nil :repo "https://github.com/unmonoqueteclea/jira.el")
 :config
  (setq jira-base-url (plist-get my/secrets :work-jiralib-url)) ;; Jira instance URL
  (setq jira-username (plist-get my/secrets :work-jira-username)) ;; Jira username (usually, an email)
  ;; API token for Jira
  ;; See https://support.atlassian.com/atlassian-account/docs/manage-api-tokens-for-your-atlassian-account/
  (setq jira-token (plist-get my/secrets :work-jira-key))
  (setq jira-token-is-personal-access-token nil)
  (setq jira-api-version 3) ;; Version 2 is also allowed
 )

(use-package org-jira
 :straight (org-jira :type git :host nil :repo "https://github.com/ahungry/org-jira")
 :config
 (setq jiralib-url (plist-get my/secrets :work-jiralib-url))
 (setq org-jira-working-dir (concat my/org-path-name (plist-get my/secrets :work-jira-working-dir)))
 (setq org-jira-custom-jqls `((:jql ,(plist-get my/secrets :work-org-jira-all-query)
                              :limit 200
                              :filename ,(plist-get my/secrets :work-org-jira-file)))))

(use-package
  pdf-tools
  :init (pdf-tools-install t)
  (setq-default
   pdf-view-display-size
   'fit-page)
  :config
  ;;https://github.com/vedang/pdf-tools?tab=readme-ov-file#auto-revert
  (add-hook 'TeX-after-compilation-finished-functions #'TeX-revert-document-buffer))

(use-package popper
 :straight ( popper :type git :host nil :repo "https://github.com/karthink/popper")
   :bind (("C-`"   . popper-toggle)
         ("M-`"   . popper-cycle)
         ("C-M-`" . popper-toggle-type))
  :init
  (setq popper-reference-buffers
        '("\\*Messages\\*"
          "Output\\*$"
          "\\*Async Shell Command\\*"
          help-mode
          compilation-mode))
  (popper-mode +1)
  (popper-echo-mode +1)
 )

(use-package rainbow-mode
  :hook ((org-mode emacs-lisp-mode yaml-ts-mode python-ts-mode sgml-mode) . rainbow-mode))

(use-package rg
 :straight (rg :type git :host github :repo "dajva/rg.el")
 :config
 (rg-enable-menu)
 )

(use-package
  super-save
  :straight (super-save
             :type git
             :host github
             :repo "bbatsov/super-save")
  :config (super-save-mode 1)
  (setq super-save-remote-files nil)
  (setq super-save-all-buffers t)
  (setq super-save-auto-save-when-idle t)
  (setq super-save-idle-duration 1))

(use-package unfill
 :straight (unfill :type git :host github :repo "purcell/unfill")
 :bind ("C-M-q" . unfill-region)
 :config
 )

  (use-package unicode-fonts
    :ensure t
    :config
    (unicode-fonts-setup)
    (set-fontset-font t 'symbol "Noto Color Emoji"))
  ;; Enable colour emoji. 😄 🎉
;; (set-fontset-font t 'symbol "Noto Color Emoji" nil)
;; (set-fontset-font t 'symbol "Segoe UI Emoji" nil 'append)
;; (set-fontset-font t 'symbol "Symbola" nil 'append)

;; Add Apple Color Emoji to the default symbol fontset used by Emacs
(defun zdx/set-emoji-font ()
  (set-fontset-font "fontset-default" 'symbol "Noto Color Emoji" nil 'prepend))

;; Call the config function once and then remove the handler
(defun zdx/set-emoji-font-in-frame (frame)
  (with-selected-frame frame
    (zdx/set-emoji-font))
  ;; Unregister this hook once its run
  (remove-hook 'after-make-frame-functions
               'zdx/set-emoji-font-in-frame))

;; Attach the function to the hook only if in Emacs server
;; otherwise just call the config function directly
(if (daemonp)
    (add-hook 'after-make-frame-functions
              'zdx/set-emoji-font-in-frame)
  (zdx/set-emoji-font))

(use-package visual-regexp
  :straight (visual-regexp :type git :host github :repo "benma/visual-regexp.el")
  :config
  )
(use-package
  visual-regexp-steroids
  :after visual-regexp
  :straight (visual-regexp-steroids
             :type git
             :host github
             :repo "benma/visual-regexp-steroids.el")
  :config (define-key global-map (kbd "C-c r")
            'vr/replace)
  (define-key global-map (kbd "C-c q")
    'vr/query-replace)
  ;; if you use multiple-cursors, this is for you:
  (define-key global-map (kbd "C-c m")
    'vr/mc-mark))

(use-package vundo
 :straight (vundo :type git :host nil :repo "https://github.com/casouri/vundo")
 :config
  (setq vundo-glyph-alist vundo-unicode-symbols)
 )

(use-package
  webpaste
  :bind (("C-c C-p C-b" . webpaste-paste-buffer)
         ("C-c C-p C-r" . webpaste-paste-region))
  :config (progn
            (setq webpaste-provider-priority
                  '("bpa.st"
                    "dpaste.org"
                    "dpaste.com")))
  (setq webpaste-paste-confirmation
        t)
  ;; fix emacs-lisp handling for bpa.st, add csharp
  ;; to see list of lexers access https://bpa.st/api/v1/lexer
  (plist-put
   (cdr (assoc "bpa.st"
               webpaste-providers-alist))
   :lang-overrides '((emacs-lisp-mode . "emacs-lisp")
                     ;; (csharp-mode . "csharp")
                     ;; (csharp-ts-mode . "csharp")
                     (python-mode . "python")
                     (python-ts-mode . "python")))
  (require 'cl-lib)
  (cl-defun
      workpaste-paste-buffer-or-region
      (&optional point mark)
    "use internally facing webpaste provider only."
    (interactive "r")
    (let ((webpaste-providers-alist `(("bpaste.work"
                                       :uri ,(plist-get
                                              my/secrets
                                              :work-pastebin-url)
                                       :post-data (("expiry" . "longtime"))
                                       :error-lambda webpaste--providers-error-lambda-no-failover
                                       :post-field-lambda webpaste--providers-pinnwand-request
                                       :lang-overrides ((emacs-lisp-mode . "emacs-lisp")
                                                        (python-ts-mode . "python")
                                                        (json-ts-mode . "json"))
                                       :success-lambda webpaste--providers-pinnwand-success)))
          (webpaste-provider-priority '("bpaste.work")))
      ;; if region is selected
      (if (region-active-p)
          ;; Paste selected region
          (webpaste-paste-region
           point
           mark)
        ;; Else, Paste buffer
        (webpaste-paste-buffer)))))

(winner-mode t)

 (use-package zoom-window
  :straight (zoom-window :type git :host github :repo "emacsorphanage/zoom-window")
  :config
(setq zoom-window-mode-line-color "medium sea green"
  ))

(use-package zzz-to-char
 :straight (zzz-to-char :type git :host nil :repo "https://github.com/mrkkrp/zzz-to-char")
 :config
 (global-set-key (kbd "M-z") #'zzz-to-char-up-to-char)
 (global-set-key (kbd "M-Z") 'zap-up-to-char)
 )

(defun consult-line-symbol-at-point ()
  "Search for a line matching the symbol found near point."
  (interactive)
  (consult-line
   (or (thing-at-point 'symbol))))

(global-set-key (kbd "M-s .") #'consult-line-symbol-at-point)
(global-set-key (kbd "M-s M-s .") #'isearch-forward-symbol-at-point)

(defun grym/dired-go-home ()
  "Go home"
  (interactive)
  (dired "~" )
  )

;; kill the python repl if running, start a new repl, and send the current buffer to it as main:
(defun grym/python-kill-and-send-buffer-as-main-interactive ()
  (interactive)
  (let*
    (
      (python-buffer "*Python*")
    )
    (if (get-buffer python-buffer)
      (let ((kill-buffer-query-functions nil))
        (kill-buffer python-buffer)))
    (run-python (python-shell-calculate-command) t t)
    (sit-for 0.2)
;    (run-python)  ; note this does not switch the current buffer
    (python-shell-send-buffer t)))

(defun grym/insert-file-at-point ()
  "Insert a newline, then contents of file at point if possible."
  (interactive)
  (save-excursion
    (insert-file-contents (ffap-file-at-point)))
  (newline))

;; https://gist.github.com/barrosfelipe/a177c63331a877864b499b080eb939fd
(defun insert-url-1 (url insert-func)
  (let* ((tem (funcall insert-func url)))
    (push-mark (+ (point) (car (cdr tem))))))


(defun grym/insert-url (url)
  "Insert contents of URL into buffer after point.
    Set mark after the inserted text.

    This function is meant for the user to run interactively.
    Don't call it from programs!
    Use `url-insert-file-contents' instead.
    \(Its calling sequence is different; see its documentation)."
  (declare (interactive-only url-insert-file-contents))
  (interactive "*sInsert URL: ")
  (insert-url-1 url #'url-insert-file-contents))

(defun grym/get-raw-pinnwand-url (pinnwand-url)
  "Take a pinnwand URL (e.g., bpa.st) and get its raw form."
  (let ((original-url (url-generic-parse-url
                       pinnwand-url)))
    (setf
     (url-filename original-url)
     (concat
      "/raw"
      (url-filename original-url)))
    (url-recreate-url original-url)))

(defun grym/insert-pinnwand-url (url)
  (interactive "*sInsert URL: ")
  (grym/insert-url (grym/get-raw-pinnwand-url url)))

(defun xah-clean-empty-lines ()
  "Replace repeated blank lines to just 1.
Works on whole buffer or text selection, respects `narrow-to-region'.

URL `http://xahlee.info/emacs/emacs/elisp_compact_empty_lines.html'
Version 2017-09-22 2020-09-08"
  (interactive)
  (let ($begin $end)
    (if (use-region-p)
        (setq $begin (region-beginning) $end (region-end))
      (setq $begin (point-min) $end (point-max)))
    (save-excursion
      (save-restriction
        (narrow-to-region $begin $end)
        (progn
          (goto-char (point-min))
          (while (re-search-forward "\n\n\n+" nil "move")
            (replace-match "\n\n")))))))

(defun grym/spam-precommit-in-project ()
  "Run pre-commit repeatedly in current project, if pre-commit is installed."
  (interactive)
  (unless (not (executable-find "pre-commit"))
  (let ((precommit-max-tries 6))
    (while (or (/= 0 (call-process "pre-commit" nil "*pre-commit output*" nil "run" "--all-files")) (> 0 precommit-max-tries))
      (setq precommit-max-tries (1- precommit-max-tries))
      ))
    )
)

  (defun grym/new-scratch-text-buffer ()
  "make a new empty text mode buffer"
(interactive)
  (switch-to-buffer (format-time-string "%d %b %Y %H:%M:%S")))

(use-package projectile
  :init
  (setq projectile-enable-caching t)
  (setq projectile-keymap-prefix (kbd "C-c p"))
  :config
  (projectile-mode t))

(setq projectile-project-search-path (list (expand-file-name "~/Projects/")
                                           (expand-file-name "~/lab-notebook")
                                           (expand-file-name (concat user-emacs-directory "emacs-nougat"))))

(use-package ob-markdown
 :straight (ob-markdown :type git :host github :repo "tnoda/ob-markdown")
 :after markdown-mode
 )

(org-babel-do-load-languages
 'org-babel-load-languages
 '((shell . t)
         (emacs-lisp . t)
         (sqlite . t)
         (python . t)
         (awk . t)
         ;; (markdown . t)
         ;; (restclient . t )
         ))

(setq org-babel-default-header-args
      '((:session . "none")
        (:results . "replace")
        (:exports . "code")
        (:cache . "no")
        (:noweb . "no")
        (:hlines . "no")
        (:tangle . "no")))

(setq org-confirm-babel-evaluate nil)
(setq org-confirm-shell-link-function nil)
(setq org-confirm-elisp-link-function nil)

(use-package htmlize)

;; (use-package toc-org
;;   :config
;;   (add-hook 'org-mode-hook 'toc-org-enable))

(use-package ox-gfm)
(eval-after-load "org"
  '(require 'ox-gfm nil t))

(require 'ox-beamer)
(setq org-beamer-mode t)
(require 'ox-latex)

(use-package org-download
 :straight (org-download :type git
               :host github
               :repo "abo-abo/org-download")
 :config
 (add-hook 'dired-mode-hook 'org-download-enable)
 )

(defun org-babel-speed-command-hook (keys)
  (when (org-babel-where-is-src-block-head)
    (cdr (assoc keys org-babel-key-bindings))))

(use-package ox-clip
 :straight (ox-clip :type git :host nil :repo "https://github.com/jkitchin/ox-clip")
 :config
 )

(require 'org-protocol)

(defun org-summary-todo (n-done n-not-done)
  "Switch entry to DONE when all subentries are done, to TODO otherwise."
  (let (org-log-done org-log-states)   ; turn off logging
    (org-todo (if (= n-not-done 0) "DONE" "TODO"))))

(add-hook 'org-after-todo-statistics-hook #'org-summary-todo)

(use-package mixed-pitch
  :hook
  ;; If you want it in all text modes:
  (org-mode . mixed-pitch-mode))

(setq org-cycle-separator-lines 0)

(defun grym/org-kill-block-or-link-at-point ()
  "Kill the body of the block or the link of the link at point.

For blocks, the content is copied if the cursor is in any
position within the block.

+ #+BEGIN_SRC
+ #+BEGIN_EXPORT
+ #+BEGIN_EXAMPLE
+ #+BEGIN_COMMENT
+ #+BEGIN_VERSE
+ #+BEGIN_QUOTE

For links, everything but the description is copied.

from rdrg109"
  (interactive)
  (let* (content
         (element (org-element-context))
         (type (org-element-type element)))
    (cond
     ;; The link is the first condition so that it is copied
     ;; even though it is within a #+BEGIN_VERSE or
     ;; #+BEGIN_QUOTE.
     ;;
     ;; This doesn't consider links within #+BEGIN_SRC,
     ;; #+BEGIN_EXPORT, #+BEGIN_EXAMPLE or #+BEGIN_COMMENT.
     ((eq type 'link)
      (setq content (org-element-property :raw-link element)))
     ((or (eq type 'src-block)
          (eq type 'export-block)
          (eq type 'example-block)
          (eq type 'comment-block))
      (setq content (org-element-property :value element)))
     ;; True if the cursor is in the line containing
     ;; #+BEGIN_VERSE, #+END_VERSE, #+BEGIN_QUOTE or #+END_QUOTE.
     ((or (eq type 'verse-block)
          (eq type 'quote-block))
      (setq content (buffer-substring-no-properties
                     (org-element-property :contents-begin element)
                     (org-element-property :contents-end element))))
     ;; Visit the parents to find out whether we are within a
     ;; #+BEGIN_QUOTE or #+BEGIN_VERSE block.
     ((let (type outermost (parent element))
        (while (setq parent (org-element-property :parent parent))
          (setq outermost parent))
        (setq type (org-element-type outermost))
        (when (or (eq type 'verse-block)
                  (eq type 'quote-block))
          (setq element outermost)))
      (setq content (buffer-substring-no-properties
                     (org-element-property :contents-begin element)
                     (org-element-property :contents-end element))))
     (t
      (error "The element at point couldn't be copied.")))
    (kill-new content)))

  (defun grym/link-on-this-line ()
    "Return the contents of org-style link on this line"
    (interactive)
    (org-next-link)
    (kill-new
     (plist-get
      (cadr
       (org-element-link-parser))
      :raw-link)))

;;(org-defkey org-mouse-map [mouse-2] 'grym/link-on-this-line)

(defun acdw/copy-region-plain (start end)
  "Copy a region to clipboard.
   Remove all Org formatting, and strip leading and trailing whitespace."
  (interactive "r")
  (let ((s (string-trim
            (buffer-substring-no-properties
             start
             end))))
    (with-temp-buffer
      (insert s)
      (let ((sentence-end-double-space nil))
        (unfill-region
         (point-min)
         (point-max)))
      (copy-region-as-kill
       (point-min)
       (point-max)))))

(setq org-fontify-done-headline t)
(custom-set-faces
 '(org-done ((t (:foreground "DeepSkyBlue"
                 :weight normal
                 :strike-through t))))
 '(org-headline-done
            ((((class color) (min-colors 16) (background dark))
               (:foreground "LightSalmon" :strike-through t)))))

(setq org-agenda-files (list my/org-path-name (concat my/org-path-name (plist-get my/secrets :work-jira-working-dir)(plist-get my/secrets :work-org-jira-file))))
(setq org-refile-targets '((org-agenda-files :maxlevel . 5)))
(setq org-refile-allow-creating-parent-nodes 'confirm)

(setq org-agenda-sorting-strategy '((agenda habit-down time-up priority-down category-keep)
 (todo priority-down category-keep)
 (tags todo-state-down priority-down category-keep)
 (search category-keep)))

(defun grym/go-to-first-heading ()
  "Go to the first org heading in a file. Intended to be run as a
hook."
  (interactive)
  (unless (derived-mode-p 'org-mode)
    (user-error "This function is intended to be used in org-mode buffers."))
  ;; h/t irc user rdrg109 for improvements here
  (let ((first-match
         (save-excursion
           (beginning-of-buffer)
           (re-search-forward "^\*+" nil :noerror))))
    ;; Move the cursor if and only if a match is found.
    (if first-match
        ;; if there is a first header, go there
      (progn
      (goto-char first-match)
      (back-to-indentation))
      ;; otherwise, go to the beginning unconditionally
      (beginning-of-buffer
      ))))
(add-hook 'org-mode-hook 'grym/go-to-first-heading)

(defun grym/org-collapse-todo ()
  (interactive)
  (org-map-entries 'outline-hide-subtree "TODO=\"DONE\"" 'tree)
  (org-map-entries 'outline-hide-subtree "TODO=\"ABANDONED\"" 'tree) )

  ;; org-archive-subtree-hierarchical.el
  ;;
  ;; version 0.2
  ;; modified from https://lists.gnu.org/archive/html/emacs-orgmode/2014-08/msg00109.html
  ;; modified from https://stackoverflow.com/a/35475878/259187

  ;; In orgmode
  ;; * A
  ;; ** AA
  ;; *** AAA
  ;; ** AB
  ;; *** ABA
  ;; Archiving AA will remove the subtree from the original file and create
  ;; it like that in archive target:

  ;; * AA
  ;; ** AAA

  ;; And this give you
  ;; * A
  ;; ** AA
  ;; *** AAA
  ;;
  ;; Install file to your include path and include in your init file with:
  ;;
  ;;  (require 'org-archive-subtree-hierarchical)
  ;;  (setq org-archive-default-command 'org-archive-subtree-hierarchical)
  ;;
  (provide 'org-archive-subtree-hierarchical)
  (require 'org-archive)

  (defun org-archive-subtree-hierarchical--line-content-as-string ()
    "Returns the content of the current line as a string"
    (save-excursion
      (beginning-of-line)
      (buffer-substring-no-properties
       (line-beginning-position) (line-end-position))))

  (defun org-archive-subtree-hierarchical--org-child-list ()
    "This function returns all children of a heading as a list. "
    (interactive)
    (save-excursion
      ;; this only works with org-version > 8.0, since in previous
      ;; org-mode versions the function (org-outline-level) returns
      ;; gargabe when the point is not on a heading.
      (if (= (org-outline-level) 0)
          (outline-next-visible-heading 1)
        (org-goto-first-child))
      (let ((child-list (list (org-archive-subtree-hierarchical--line-content-as-string))))
        (while (org-goto-sibling)
          (setq child-list (cons (org-archive-subtree-hierarchical--line-content-as-string) child-list)))
        child-list)))

  (defun org-archive-subtree-hierarchical--org-struct-subtree ()
    "This function returns the tree structure in which a subtree
  belongs as a list."
    (interactive)
    (let ((archive-tree nil))
      (save-excursion
        (while (org-up-heading-safe)
          (let ((heading
                 (buffer-substring-no-properties
                  (line-beginning-position) (line-end-position))))
            (if (eq archive-tree nil)
                (setq archive-tree (list heading))
              (setq archive-tree (cons heading archive-tree))))))
      archive-tree))

  (defun org-archive-subtree-hierarchical ()
    "This function archives a subtree hierarchical"
    (interactive)
    (let ((org-tree (org-archive-subtree-hierarchical--org-struct-subtree))
          (this-buffer (current-buffer))
          (file (abbreviate-file-name
                 (or (buffer-file-name (buffer-base-buffer))
                     (error "No file associated to buffer")))))
      (save-excursion
        (setq location org-archive-location
              afile (car (org-archive--compute-location
                                     (or (org-entry-get nil "ARCHIVE" 'inherit) location)))
              ;; heading (org-extract-archive-heading location)
              infile-p (equal file (abbreviate-file-name (or afile ""))))
        (unless afile
          (error "Invalid `org-archive-location'"))
        (if (> (length afile) 0)
            (setq newfile-p (not (file-exists-p afile))
                  visiting (find-buffer-visiting afile)
                  buffer (or visiting (find-file-noselect afile)))
          (setq buffer (current-buffer)))
        (unless buffer
          (error "Cannot access file \"%s\"" afile))
        (org-cut-subtree)
        (set-buffer buffer)
        (org-mode)
        (goto-char (point-min))
        (while (not (equal org-tree nil))
          (let ((child-list (org-archive-subtree-hierarchical--org-child-list)))
            (if (member (car org-tree) child-list)
                (progn
                  (search-forward (car org-tree) nil t)
                  (setq org-tree (cdr org-tree)))
              (progn
                (goto-char (point-max))
                (newline)
                (org-insert-struct org-tree)
                (setq org-tree nil)))))
        (newline)
        (org-yank)
        (when (not (eq this-buffer buffer))
          (save-buffer))
        (message "Subtree archived %s"
                 (concat "in file: " (abbreviate-file-name afile))))))

  (defun org-insert-struct (struct)
    "TODO"
    (interactive)
    (when struct
      (insert (car struct))
      (newline)
      (org-insert-struct (cdr struct))))

  (defun org-archive-subtree ()
    (org-archive-subtree-hierarchical)
    )

(require 'org-archive-subtree-hierarchical)
(setq org-archive-default-command 'org-archive-subtree-hierarchical)

(defun grym/insert-org-file-dwim ()
  "Insert file contents of the current org-mode file path at point."
  (interactive)
  (let ((fname-to-insert (thing-at-point 'filename)))
    (when (and (file-exists-p fname-to-insert)
               (equal (file-name-extension
                       fname-to-insert)
                      "org"))
      (save-excursion
        (org-end-of-line)
        (org-newline-and-indent)
        (insert-file fname-to-insert)
        (message
         "Inserting %s"
         (file-name-base
          fname-to-insert)))
      (org-beginning-of-line)
      (kill-line 1)
      (org-demote-subtree))))

(use-package yasnippet)
(setq yas-snippet-dirs
      (list (concat (file-name-as-directory user-emacs-directory)
                    (file-name-as-directory "emacs-nougat")
                    "snippets")))

(yas-global-mode 1) ;; or M-x yas-reload-all if you've started YASnippet already.
(setq yas-triggers-in-field t) ;; allow nested snippets
(setq yas-indent-line 'fixed)
(add-hook 'org-mode-hook '(lambda () (set (make-local-variable 'yas-indent-line) 'fixed)))

(setq vc-follow-symlinks t)

    (add-hook 'before-save-hook 'magit-wip-commit-initial-backup)
      (use-package magit
       :straight (magit :type git
                     :host github
                     :repo "magit/magit")
       :bind(("C-x g" . magit-status)
           ;;https://emacs.stackexchange.com/a/54542
             (:map magit-file-section-map
                   ("RET" . magit-diff-visit-file-other-window)
                   :map magit-hunk-section-map
           ("RET" . magit-diff-visit-file-other-window)))
       :init (setq magit-status-margin '(nil "%d %b %y %H:%M" magit-log-margin-width t 24))
       :config
       (require 'magit-extras)
       (setq magit-log-section-commit-count 25)
       (magit-wip-mode 1)
)

(use-package forge
  :ensure t
  :after magit
  :config (setq forge-add-pullreq-refspec 'ask forge-pull-notifications t
                   forge-topic-list-limit '(60 . 0))
  (add-to-list 'forge-alist `(,(plist-get my/secrets :work-gitlab-alias) ,(plist-get my/secrets :work-gitlab-api-url) ,(plist-get my/secrets :work-gitlab-alias) forge-gitlab-repository))
  )

(use-package code-review
 :straight ( code-review :type git :host nil :repo "https://github.com/phelrine/code-review/" :branch "fix/closql-update")
 :hook (code-review-mode . emojify-mode)
 :config
 (setq code-review-fill-column 80)
 (setq code-review-auth-login-marker 'code-review)
 (setq code-review-gitlab-host (plist-get my/secrets :work-gitlab-codereview-url))
 (setq code-review-gitlab-graphql-host (plist-get my/secrets :work-gitlab-codereview-url))
 (define-key forge-topic-mode-map (kbd "C-c r") 'code-review-forge-pr-at-point)
 (define-key code-review-mode-map (kbd "C-c C-n") 'code-review-comment-jump-next)
 (define-key code-review-mode-map (kbd "C-c C-p") 'code-review-comment-jump-previous)
 )

;;  (use-package abridge-diff
;;   :straight ( abridge-diff :type git :host nil :repo "https://github.com/jdtsmith/abridge-diff")
;; :after magit
;;   :init
;;   (abridge-diff-mode 1)
;;   )

(use-package git-timemachine
 :straight (git-timemachine :type git :host nil :repo "https://github.com/emacsmirror/git-timemachine")
 :config
 )

 (use-package git-link
  :straight (git-link :type git :host nil :repo "https://github.com/sshaw/git-link")
  :config
(add-to-list 'git-link-remote-alist
    `(,(plist-get my/secrets :work-gitlab-alias) git-link-gitlab))
  (add-to-list 'git-link-commit-remote-alist
    `(,(plist-get my/secrets :work-gitlab-alias) git-link-commit-gitlab)))

(use-package difftastic
  :after magit
  :demand t
  :bind (:map magit-blame-read-only-mode-map
         ("D" . difftastic-magit-show)
         ("S" . difftastic-magit-show))
  :config
  (eval-after-load 'magit-diff
    '(transient-append-suffix 'magit-diff '(-1 -1)
       [("D" "Difftastic diff (dwim)" difftastic-magit-diff)
        ("S" "Difftastic show" difftastic-magit-show)])))

(use-package pandoc-mode)

(add-hook 'markdown-mode-hook 'pandoc-mode)
(add-hook 'org-mode-hook 'pandoc-mode)

(when (version<= emacs-version "29.1")
  (use-package tree-sitter
    :straight (tree-sitter :type git
                           :host github
                           :repo "ubolonton/emacs-tree-sitter"
                           :files ("lisp/*.el"))
    :config (add-to-list 'tree-sitter-major-mode-language-alist '(python-mode . python))
    :hook ((python-mode ) . tree-sitter-hl-mode))

  (use-package tree-sitter-langs
    :straight (tree-sitter-langs :type git
                                 :host github
                                 :repo "ubolonton/emacs-tree-sitter"
                                 :files ("langs/*.el" "langs/queries"))
    :after tree-sitter)
)
(add-to-list 'auto-mode-alist '("\\.yml\\'" . yaml-ts-mode))
(add-to-list 'auto-mode-alist '("\\.yaml\\'" . yaml-ts-mode))
(add-to-list 'auto-mode-alist '("/Dockerfile[^/]*\\'" . dockerfile-ts-mode))

(when (version<= "29.1" emacs-version)
    (use-package treesit-auto
      :straight (treesit-auto :type git :host nil :repo "https://github.com/renzmann/treesit-auto")
      :config
      (setq treesit-auto-install 'prompt)
      (global-treesit-auto-mode)
      )

    (use-package
      combobulate
      :straight (combobulate
                 :type git
                 :host nil
                 :nonrecursive t
                 :repo "https://github.com/mickeynp/combobulate")
      :preface
        (dolist (mapping '((python-mode . python-ts-mode)
                   ;; (css-mode . css-ts-mode)
                   ;; (typescript-mode . tsx-ts-mode)
                   ;; (js-mode . js-ts-mode)
                   ;; (css-mode . css-ts-mode)
                    ;; (markdown-mode . markdown-ts-mode)
                    (json-mode . json-ts-mode)
                   (yaml-mode . yaml-ts-mode)))
          (add-to-list 'major-mode-remap-alist mapping))
      :hook ((python-ts-mode . combobulate-mode)
             ;; (js-ts-mode . combobulate-mode)
             ;; (css-ts-mode . combobulate-mode)
             ;; (markdown-ts-mode . combobulate-mode)
             ;; (typescript-ts-mode . combobulate-mode)
             ;; (tsx-ts-mode . combobulate-mode)
             (yaml-ts-mode . combobulate-mode)
             (json-ts-mode . combobulate-mode)))
    )

(use-package eglot
 :straight (eglot :type git :host github :repo "joaotavora/eglot")
 :after yasnippet
 :init (add-to-list 'eglot-server-programs `(python-ts-mode . ("pylsp")))
       ;; (add-to-list 'eglot-server-programs `(yaml-ts-mode . ("yaml-language-server --stdio")))
       ;; (add-to-list 'eglot-server-programs `(toml-ts-mode . ("taplo lsp stdio")))
 :hook ((python-mode . eglot-ensure)
        (python-ts-mode . eglot-ensure)
        ;; (yaml-ts-mode . eglot-ensure)
        ;; (toml-ts-mode . eglot-ensure)
        )
 :config
 (setq eglot-ignored-server-capabilities '(:documentOnTypeFormattingProvider))
 )

(use-package eldoc-box)

(use-package eglot-booster
 :straight ( eglot-booster :type git :host nil :repo "https://github.com/jdtsmith/eglot-booster")
 :after eglot
 :init (setq eglot-booster-io-only t)
 :config (eglot-booster-mode)
 )

(use-package sqlite-mode-extras
 :straight (sqlite-mode-extras :type git :host nil :repo "https://github.com/xenodium/sqlite-mode-extras")
 :hook ((sqlite-mode . sqlite-extras-minor-mode))
 :config
 )

(use-package envrc
 :straight (envrc :type git :host github :repo "purcell/envrc")
 :config (envrc-global-mode)
 )

(when (eq system-type 'gnu/linux)
  (setq grym/transient-key "<XF86Launch8>" ))
(when (eq system-type 'darwin)
  (setq grym/transient-key "<f9>" ))

  (require 'transient)
  (require 'indent-bars)
    (transient-define-prefix grym/utility-transient ()
      "þe dumping ground"
      [
       ["Open"
        ("od" "dired indirect" grym/dired-open-other-window)
        ("of" "find file at point" ffap)
        ;; ("V" "projectile vc here" projectile-vc)
        ;; ("d" "dired" dired)
        ]
       ["Search"
        ("A"   "rg in project" rg-project)
        ("R"   "consult ripgrep" consult-ripgrep)
        ;; ("o"   "Occur in project" projectile-multi-occur)
        ]
       ["Buffers"
          ("0" "kill buffer and window" kill-buffer-and-window)
          ("1" "close other window" grym/close-next-pane)
          ("2" "kill other buffer and window" grym/close-and-kill-next-pane)
          ("W" "whitespace" whitespace-mode)
          ("a" "copy region plain" acdw/copy-region-plain)
          ("be" "eval and replace" crux-eval-and-replace)
          ("bI" "indent bars" indent-bars-mode)
          ("bj" "zoom" zoom-window-zoom)
          ("bl" "clean empty lines" xah-clean-empty-lines)
          ("bn" "toggle line numbers" display-line-numbers-mode)
          ("bs" "new scratch text buffer" grym/new-scratch-text-buffer)
          ("bu" "insert url contents at point" grym/insert-url)
          ("bw" "paste marked region or buffer" webpaste-paste-buffer-or-region)
          ("c" "insert character" insert-char)
          ("d" "define word at point" dictionary-lookup-definition)
          ("g" "clickable links" goto-address-mode)
          ("t" "transcribe toggle" whisper-run)
          ;; ("i" "imenu list" imenu-list-smart-toggle)
          ("q" "bury" bury-buffer)
          ("r" "view+olivetti" grym/toggle-reader-mode)
          ("x" "+/- ro" read-only-mode)
          ;; ("R" "rectangle" cc/rectangle-tmenu )
          ;; ("m" "mark ring" consult-mark)
          ;; ("o" "olivetti" olivetti-mode)
          ;; ("t" "column marker" display-fill-column-indicator-mode)
      ]
       ["Projectile"
          ("C"   "Rebuild cache" projectile-invalidate-cache)
          ("X"   "Cleanup" projectile-cleanup-known-projects)
          ("f" "find file" consult-projectile-find-file)
          ("k"   "Kill project" projectile-kill-buffers)
          ("v" "projectile vc"  grym/switch-projectile-vc)
        ]
       ["Window"
            ("w" "window movement" grym/window-transient)
        ]
       ["Org" :if-mode org-mode
         ("Oc"  "collapse todo headings" grym/org-collapse-todo)
         ("Or" "restart org" org-mode-restart)
        ]
       ["Dired" :if-mode dired-mode
         ("d" "share with dragon" grym/dwim-shell-command-dragon-marked-files)
         ("f" "view with feh" grym/dwim-shell-command-feh-marked-files)
         ;; ("Dg" "git log" dired-git-log-mode)
         ("u" "upload to oxo" grym/dwim-shell-command-oxo-marked-files)
       ]
      ["Programming" :if-derived prog-mode
       ("e" "eglot transient" grym/eglot-transient)
       ("l" "git file log" magit-log-buffer-file)
       ("p" "precommit" grym/spam-precommit-in-project)
       ;; ("s" "toggle sidebars" +sidebar-toggle)
       ]
      ["Meta"
        ("<XF86Launch8>" "quit" transient-quit-one)]]
      )

  (transient-define-prefix grym/window-transient ()
    ["Window Movement"
     ["Move windows"
      ("I" "up" windmove-swap-states-up :transient t)
      ("J" "left" windmove-swap-states-left :transient t)
      ("K" "right" windmove-swap-states-right :transient t)
      ("L" "down" windmove-swap-states-down :transient t)
      ]
     ["Modify windows"
        ("0" "delete this window" delete-window)
        ("1" "delete other windows" delete-other-windows)
        ("2" "split below" split-window-below)
        ("3" "split right" split-window-right)
        ("C" "clone" clone-indirect-buffer)
        ("c" "clone indirect" clone-indirect-buffer-other-window)
        ("j" "zoom" zoom-window-zoom)
        ("w" "swap window" ace-swap-window)
      ]
     ["winner-mode"
      ("u" "undo"  winner-undo :transient t)
      ("U" "redo"  winner-redo :transient t)]
     ["Meta"
        ("<XF86Launch8>" "quit" transient-quit-one)]]
)

  (global-set-key (kbd grym/transient-key) 'grym/utility-transient)

(require 'transient)
(transient-define-prefix grym/eglot-transient ()
  ["Eglot"
   ["Formatting"
    ("i" "indent-bars" indent-bars-mode)
    ("r" "rename at point" eglot-rename)
    ;; ("h" "show menu" eglot-transient-menu) ;; heh
    ]
   ["Eldoc"
    "e" "doc hover at point" eldoc-box-hover-at-point-mode
    ]
   ["Unit test" :if-mode python-ts-mode
    ("c" "show coverage" python-coverage-overlay-mode)
    ("p" "pytest" python-pytest-dispatch)
    ]
   ["Meta"
        ("<XF86Launch8>" "quit" transient-quit-one)]
   ]
  )