(print "This code will not be run!")

(print "This code is run in my config!")

;;; init.el — Emacs init file -**- lexical-binding: t -**-

;; IMPORTANT: lexical-binding must be on the first line with proper formatting
;; This is essential for compile-angel and native compilation to work correctly.
;; Errors like "Invalid read syntax: ")" or "file has no lexical-binding directive"
;; are usually related to missing or incorrect lexical-binding settings.

;; Fix for compile-angel related issues - pre-define variables that might be referenced
(defvar old-value nil)
(defvar original-noninteractive-value nil)
(setq comp-speed 2)

;; Configure straight.el to use GitHub mirrors for Savannah repositories
(setq straight-vc-git-default-clone-url
      '(("git\\\\.savannah\\\\.gnu\\\\.org"
         .
         "<https://github.com/emacs-straight/%s>")))

;; Override recipes for specific packages
(setq straight-recipe-overrides
      '((nil
         .
         ((nongnu-elpa
           :type git
           :host github
           :repo "emacsmirror/nongnu<sub>elpa</sub>")
          (ws-butler
           :type git
           :host github
           :repo "emacsmirror/ws-butler")
          (org
           :type git
           :host github
           :repo "emacs-straight/org-mode"
           :local-repo "org")))))

;; Packages setup to prepare literate-elisp
(defvar bootstrap-version)
(let ((bootstrap-file
       (expand-file-name "straight/repos/straight.el/bootstrap.el"
                         (or (bound-and-true-p straight-base-dir)
                             user-emacs-directory)))
      (bootstrap-version 7))
  (unless (file-exists-p bootstrap-file)
    (with-current-buffer
        (url-retrieve-synchronously
         "<https://raw.githubusercontent.com/radian-software/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)
(require 'use-package)
(setq use-package-compute-statistics t)

(use-package general)
(use-package org)

(use-package
 literate-elisp
 :demand t
 :straight
 '(literate-elisp
   :type git
   :host github
   :repo "jingtaozf/literate-elisp")
 :config
 ;; ;; To make \`elisp-refs' work with \`literate-elisp', we need to add an advice to \`elisp-refs&#x2013;read-all-buffer-forms'.
 (eval-after-load "elisp-refs"
   '(advice-add
     'elisp-refs&#x2013;read-all-buffer-forms
     :around #'literate-elisp-refs&#x2013;read-all-buffer-forms))
 ;; To make \`elisp-refs' work with \`literate-elisp', we need to add an advice to \`elisp-refs&#x2013;loaded-paths'.
 (eval-after-load "elisp-refs"
   '(advice-add
     'elisp-refs&#x2013;loaded-paths
     :filter-return #'literate-elisp-refs&#x2013;loaded-paths))
 ;; To make \`helpful' work with \`literate-elisp', we need to add an advice to \`helpful&#x2013;find-by-macroexpanding'.
 (eval-after-load 'helpful
   '(advice-add
     'helpful&#x2013;find-by-macroexpanding
     :around #'literate-elisp-helpful&#x2013;find-by-macroexpanding)))

; Start literate load
(literate-elisp-load
 (expand-file-name "init.org" user-emacs-directory))

(setq custom-file (concat user-emacs-directory "custom.el"))
(if (not (file-exists-p custom-file))
    (f-touch custom-file))
(load custom-file)

(when (eq system-type 'darwin)
  (setq mac-left-command-modifier 'super)
  (setq mac-right-command-modifier 'meta)

  (add-to-list 'default-frame-alist '(ns-transparent-titlebar . t))

  (add-to-list
   'default-frame-alist
   '(ns-appearance . light)) ;; or dark - depending on your theme

  (use-package
   osx-plist
   :straight
   '(osx-plist :type git :host github :repo "gonewest818/osx-plist")))

(add-to-list 'default-frame-alist '(width . 130)) ; Set width to 80 columns
(add-to-list 'default-frame-alist '(height . 40)) ; Set height to 24 lines

(defun center-frame ()
  "Center the frame on the screen, respecting the size set in default-frame-alist."
  (interactive)
  (let* ((desired-width
          (or (cdr (assq 'width default-frame-alist)) 80))
         (desired-height
          (or (cdr (assq 'height default-frame-alist)) 24))
         (screen-width (x-display-pixel-width))
         (screen-height (x-display-pixel-height))
         (char-width (frame-char-width))
         (char-height (frame-char-height))
         (frame-pixel-width (* desired-width char-width))
         (frame-pixel-height (* desired-height char-height))
         (left (max 0 (/ (- screen-width frame-pixel-width) 2)))
         (top (max 0 (/ (- screen-height frame-pixel-height) 2))))
    (message
     "Screen size: %dx%d, Desired frame size: %dx%d, Position: (%d, %d)"
     screen-width screen-height desired-width desired-height left top)
    (set-frame-size (selected-frame) desired-width desired-height)
    (set-frame-position (selected-frame) left top)
    (message "Frame set to %dx%d at (%d, %d)"
             (frame-width)
             (frame-height)
             (frame-parameter nil 'left)
             (frame-parameter nil 'top))))

;; Call this function when Emacs starts
(add-hook 'window-setup-hook #'center-frame)

(defun toggle-fullscreen-or-maximized ()
  "Toggle between fullscreen on macOS and maximized on Linux."
  (interactive)
  (if (eq system-type 'darwin) ; macOS
      (set-frame-parameter
       nil 'fullscreen
       (if (frame-parameter nil 'fullscreen)
           nil
         'fullboth))
    (set-frame-parameter
     nil 'fullscreen
     (if (eq (frame-parameter nil 'fullscreen) 'maximized)
         nil
       'maximized)))) ; Linux

(add-hook 'window-setup-hook #'toggle-fullscreen-or-maximized)

(when (eq system-type 'darwin)
  (use-package
   highlight2clipboard
   :straight
   '(highlight2clipboard
     :type git
     :host github
     :repo "Lindydancer/highlight2clipboard")))

(setq default-directory "~/")
(use-package package)
(use-package
 exec-path-from-shell
 :demand t
 :init
 (setq exec-path-from-shell-variables
       '("PATH" "MANPATH" "OPENAI_API_KEY"))
 (setq exec-path-from-shell-arguments '("-l" "-i"))
 :config
 (when (memq window-system '(mac ns x))
   (exec-path-from-shell-initialize)))

(use-package
 vterm
 :init
 (setq vterm-copy-exclude-prompt nil)
 (setq vterm-always-compile-module t)
 (setq vterm-timer-delay 0.01)
 (setq vterm-tramp-shells
       '("/usr/bin/bash" "/bin/bash" "/bin/zsh" "docker" "/bin/sh"))
 :config
 (define-key
  vterm-mode-map (kbd "M-k")
  (lambda ()
    (interactive)
    (kill-this-buffer nil)))
 (define-key vterm-mode-map (kbd "M-0") nil)
 (define-key vterm-mode-map (kbd "M-1") nil)
 (define-key vterm-mode-map (kbd "M-2") nil)
 (define-key vterm-mode-map (kbd "M-3") nil)
 (define-key vterm-mode-map (kbd "M-T") nil)
 (define-key vterm-mode-map (kbd "M-R") nil)
 (define-key vterm-mode-map (kbd "M-G") nil)
 (define-key vterm-mode-map (kbd "M-:") nil)
 (define-key vterm-mode-map (kbd "M-s") 'nil)

 (defun kill-buffer-and-its-windows (buffer)
   "Kill BUFFER and delete its windows.  Default is `current-buffer'.
BUFFER may be either a buffer or its name (a string)."
   (interactive (list
                 (read-buffer "Kill buffer: "
                              (current-buffer)
                              'existing)))
   (setq buffer (get-buffer buffer))
   (if (buffer-live-p buffer) ; Kill live buffer only.
       (let
           ((wins (get-buffer-window-list buffer nil t))) ; On all frames.
         (when (and (buffer-modified-p buffer)
                    (fboundp '1on1-flash-ding-minibuffer-frame))
           (1on1-flash-ding-minibuffer-frame t)) ; Defined in `oneonone.el'.
         (when
             (kill-buffer buffer) ; Only delete windows if buffer killed.
           (dolist (win wins) ; (User might keep buffer if modified.)
             (when (window-live-p win)
               ;; Ignore error, in particular,
               ;; "Attempt to delete the sole visible or iconified frame".
               (condition-case nil
                   (delete-window win)
                 (error nil))))))
     (when (interactive-p)
       (error
        "Cannot kill buffer.  Not a live buffer: `%s'" buffer))))

 (setq vterm-kill-buffer-on-exit t)
 (define-key
  vterm-mode-map (kbd "M-k")
  (lambda ()
    (interactive)
    (kill-buffer-and-its-windows (current-buffer))))
 ;; Add goto-address-mode to vterm-mode-hook for clickable links
 (add-hook 'vterm-mode-hook 'goto-address-mode))

(use-package
 vterm-toggle
 :after vterm
 :demand t
 :bind
 (:map
  vterm-mode-map
  ("<escape>" . vterm-send-C-c)
  ("M-T" . vterm-toggle)
  ("M-R" . vterm-toggle-cd)
  ("M-n" . vterm-toggle-forward)
  ("M-p" . vterm-toggle-backward))
 (:map global-map ("M-T" . vterm-toggle) ("M-R" . vterm-toggle-cd))
 :config
 (define-key vterm-mode-map (kbd "M-T") 'vterm-toggle)
 (define-key vterm-mode-map (kbd "M-R") 'vterm-toggle-cd)

 (setq vterm-toggle-scope 'dedicated)
 (setq vterm-toggle-project-root t)
 (setq vterm-toggle-cd-auto-create-buffer nil)
 (setq vterm-toggle-reset-window-configration-after-exit t)
 (setq vterm-toggle-fullscreen-p nil)
 (setq vterm-toggle-hide-method 'bury-all-vterm-buffer)
 (add-to-list
  'display-buffer-alist
  '((lambda (buffer-or-name _)
      (let ((buffer (get-buffer buffer-or-name)))
        (with-current-buffer buffer
          (or (equal major-mode 'vterm-mode)
              (string-prefix-p
               vterm-buffer-name (buffer-name buffer))))))
    (display-buffer-reuse-window display-buffer-in-direction)
    (direction . bottom)
    (dedicated . t)
    (reusable-frames . visible)
    (window-height . 0.3)
    (window-width . 0.3)))

 ;; Function to get project root without prompting
 (defun my/get-project-root ()
   (or (when (fboundp 'project-root)
         (when-let* ((project (project-current nil)))
           (project-root project)))
       (when (fboundp 'projectile-project-root)
         (projectile-project-root))
       default-directory))

 ;; Override vterm-toggle--new
 (defun vterm-toggle--new (&optional buffer-name)
   "New vterm buffer."
   (let* ((buffer-name (or buffer-name vterm-buffer-name))
          (default-directory
           (if vterm-toggle-project-root
               (my/get-project-root)
             default-directory)))
     (if vterm-toggle-fullscreen-p
         (vterm buffer-name)
       (if (eq major-mode 'vterm-mode)
           (let ((display-buffer-alist nil))
             (vterm buffer-name))
         (vterm-other-window buffer-name)))))

 ;; Override vterm-toggle--project-root
 (defun vterm-toggle--project-root ()
   (my/get-project-root)))

(use-package
 zoom
 :init (setq zoom-size '(0.618 . 0.618))
 :config (zoom-mode))

(use-package
 visual-fill-column
 :init (setq visual-fill-column-center-text t)
 :config (visual-fill-column-mode 1))

(use-package
 centered-window
 :init (setq cwm-centered-window-width 180)
 :ensure t
 :config (centered-window-mode t)
 ; reload the fringe color after loading the theme
 (cwm-update-fringe-background))

;; EditorConfig Setup
(use-package editorconfig
  :ensure t
  :config
  (editorconfig-mode 1)
  ;; Set some custom variables that extend EditorConfig's capabilities
  (setq editorconfig-trim-whitespaces-mode 'whitespace-cleanup-mode)

  ;; Custom hook to apply visual settings after EditorConfig is loaded
  (defun my/apply-visual-settings (_props)
    "Apply visual settings after EditorConfig properties are loaded."
    (when (and (boundp 'max_line_length) max_line_length)
      (when (bound-and-true-p visual-fill-column-mode)
        (setq-local visual-fill-column-width max_line_length))))

  (add-hook 'editorconfig-after-apply-functions #'my/apply-visual-settings))

(global-set-key (kbd "M-k") (lambda () (interactive) (kill-this-buffer nil)))
(global-set-key (kbd "C-c C-b") 'compile)
(global-set-key (kbd "M-0") 'delete-window)
(global-set-key (kbd "M-1") 'delete-other-windows)
(global-set-key (kbd "M-2") 'split-window-below)
(global-set-key (kbd "M-3") 'split-window-right)

; Unbind reverse search because we'll use swiper
(global-unset-key (kbd "C-r"))
(global-set-key (kbd "M-u") 'upcase-dwim)
(global-set-key (kbd "M-l") 'downcase-dwim)
(global-set-key (kbd "C-.") 'xref-find-definitions-other-window)
(define-key global-map (kbd "RET") 'newline-and-indent)

; Disable Ctrl + mouse wheel up/down zooming in/out
(global-unset-key (kbd "C-<wheel-up>"))   ;; Unbind Ctrl + Wheel Up
(global-unset-key (kbd "C-<wheel-down>")) ;; Unbind Ctrl + Wheel Down

(setq font-lock-support-mode 'jit-lock-mode)
(setq jit-lock-defer-time nil)
(setq jit-lock-stealth-time 0)

(use-package
 ctrlf
 :config
 ;; Standard CTRLF configuration
 (define-key
  ctrlf-minibuffer-mode-map (kbd "C-r") 'ctrlf-backward-default)
 (setq ctrlf-default-search-style 'literal)

 ;; Add a hook to automatically cancel CTRLF search when leaving the minibuffer
 (defun my/auto-cancel-ctrlf ()
   "Automatically cancel CTRLF search when leaving the minibuffer."
   (when (and (bound-and-true-p ctrlf--active-p)
              (not (minibufferp))
              (not (eq (current-buffer) ctrlf--minibuffer)))
     (ctrlf-cancel)))

 (add-hook 'post-command-hook #'my/auto-cancel-ctrlf)

 ;; Enable CTRLF globally
 (ctrlf-mode t))

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

(use-package
 popper
 :bind
 (("C-`" . popper-toggle-latest)
  ("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 page-break-lines :config (global-page-break-lines-mode))

(use-package eldoc :hook (prog-mode . eldoc-mode))

(use-package which-key :config (which-key-mode 1))

(use-package
 ibuffer
 :config
 (global-set-key (kbd "C-x C-b") 'ibuffer)
 (define-key ibuffer-mode-map (kbd "M-o") nil))

;; Use ace-popup-menu for completions
(use-package
 ace-popup-menu
 :config
 (ace-popup-menu-mode 1)
 (setq ace-popup-menu-show-pane-header t))

(setq native-comp-async-report-warnings-errors nil)
;; Show the line number of the cursor in the mode bar at the bottom of each buffer
(setq line-number-mode t)

;; Disable the loud bell
(setq ring-bell-function
      (lambda ()
        (let ((orig-fg (face-foreground 'mode-line)))
          (set-face-foreground 'mode-line "#F2804F")
          (run-with-idle-timer 0.1 nil
                               (lambda (fg)
                                 (set-face-foreground 'mode-line fg))
                               orig-fg))))

;; Make sure all backup files only live in one place
(setq backup-directory-alist `((".*" . ,temporary-file-directory)))
(setq auto-save-file-name-transforms
      `((".*" ,temporary-file-directory t)))
;; Don't truncate lines
(setq truncate-lines t)

;; Don't show the scroll bar on the side of buffers
(scroll-bar-mode -1)
;; Don't show the toolbar, it just takes up space
(tool-bar-mode -1)

;; Show column number in the modeline
(setq column-number-mode t)
(setq blink-paren-function nil)
(setq inhibit-startup-screen t)

(use-package
 expand-region
 :config (global-set-key (kbd "M-J") 'er/expand-region))

(use-package
 expreg
 :config (global-set-key (kbd "M-J") 'expreg-expand))

(use-package
 direnv
 :init
 ; An attempt to run direnv earlier in the startup process
 (setq direnv--hooks
       '(find-file-hook
         post-command-hook before-hack-local-variables-hook))
 :config (direnv-mode 't))

(use-package fish-mode)

(define-key term-raw-map (kbd "M-o") 'next-multiframe-window)
(define-key term-raw-map (kbd "M-i") 'previous-multiframe-window)
(define-key global-map (kbd "M-o") 'next-multiframe-window)
(define-key global-map (kbd "M-i") 'previous-multiframe-window)

(setq aw-keys '(?a ?s ?d ?f ?g ?h ?j ?k ?l))

(use-package
  anzu
  :bind
  (([remap query-replace] . #'anzu-query-replace)
   ([remap query-replace-regexp] . #'anzu-query-replace-regexp))
  :config (global-anzu-mode +1))

(use-package lin :init (lin-global-mode t))
(use-package
 hl-line
 :config
 (add-hook
  'eshell-mode-hook (lambda () (setq-local global-hl-line-mode nil)))
 (add-hook
  'term-mode-hook (lambda () (setq-local global-hl-line-mode nil)))
 (add-hook
  'vterm-mode-hook (lambda () (setq-local global-hl-line-mode nil)))
 (global-hl-line-mode t))

;; Replace the text of selections
(pending-delete-mode t)

(use-package
 undo-fu
 :bind ("C-/" . undo-fu-only-undo) ("C-?" . undo-fu-only-redo))
(use-package undo-fu-session :config (global-undo-fu-session-mode))

(use-package
 vundo
 :init (setq vundo-glyph-alist vundo-unicode-symbols))

(global-so-long-mode t)

(use-package esup)

(use-package
 scratch
 :defer t
 :straight
 '(scratch
   :host nil
   :type git
   :repo "https://codeberg.org/emacs-weirdware/scratch.git")
 :config (scratch--create 'emacs-lisp-mode "*scratch*"))

(use-package
 multiple-cursors
 :config
 (global-set-key (kbd "C-M-j") 'mc/edit-lines)
 (global-set-key (kbd "C->") 'mc/mark-next-like-this)
 (global-set-key (kbd "C-<") 'mc/mark-previous-like-this)
 (global-set-key (kbd "C-c C-<") 'mc/mark-all-like-this)
 (global-set-key (kbd "C-M-=") 'mc/mark-all-symbols-like-this))

(use-package
 dashboard
 :straight
 '(emacs-dashboard
   :type git
   :host github
   :repo "emacs-dashboard/emacs-dashboard"
   :files ("banners" :defaults))
 :config (setq dashboard-projects-backend 'project-el)
 ;; Set the title
 (setq dashboard-banner-logo-title "Welcome to Emacs!")
 ;; Set the banner
 (setq dashboard-startup-banner 'official)
 (setq dashboard-items
       '((projects . 5)
         (recents . 5) (bookmarks . 5)
         ;; (agenda . 5)
         (registers . 5)))
 ;; ;; Value can be
 ;; ;; 'official which displays the official emacs logo
 ;; ;; 'logo which displays an alternative emacs logo
 ;; ;; 1, 2 or 3 which displays one of the text banners
 ;; ;; "path/to/your/image.png" which displays whatever image you would prefer

 ;; ;; Content is not centered by default. To center, set
 (setq dashboard-center-content t)
 (setq initial-buffer-choice (lambda () (get-buffer "*dashboard*")))

 ;; ;; To disable shortcut "jump" indicators for each section, set
 ;; (setq dashboard-show-shortcuts nil)

 ;; Override this function so that we can filter remote projects
 (defun dashboard-projects-backend-load-projects ()
   "Depending on `dashboard-projects-backend' load corresponding backend.
  Return function that returns a list of projects."
   (cl-remove-if
    (lambda (x) (string-search "/ssh" x))
    (cl-case
     dashboard-projects-backend
     (`projectile
      (require 'projectile)
      (dashboard-mute-apply (projectile-cleanup-known-projects))
      (projectile-load-known-projects))
     (`project-el
      (require 'project)
      (dashboard-mute-apply
       (dashboard-funcall-fboundp #'project-forget-zombie-projects))
      (project-known-project-roots))
     (t
      (display-warning
       '(dashboard) "Invalid value for `dashboard-projects-backend'"
       :error)))))

 (dashboard-setup-startup-hook))

(use-package
 breadcrumb
 :straight '(breadcrumb :type git :host github :repo "joaotavora/breadcrumb")
 :config (breadcrumb-mode t))

(setq show-paren-when-point-inside-paren 't)
(setq show-paren-style 'mixed)
(setq show-paren-context-when-offscreen 't)
(setq show-paren-context-when-offscreen t)
(setq show-paren-style 'mixed)


;; Treat ‘<’ and ‘>’ as if they were words, instead of ‘parenthesis’.
(modify-syntax-entry ?< "w<")
(modify-syntax-entry ?> "w>")

;; Show matching parens
(setq show-paren-delay 0)
(show-paren-mode t)

(use-package
  elec-pair
  :config ;; Disable electric pair in minibuffer
  (defun my/inhibit-electric-pair-mode (char)
    (or (minibufferp) (electric-pair-conservative-inhibit char)))
  (setq electric-pair-inhibit-predicate
        #'my/inhibit-electric-pair-mode)
(electric-pair-mode t)
;; The ‘<’ and ‘>’ are not ‘parenthesis’, so give them no compleition.
(setq electric-pair-inhibit-predicate
      (lambda (c)
        (or (member c '(?< ?> ?~))
            (electric-pair-default-inhibit c)))))

(use-package
 smartparens
 :hook (prog-mode . smartparens-mode)
 :hook (text-mode . smartparens-mode)
 :hook (org-mode . smartparens-mode)
 :hook (markdown-mode . smartparens-mode)
 :config
 ;; load default config
 (require 'smartparens-config))

(use-package
 rsync-mode
 :straight '(rsync-mode :type git :host github :repo "jsigman/rsync-mode"))

(use-package link-to-remote
  :straight (:host github :repo "jsigman/link-to-remote.el")
  :bind ("C-c l" . link-to-remote))

(use-package
 unison-sync-mode
 :straight
 (:host github :repo "jsigman/unison-sync-mode"))

(use-package wgrep :config (setq wgrep-auto-save-buffer t))
(use-package rg :config (rg-enable-menu) (setq rg-executable "rg"))

(use-package
 avy
 :config
 (global-set-key
  (kbd "C-'")
  'avy-goto-line) ;; Consistent with ivy-avy
 (global-set-key
  (kbd "C-M-'")
  'avy-goto-end-of-line) ;; Consistent with ivy-avy

 (setq avy-case-fold-search nil) ;; case sensitive makes selection easier
 (setq avy-indent-line-overlay t))

(use-package casual-avy
  :ensure t
  :bind ("M-'" . casual-avy-tmenu))

(use-package
 apheleia
 :config
 (setf (alist-get 'isort apheleia-formatters)
       '("isort" "--stdout" "-"))
 (setf (alist-get 'python-ts-mode apheleia-mode-alist) '(isort black))
 (add-to-list
  'apheleia-formatters
  '(prettier-toml
    npx "prettier" "--stdin-filepath" filepath "--parser=toml"))
 (add-to-list 'apheleia-mode-alist '(conf-toml-mode . prettier-toml))
 (defun apheleia-indent-region+ (orig scratch callback)
   (with-current-buffer scratch
     (setq-local indent-line-function
                 (buffer-local-value 'indent-line-function orig))
     (indent-region (point-min) (point-max))
     (funcall callback scratch)))

 (push '(jsonian-mode . prettier-json) apheleia-mode-alist)
 (setq apheleia-mode-alist
       (assq-delete-all 'emacs-lisp-mode apheleia-mode-alist))

 ;; Add shfmt for direnv-envrc-mode
 (add-to-list 'apheleia-mode-alist '(direnv-envrc-mode . shfmt))

 (apheleia-global-mode t))

(use-package
 elisp-autofmt
 :commands (elisp-autofmt-mode elisp-autofmt-buffer)
 :hook (emacs-lisp-mode . elisp-autofmt-mode)
 :init (setq elisp-autofmt-check-elisp-autofmt-exists 'always)
 :straight
 '(elisp-autofmt
   ;; :files (:defaults "elisp-autofmt")
   :host nil
   :type git
   :repo "https://codeberg.org/ideasman42/emacs-elisp-autofmt.git")
 :config
 (setq elisp-autofmt-on-save-p
       ; return t unless in "~/.emacs.d/straight"
       (lambda ()
         (not
          (string-match-p
           (concat
            "^"
            (regexp-quote
             (expand-file-name "straight" user-emacs-directory)))
           (buffer-file-name))))))

(use-package
 package-lint
 :ensure t
 :commands (package-lint-current-buffer)
 :config
 (defun my/package-lint-this-file ()
   "Run package-lint on the current buffer and show output."
   (interactive)
   (let ((output-buffer (get-buffer-create "*Package-Lint*")))
     (with-current-buffer output-buffer
       (erase-buffer)
       (insert
        "Running package-lint on "
        (buffer-name (current-buffer))
        "...\n\n"))
     ;; Current version of package-lint doesn't take a buffer argument
     (package-lint-current-buffer)
     (display-buffer output-buffer)))

 :bind (:map emacs-lisp-mode-map ("C-c C-x l" . my/package-lint-this-file)))

(use-package ws-butler
:hook (prog-mode . ws-butler-mode)
:hook (org-mode . ws-butler-mode))

(use-package
 highlight-indent-guides
 :hook ((python-mode) . highlight-indent-guides-mode))

(use-package
 indent-bars
 :straight (indent-bars :type git :host github :repo "jdtsmith/indent-bars")
 :config
 (require 'indent-bars-ts) ; not needed with straight
 :custom
 (indent-bars-treesit-support t)
 (indent-bars-treesit-ignore-blank-lines-types '("module"))
 ;; Add other languages as needed
 (indent-bars-treesit-scope
  '((python
     function_definition
     class_definition
     for_statement
     if_statement
     with_statement
     while_statement)))
 ;; Note: wrap may not be needed if no-descend-list is enough
 ;;(indent-bars-treesit-wrap '((python argument_list parameters ; for python, as an example
 ;;				      list list_comprehension
 ;;				      dictionary dictionary_comprehension
 ;;				      parenthesized_expression subscript)))
 :hook ((python-mode) . indent-bars-mode))

(setq
 dired-omit-files
 "^\\.?#\\|^\\.\\(DS_Store\\|localized\\|AppleDouble\\)$\\|^\\.\\.$")
(setq dired-kill-when-opening-new-dired-buffer t)
(when (eq system-type 'darwin) (setq
 insert-directory-program "gls"
 dired-use-ls-dired t))
(setq dired-listing-switches "-al --group-directories-first")

;; wdired settings
(use-package
 wdired
 :config
 (setq wdired-allow-to-change-permissions t)
 (define-key dired-mode-map (kbd "e") 'wdired-change-to-wdired-mode)
 (define-key dired-mode-map (kbd "M-G") nil))

(use-package
 project
 :demand t
 :straight (:type built-in)
 :bind-keymap ("C-c p" . project-prefix-map)
 :config (setq project-vc-include-untracked t)
 ;; Custom project detection function
 (defun my/project-try-local (dir)
   "Determine if DIR is a project by finding the nearest .git directory.
This helps with correctly identifying Git submodules as separate projects."
   (let ((root (locate-dominating-file dir ".git")))
     (when root
       (cons 'transient (expand-file-name root)))))

 ;; TODO - This function not working yet for monorepo folders
 ;; Add our custom function to the beginning of project-find-functions
 ;; (add-hook 'project-find-functions #'my/project-try-local)

 ;; Set up project-vc-ignores
 (setq project-vc-ignores
       '("venv/"
         "typings/"
         "node_modules/"
         ".mypy_cache/"
         ".pytest_cache/"
         ".cache/"
         ".dvc/cache/"
         ".dvc/tmp/"
         ".jekyll-cache/"
         "!*.org"
         "!/notes/"))

 ;; Function to add ignored directories to project-vc-ignores
 (defun my/add-project-ignore (dir)
   "Add DIR to the list of ignored directories in project-vc-ignores."
   (add-to-list 'project-vc-ignores dir))

 ;; Add additional directories to project-vc-ignores
 (dolist (dir
          '("venv"
            "data"
            "typings"
            "node_modules"
            ".mypy_cache"
            ".pytest_cache"
            ".cache"
            ".dvc/cache"
            ".dvc/tmp"
            ".jekyll-cache"))
   (my/add-project-ignore dir))

 ;; Disable automatic project remembering
 (advice-add 'project-remember-project :override #'ignore)

 ;; Prevent automatic removal of projects not found
 (advice-add 'project--remove-from-project-list :override #'ignore))

(use-package
 projectile
 :init (setq projectile-git-submodule-command nil)
 ;; always ignore the home directory and root
 (setq projectile-ignored-projects
       `("/" "~/" ,(expand-file-name "~/")))

 (setq projectile-track-known-projects-automatically nil)

 ;; Use alien as the default, and project-wise add other files
 (setq projectile-indexing-method 'native)
 (setq projectile-enable-caching t)
 (setq projectile-files-cache-expire 300)
 (setq projectile-file-exists-remote-cache-expire nil)

 :config
 (define-key projectile-mode-map (kbd "s-p") 'projectile-command-map)
 (define-key
  projectile-mode-map (kbd "C-c p") 'projectile-command-map)
 (define-key projectile-mode-map (kbd "M-K") 'projectile-kill-buffers)

 (add-to-list 'projectile-globally-ignored-directories "/venv")
 (add-to-list 'projectile-globally-ignored-directories "/data")
 (add-to-list 'projectile-globally-ignored-directories "/typings")
 (add-to-list
  'projectile-globally-ignored-directories "/node_modules")
 (add-to-list 'projectile-globally-ignored-directories "/.mypy_cache")
 (add-to-list
  'projectile-globally-ignored-directories "/.pytest_cache")
 (add-to-list 'projectile-globally-ignored-directories "/.cache")
 (add-to-list 'projectile-globally-ignored-directories "/.dvc/cache")
 (add-to-list 'projectile-globally-ignored-directories "/.dvc/tmp")
 (add-to-list
  'projectile-globally-ignored-directories "/.jekyll-cache")
 (projectile-mode +1)
 ;; (add-hook 'magit-run-section-hook 'projectile-invalidate-cache)
 (add-hook
  'magit-section-post-command-hook 'projectile-invalidate-cache)

 (setq projectile-ignored-project-function
       (lambda (project-root)
         (string-match-p tramp-file-name-regexp project-root))))

;; Built-in completion-preview configuration (Emacs 30+)
(use-package completion-preview
  :ensure nil  ;; Built-in package, don't try to install
  :when (fboundp 'completion-preview-mode)
  :custom
  ;; Configure to mimic Corfu behavior
  (completion-preview-minimum-symbol-length 1)    ;; Like corfu-auto-prefix
  (completion-preview-exact-match-only nil)       ;; Show multiple matches, not just exact
  (completion-preview-idle-delay 0.0)             ;; No delay, like corfu-auto-delay
  (completion-preview-commands '(self-insert-command
                                insert-char
                                delete-backward-char
                                backward-delete-char-untabify
                                analyze-text-conversion
                                completion-preview-complete))
  (completion-preview-sort-function #'completion-pcm--sort-string-in-region)  ;; Similar ordering to Corfu
  (completion-preview-message-format "Completion %i of %n")  ;; Nice cycling message

  :init
  ;; Use our existing completion styles (orderless)
  (setq completion-preview-completion-styles '(orderless basic))

  ;; Enable globally
  (global-completion-preview-mode 1)

  :config
  ;; Add cycling keybindings similar to Corfu
  (define-key completion-preview-active-mode-map (kbd "M-n") #'completion-preview-next-candidate)
  (define-key completion-preview-active-mode-map (kbd "M-p") #'completion-preview-prev-candidate)

  ;; Add visual enhancements
  (custom-set-faces
   '(completion-preview ((t :inherit shadow :slant italic)))
   '(completion-preview-exact ((t :underline "#00aa00" :inherit completion-preview-common)))
   '(completion-preview-highlight ((t :inherit highlight :weight bold))))

  ;; Optional: disable preview when doing certain operations
  (add-hook 'before-save-hook (lambda () (completion-preview-hide))))

(use-package
 corfu
 ;; Optional customizations
 :custom
 (corfu-cycle t) ;; Enable cycling for `corfu-next/previous'
 (corfu-auto t) ;; Enable auto completion
 ;; (corfu-commit-predicate nil)   ;; Do not commit selected candidates on next input
 (corfu-quit-at-boundary 'separator) ;; Automatically quit at word boundary
 (corfu-quit-no-match 'separator) ;; Automatically quit if there is no match
 (corfu-scroll-margin 5) ;; Use scroll margin
 ;; (corfu-preview-current nil)    ;; Do not preview current candidate
 (corfu-auto-delay 0.0)
 (corfu-auto-prefix 1)
 (corfu-on-exact-match 'quit)

 ;; (corfu-separator ?\s)          ;; Orderless field separator
 ;; (corfu-preview-current nil)    ;; Disable current candidate preview
 ;; (corfu-preselect-first nil)    ;; Disable candidate preselection
 ;; (corfu-on-exact-match nil)     ;; Configure handling of exact matches
 ;; (corfu-echo-documentation nil) ;; Disable documentation in the echo area
 ;; (corfu-scroll-margin 5)        ;; Use scroll margin

 ;; You may want to enable Corfu only for certain modes.
 ;; :hook ((prog-mode . corfu-mode)
 ;;        (shell-mode . corfu-mode)
 ;;        (eshell-mode . corfu-mode))

 ;; Recommended: Enable Corfu globally.
 ;; This is recommended since dabbrev can be used globally (M-/).
 :init (global-corfu-mode)

 ;; :config
 ;; (define-key corfu-map (kbd "M-p") #'corfu-doc-scroll-down) ;; corfu-next
 ;; (define-key corfu-map (kbd "M-n") #'corfu-doc-scroll-up)  ;; corfu-previous

 ;; Quit on save
 :hook (before-save-hook . corfu-quit)
 :load-path "straight/build/corfu/extensions"
 :config
 (require 'corfu-history)
 (corfu-history-mode 1)
 (savehist-mode 1)
 (add-to-list 'savehist-additional-variables 'corfu-history)
 ;; (corfu-mode-hook . corfu-doc-mode)
 )

(advice-add 'corfu--candidates :around
            (lambda (orig-fun &rest args)
              (message "corfu--candidates called with args: %S" args)
              (let ((result (apply orig-fun args)))
                (message "corfu--candidates returned: %S" result)
                result)))

;; Better approach for combining Eglot and file completion
(defun my/eglot-capf ()
  "Set up improved completion-at-point functions for Eglot-managed buffers."
  (setq-local
   completion-at-point-functions
   (list
    #'eglot-completion-at-point
    ;; Use cape-file separately rather than in cape-capf-super
    #'cape-file)))

(add-hook 'eglot-managed-mode-hook #'my/eglot-capf)

;; Keep the Eglot integration settings
(setq completion-category-overrides
      '((eglot (styles orderless)) (eglot-capf (styles orderless))))
(advice-add 'eglot-completion-at-point :around #'cape-wrap-buster)

(advice-add 'eglot-completion-at-point :around #'cape-wrap-buster)

;; Option 1: Specify explicitly to use Orderless for Eglot
(setq completion-category-overrides '((eglot (styles orderless))
                                      (eglot-capf (styles orderless))))

;; Option 2: Undo the Eglot modification of completion-category-defaults
(with-eval-after-load 'eglot
   (setq completion-category-defaults nil))

;; Enable cache busting, depending on if your server returns
;; sufficiently many candidates in the first place.
(advice-add 'eglot-completion-at-point :around #'cape-wrap-buster)

(defun my/eglot-capf ()
  (setq-local completion-at-point-functions
              (list (cape-capf-super
                     #'eglot-completion-at-point
                     ;; #'yas-expand
                     #'cape-file))))

(add-hook 'eglot-managed-mode-hook #'my/eglot-capf)

(defun add-cape-completions ()
  (add-to-list 'completion-at-point-functions #'cape-file)
  ;; (add-to-list 'completion-at-point-functions
  ;;              #'cape-keyword)
  ;; (add-to-list 'completion-at-point-functions
  ;;              #'cape-symbol)
  )

;; Add extensions
(use-package
 cape
 ;; Bind dedicated completion commands
 ;; :bind (("C-c p p" . completion-at-point) ;; capf
 ;;        ("C-c p t" . complete-tag)        ;; etags
 ;;        ("C-c p d" . cape-dabbrev)        ;; or dabbrev-completion
 ;;        ("C-c p f" . cape-file)
 ;;        ("C-c p k" . cape-keyword)
 ;;        ("C-c p s" . cape-symbol)
 ;;        ("C-c p a" . cape-abbrev)
 ;;        ("C-c p i" . cape-ispell)
 ;;        ("C-c p l" . cape-line)
 ;;        ("C-c p w" . cape-dict)
 ;;        ("C-c p \\" . cape-tex)
 ;;        ("C-c p _" . cape-tex)
 ;;        ("C-c p ^" . cape-tex)
 ;;        ("C-c p &" . cape-sgml)
 ;;        ("C-c p r" . cape-rfc1345))
 :hook (corfu-mode . add-cape-completions))
;; A few more useful configurations...
(setq completion-cycle-threshold 3)

;; Optionally use the `orderless' completion style.
(use-package
 orderless
 :after vertico
 :init
 ;; Tune the global completion style settings to your liking!
 ;; This affects the minibuffer and non-lsp completion at point.
 (setq
  completion-styles '(orderless partial-completion basic)
  completion-category-defaults nil
  completion-category-overrides nil))

;; ;; Use dabbrev with Corfu!
;; (use-package dabbrev
;;   ;; Swap M-/ and C-M-/
;;   :bind (("M-/" . dabbrev-completion)
;;          ("C-M-/" . dabbrev-expand)))

;; A few more useful configurations...
(use-package
 emacs
 :init
 ;; TAB cycle if there are only few candidates
 (setq completion-cycle-threshold 3)

 ;; Emacs 28: Hide commands in M-x which do not apply to the current mode.
 ;; Corfu commands are hidden, since they are not supposed to be used via M-x.
 ;; (setq read-extended-command-predicate
 ;;       #'command-completion-default-include-p)
 )

;; Enable vertico
(use-package
 vertico
 :init (vertico-mode)
 :bind (:map vertico-map ("C-j" . vertico-exit-input))

 ;; Different scroll margin
 ;; (setq vertico-scroll-margin 0)

 ;; Show more candidates
 ;; (setq vertico-count 20)

 ;; Grow and shrink the Vertico minibuffer
 ;; (setq vertico-resize t)

 ;; Optionally enable cycling for `vertico-next' and `vertico-previous'.
 ;; (setq vertico-cycle t)
 )

;; Persist history over Emacs restarts. Vertico sorts by history position.
(use-package savehist :init (savehist-mode))

;; A few more useful configurations...
(use-package
 emacs
 :init
 ;; Add prompt indicator to `completing-read-multiple'.
 ;; We display [CRM<separator>], e.g., [CRM,] if the separator is a comma.
 (defun crm-indicator (args)
   (cons
    (format "[CRM%s] %s"
            (replace-regexp-in-string
             "\\`\\[.*?]\\*\\|\\[.*?]\\*\\'" "" crm-separator)
            (car args))
    (cdr args)))
 (advice-add #'completing-read-multiple :filter-args #'crm-indicator)

 ;; Do not allow the cursor in the minibuffer prompt
 (setq minibuffer-prompt-properties
       '(read-only t cursor-intangible t face minibuffer-prompt))
 (add-hook 'minibuffer-setup-hook #'cursor-intangible-mode)

 ;; Emacs 28: Hide commands in M-x which do not work in the current mode.
 ;; Vertico commands are hidden in normal buffers.
 ;; (setq read-extended-command-predicate
 ;;       #'command-completion-default-include-p)

 ;; Enable recursive minibuffers
 (setq enable-recursive-minibuffers t))

(use-package marginalia
  ;; Bind `marginalia-cycle' locally in the minibuffer.  To make the binding
  ;; available in the *Completions* buffer, add it to the
  ;; `completion-list-mode-map'.
  :bind (:map minibuffer-local-map
         ("M-A" . marginalia-cycle))

  ;; The :init section is always executed.
  :init

  ;; Marginalia must be activated in the :init section of use-package such that
  ;; the mode gets enabled right away. Note that this forces loading the
  ;; package.
  (marginalia-mode))

(use-package embark
  :ensure t
  :bind
  (("C-." . embark-act)         ;; pick some comfortable binding
   ("C-;" . embark-dwim)        ;; good alternative: M-.
   ("C-h B" . embark-bindings)) ;; alternative for `describe-bindings'

  :init

  ;; Optionally replace the key help with a completing-read interface
  (setq prefix-help-command #'embark-prefix-help-command)

  ;; Show the Embark target at point via Eldoc. You may adjust the
  ;; Eldoc strategy, if you want to see the documentation from
  ;; multiple providers. Beware that using this can be a little
  ;; jarring since the message shown in the minibuffer can be more
  ;; than one line, causing the modeline to move up and down:

  ;; (add-hook 'eldoc-documentation-functions #'embark-eldoc-first-target)
  ;; (setq eldoc-documentation-strategy #'eldoc-documentation-compose-eagerly)

  :config

  ;; Hide the mode line of the Embark live/completions buffers
  (add-to-list 'display-buffer-alist
               '("\\`\\*Embark Collect \\(Live\\|Completions\\)\\*"
                 nil
                 (window-parameters (mode-line-format . none)))))

;; Consult users will also want the embark-consult package.
(use-package embark-consult
  :ensure t ; only need to install it, embark loads it after consult if found
  :hook
  (embark-collect-mode . consult-preview-at-point-mode))

;; Example configuration for Consult
(use-package
 consult
 ;; Replace bindings. Lazily loaded due by `use-package'.
 :demand t
 :bind
 ( ;; C-c bindings in `mode-specific-map'
  ("C-c M-x" . consult-mode-command)
  ("C-c h" . consult-history)
  ("C-c k" . consult-kmacro)
  ("C-c m" . consult-man)
  ("C-c i" . consult-info)
  ([remap Info-search] . consult-info)
  ;; C-x bindings in `ctl-x-map'
  ("C-x M-:" . consult-complex-command) ;; orig. repeat-complex-command
  ("C-x b" . consult-buffer) ;; orig. switch-to-buffer
  ("C-x 4 b" . consult-buffer-other-window) ;; orig. switch-to-buffer-other-window
  ("C-x 5 b" . consult-buffer-other-frame) ;; orig. switch-to-buffer-other-frame
  ("C-x t b" . consult-buffer-other-tab) ;; orig. switch-to-buffer-other-tab
  ("C-x r b" . consult-bookmark) ;; orig. bookmark-jump
  ("C-x p b" . consult-project-buffer) ;; orig. project-switch-to-buffer
  ;; Custom M-# bindings for fast register access
  ("M-#" . consult-register-load)
  ;; ("M-'" . consult-register-store) ;; orig. abbrev-prefix-mark (unrelated)
  ("M-\"" . consult-register-store) ;; orig. abbrev-prefix-mark (unrelated)
  ("C-M-#" . consult-register)
  ;; Other custom bindings
  ("M-y" . consult-yank-pop) ;; orig. yank-pop
  ;; M-g bindings in `goto-map'
  ("M-g e" . consult-compile-error)
  ("M-g f" . consult-flymake) ;; Alternative: consult-flycheck
  ("M-g g" . consult-goto-line) ;; orig. goto-line
  ("M-g M-g" . consult-goto-line) ;; orig. goto-line
  ("M-g o" . consult-outline) ;; Alternative: consult-org-heading
  ("M-g m" . consult-mark)
  ("M-g k" . consult-global-mark)
  ("M-g i" . consult-imenu)
  ("M-g I" . consult-imenu-multi)
  ;; M-s bindings in `search-map'
  ("M-s d" . consult-find) ;; Alternative: consult-fd
  ("M-s c" . consult-locate)
  ("M-s g" . consult-grep)
  ("M-s G" . consult-git-grep)
  ("M-s r" . consult-ripgrep)
  ("M-s l" . consult-line)
  ("M-s L" . consult-line-multi)
  ("M-s k" . consult-keep-lines)
  ("M-s u" . consult-focus-lines)
  ;; Isearch integration
  ;; ("M-s e" . consult-isearch-history)
  :map
  isearch-mode-map
  ("M-e" . consult-isearch-history) ;; orig. isearch-edit-string
  ("M-s e" . consult-isearch-history) ;; orig. isearch-edit-string
  ("M-s l" . consult-line) ;; needed by consult-line to detect isearch
  ("M-s L" . consult-line-multi) ;; needed by consult-line to detect isearch
  ;; Minibuffer history
  :map
  minibuffer-local-map
  ("M-s" . consult-history) ;; orig. next-matching-history-element
  ("M-r" . consult-history)) ;; orig. previous-matching-history-element

 ;; Enable automatic preview at point in the *Completions* buffer. This is
 ;; relevant when you use the default completion UI.
 :hook (completion-list-mode . consult-preview-at-point-mode)

 ;; The :init configuration is always executed (Not lazy)
 :init
 (defun consult-ripgrep-project-root (&optional initial)
   (interactive "P")
   (let ((dir (funcall consult-project-function)))
     (consult--grep
      "Ripgrep" #'consult--ripgrep-make-builder dir initial)))

 ;; Optionally configure the register formatting. This improves the register
 ;; preview for `consult-register', `consult-register-load',
 ;; `consult-register-store' and the Emacs built-ins.
 (setq
  register-preview-delay 0.5
  register-preview-function #'consult-register-format)

 ;; Optionally tweak the register preview window.
 ;; This adds thin lines, sorting and hides the mode line of the window.
 (advice-add #'register-preview :override #'consult-register-window)

 ;; Use Consult to select xref locations with preview
 (setq
  xref-show-xrefs-function #'consult-xref
  xref-show-definitions-function #'consult-xref)

 ;; Configure other variables and modes in the :config section,
 ;; after lazily loading the package.
 :config

 ;; Optionally configure preview. The default value
 ;; is 'any, such that any key triggers the preview.
 ;; (setq consult-preview-key 'any)
 ;; (setq consult-preview-key "M-.")
 ;; (setq consult-preview-key '("S-<down>" "S-<up>"))
 ;; For some commands and buffer sources it is useful to configure the
 ;; :preview-key on a per-command basis using the `consult-customize' macro.
 (consult-customize
  consult-theme
  :preview-key
  '(:debounce 0.2 any)
  consult-ripgrep
  consult-git-grep
  consult-grep
  consult-bookmark
  consult-recent-file
  consult-xref
  consult--source-bookmark
  consult--source-file-register
  consult--source-recent-file
  consult--source-project-recent-file
  ;; :preview-key "M-."
  :preview-key '(:debounce 0.4 any))

 ;; Optionally configure the narrowing key.
 ;; Both < and C-+ work reasonably well.
 (setq consult-narrow-key "<") ;; "C-+"

 ;; Optionally make narrowing help available in the minibuffer.
 ;; You may want to use `embark-prefix-help-command' or which-key instead.
 ;; (define-key consult-narrow-map (vconcat consult-narrow-key "?") #'consult-narrow-help)

 ;; By default `consult-project-function' uses `project-root' from project.el.
 ;; Optionally configure a different project root function.
 ;;;; 1. project.el (the default)
 ;; (setq consult-project-function #'project-root)
 ;;;; 2. vc.el (vc-root-dir)
 ;; (setq consult-project-function (lambda (_) (vc-root-dir)))
 ;;;; 3. locate-dominating-file
 ;; (setq consult-project-function (lambda (_) (locate-dominating-file "." ".git")))
 ;;;; 4. projectile.el (projectile-project-root)
 ;; (autoload 'projectile-project-root "projectile")
 ;; (setq consult-project-function
 ;;       (lambda (_) (projectile-project-root)))
 ;;;; 5. No project support
 ;; (setq consult-project-function nil)
 )

(use-package
 yasnippet
 :demand t
 :init
 (load "yasnippet.el") ; get rid of weird invalid function issue
 )
(use-package
 yasnippet-snippets
 :demand t
 :straight
 '(yasnippet-snippets
   :type git
   :host github
   :repo "jsigman/yasnippet-snippets"))

(yas-global-mode 1)

(use-package
 consult-yasnippet
 :after consult
 :config (global-set-key (kbd "M-Y") 'consult-yasnippet))

(use-package
 yasnippet-capf
 :after cape
 :init
 (setq yasnippet-capf-lookup-by 'key) ;; key or name
 :config (add-to-list 'completion-at-point-functions #'yasnippet-capf))

(use-package
 eglot
 :ensure t
 :demand t
 :straight nil
 :init
 (defun file-is-remote-p ()
   "Return non-nil if the current file is remote."
   (and (buffer-file-name) (file-remote-p (buffer-file-name))))

 (defun maybe-start-eglot ()
   "Start Eglot if the current file is not remote."
   (unless (file-is-remote-p)
     (when (fboundp 'eglot-ensure)
       (eglot-ensure))))

 (defun disable-eglot-if-remote ()
   "Disable Eglot if the current file is remote."
   (when (and (file-is-remote-p)
              (fboundp 'eglot-managed-p)
              (fboundp 'eglot-shutdown)
              (eglot-managed-p))
     (eglot-shutdown)))

 :hook
 ((python-mode
   markdown-mode
   sh-mode
   yaml-mode
   json-mode
   dockerfile-mode
   LaTeX-mode)
  . maybe-start-eglot)
 :hook (find-file . disable-eglot-if-remote)
 :config
 ;; Configure eglot-server-programs
 (add-to-list
  'eglot-server-programs
  '(python-mode . ("pyright-langserver" "--stdio")))
 (add-to-list
  'eglot-server-programs
  '(markdown-mode . ("vscode-markdown-language-server" "--stdio")))
 (add-to-list
  'eglot-server-programs
  '(sh-mode . ("bash-language-server" "start")))
 (add-to-list
  'eglot-server-programs
  '(yaml-mode . ("yaml-language-server" "--stdio")))
 (add-to-list
  'eglot-server-programs
  '(json-mode . ("vscode-json-languageserver" "--stdio")))
 (add-to-list
  'eglot-server-programs
  '(dockerfile-mode . ("docker-langserver" "--stdio")))
 (add-to-list 'eglot-server-programs '(LaTeX-mode . ("texlab")))

 (defvar my-eglot-inlay-hints-exempt-modes
   '(python-ts-mode python-mode) ;; List of modes where inlay hints should be disabled
   "List of major modes where Eglot inlay hints mode should be disabled.")

 (defun my-disable-eglot-inlay-hints ()
   "Disable Eglot inlay hints mode for specific major modes."
   (when (and (bound-and-true-p eglot-inlay-hints-mode)
              (member major-mode my-eglot-inlay-hints-exempt-modes))
     (eglot-inlay-hints-mode -1)))

 (add-hook 'eglot-managed-mode-hook #'my-disable-eglot-inlay-hints)

 ;; Customize eglot symbol highlighting
 (custom-set-faces
  '(eglot-highlight-symbol-face
    ((t (:inherit highlight :underline t)))))

 ;; Basic settings
 (setq eglot-autoshutdown t) (setq eglot-extend-to-xref t)

 ;; Increase read-process-output-max for performance
 (setq read-process-output-max (* 1024 1024))

 ;; Ignore certain directories for file watching
 (setq eglot-ignored-server-capabilities
       '(:documentOnTypeFormattingProvider))

 ;; Key bindings (optional)
 :bind
 (:map
  eglot-mode-map
  ("C-c l a" . eglot-code-actions)
  ("C-c l r" . eglot-rename)
  ("C-c l f" . eglot-format)
  ("C-c l d" . eglot-find-declaration)))

(use-package
 iedit
 :custom-face (iedit-occurrence ((t (:background "Red"))))
 :bind (:map eglot-mode-map ("M-S" . eglot-iedit-highlights))
 :init
 (setq iedit-toggle-key-default nil) ;; Disable the warning for conflicting keybinding
 (defun eglot-iedit-highlights ()
   "Start an `iedit' operation on the documentHighlights at point.
This can be used as a primitive `eglot-rename' replacement if the
language server doesn't support renaming.

See also `eglot-server-capable' for :documentHighlightProvider."
   (interactive)
   (unless (eglot-server-capable :documentHighlightProvider)
     (error "Server does not support documentHighlights"))
   (let
       ((highlights
         (eglot--request
          (eglot--current-server-or-lose)
          :textDocument/documentHighlight (eglot--TextDocumentPositionParams)))
        (-compare-fn
         (lambda (hl1 hl2)
           (and (equal
                 (plist-get (plist-get hl1 :range) :start)
                 (plist-get (plist-get hl2 :range) :start))
                (equal
                 (plist-get (plist-get hl1 :range) :end)
                 (plist-get (plist-get hl2 :range) :end))))))
     (iedit-mode)
     (dolist (highlight (-distinct highlights))
       (let* ((range (plist-get highlight :range))
              (start
               (eglot--lsp-position-to-point
                (plist-get range :start)))
              (end
               (eglot--lsp-position-to-point (plist-get range :end))))
         (iedit-add-occurrence-overlay start end))))))

(use-package
 eglot-booster
 :after eglot
 :config (eglot-booster-mode)
 :straight
 '(eglot-booster
   :type git
   :host github
   :repo "jdtsmith/eglot-booster"))

(use-package dash)
(use-package ht)
(use-package pcre2el)
(use-package async)

(use-package eros :config (eros-mode t))
(use-package
 lisp-extra-font-lock
 :config (lisp-extra-font-lock-global-mode 1))
(use-package elisp-docstring-mode)
(use-package
 highlight-function-calls
 :hook (emacs-lisp-mode . highlight-function-calls-mode))
(use-package
 inspector
 :straight
 '(inspector :type git :host github :repo "mmontone/emacs-inspector"))
(setq eval-expression-print-length nil)
(setq eval-expression-print-level nil)

;;; Python configuration
(use-package
 python
 :init
 (setq python-shell-interpreter "python3")
 (setq python-shell-interpreter-args "-i")
 :bind
 (:map
  python-mode-map
  ;; Unbind all Python shell keys I don't use
  ("C-c C-b" . nil) ; python-shell-send-block - Send current block to Python shell
  ("C-c C-c" . nil) ; python-shell-send-buffer - Send entire buffer to Python shell
  ("C-c C-d" . nil) ; python-describe-symbol - Display documentation for Python symbol
  ("C-c C-f" . nil) ; python-shell-send-file - Send file to Python shell
  ("C-c C-p" . nil) ; run-python - Start a Python interpreter process
  ("C-c C-r" . nil) ; python-shell-send-region - Send region to Python shell
  ("C-c C-s" . nil) ; python-shell-send-string - Send string to Python shell
  ("C-c C-z" . nil)) ; python-shell-switch-to-shell - Switch to Python shell buffer
 :config
 ;; Also unbind keys for python-ts-mode
 (with-eval-after-load 'python-ts-mode
   (bind-keys
    :map python-ts-mode-map
    ("C-c C-b" . nil) ; python-shell-send-block
    ("C-c C-c" . nil) ; python-shell-send-buffer
    ("C-c C-d" . nil) ; python-describe-symbol
    ("C-c C-f" . nil) ; python-shell-send-file
    ("C-c C-p" . nil) ; run-python
    ("C-c C-r" . nil) ; python-shell-send-region
    ("C-c C-s" . nil) ; python-shell-send-string
    ("C-c C-z" . nil)))) ; python-shell-switch-to-shell

;; Python prettify symbols
(add-hook
 'python-mode-hook
 (lambda ()
   (mapc
    (lambda (pair) (push pair prettify-symbols-alist))
    '(("in" . #x2208) ("return" . #x27fc) ("yield" . #x27fb)))))

;; Apply the same prettify-symbols to python-ts-mode
(add-hook
 'python-ts-mode-hook
 (lambda ()
   (mapc
    (lambda (pair) (push pair prettify-symbols-alist))
    '(("in" . #x2208) ("return" . #x27fc) ("yield" . #x27fb)))))

(use-package
 buftra
 :straight
 '(buftra.el :type git :host github :repo "humitos/buftra.el"))

(use-package
 py-pyment
 :straight
 '(py-cmd-buffer.el
   :type git
   :host github
   :repo "humitos/py-cmd-buffer.el")
 :after python
 :config (setq py-pyment-options '("--output=google")))

(defun python-multiline-to-singleline ()
  "Convert multi-line Python code in the current region to a single line with single spaces."
  (interactive)
  (when (use-region-p)
    (let* ((start (region-beginning))
           (end (region-end))
           (multi-line-code (buffer-substring start end))
           (single-line-code (replace-regexp-in-string "[ \t\n]+" " " multi-line-code)))
      (kill-new single-line-code)
      (message "Single-line code copied to kill ring."))))

(with-eval-after-load 'python
  (define-key python-mode-map (kbd "C-c C-l") 'python-multiline-to-singleline))

(use-package markdown-mode
  :mode ("\\.md\\'" . gfm-mode)
  :init
  (setq markdown-command "multimarkdown")
  :config
  (setq markdown-fontify-code-blocks-natively t))

(use-package
 sgml-mode
 :mode ("\\.html\\'" . html-mode)
 :bind
 (:map
  sgml-mode-map
  ("M-o b" . nil)
  ("M-o d" . nil)
  ("M-o i" . nil)
  ("M-o l" . nil)
  ("M-o o" . nil)
  ("M-o u" . nil)
  ("M-o M-o" . nil)
  ("M-o" . nil))
 :bind
 (:map
  html-mode-map
  ("M-o b" . nil)
  ("M-o d" . nil)
  ("M-o i" . nil)
  ("M-o l" . nil)
  ("M-o o" . nil)
  ("M-o u" . nil)
  ("M-o M-o" . nil)
  ("M-o" . nil)))
(use-package html-ts-mode)

(use-package
 web-mode
 :config
 (add-to-list 'auto-mode-alist '("\\.liquid\\'" . web-mode)))

(use-package
 dotenv-mode
 :defer t
 :init
 (add-to-list
  'auto-mode-alist '("\\.env\\(\\.template\\)?\\'" . dotenv-mode)))

(use-package
 tex
 :straight auctex
 :defer t
 :hook (LaTeX-mode . visual-line-mode)
 :hook (LaTeX-mode . flyspell-mode)
 :hook (LaTeX-mode . LaTeX-math-mode)
 :hook (LaTeX-mode . TeX-source-correlate-mode)
 :config
 (setq TeX-auto-save t)
 (setq TeX-parse-self t)
 (setq-default TeX-master nil)

 ;; (add-hook 'LaTeX-mode-hook 'company-auctex-init)
 ;; (add-hook 'LaTeX-mode-hook 'company-mode)
 (add-hook 'LaTeX-mode-hook 'turn-on-reftex)
 (setq reftex-plug-into-AUCTeX t)
 (setq TeX-PDF-mode t))
(use-package cdlatex)

;; -------------------------/AucTex-------------------------------;;

(use-package
 matlab-mode
 '(matlab-mode
   :type git
   :repo "https://git.code.sf.net/p/matlab-emacs/src")
 :defer t)
(require 'matlab)
(setq matlab-shell-command-switches '("-nodesktop" "-nosplash"))

;; Override the 'yes-or-no-p' temporarily
(let ((original-yes-or-no-p (symbol-function 'yes-or-no-p)))
  (fset 'yes-or-no-p (lambda (&rest args) t))

  ;; Load the sqlite3 package
  (use-package
   sqlite3
   :straight
   (sqlite3
    :type git
    :host github
    :repo "pekingduck/emacs-sqlite3-api"
    :files ("*.c" "*.h" "*.el" "Makefile")))

  ;; Restore the original function
  (fset 'yes-or-no-p original-yes-or-no-p))

(use-package yaml-mode)
(use-package yaml-ts-mode)

(use-package
 dap-mode
 :init
 (if (eq system-type 'gnu/linux)
     (add-to-list 'image-types 'svg))
 :config
 (add-hook
  'dap-stopped-hook (lambda (arg) (call-interactively #'dap-hydra)))
 ;; Enabling only some features
 (setq dap-auto-configure-features
       '(sessions locals controls tooltip))
 (setq dap-python-debugger 'debugpy)
 (require 'dap-mode)
 (require 'dap-python)
 (require 'dap-ui)

 (add-hook 'python-mode-hook 'dap-mode)
 (add-hook 'python-mode-hook 'dap-ui-mode)
 (add-hook 'python-mode-hook 'dap-tooltip-mode)

 (define-key python-mode-map (kbd "M-D") #'dap-hydra))

(use-package jq-mode)

(use-package json-mode)
(use-package
 json-ts-mode
 :init (add-to-list 'auto-mode-alist '("\\.jsonl\\'" . json-ts-mode))
 ;; Add a hook to disable apheleia for jsonl files
 (add-hook
  'json-ts-mode-hook
  (lambda ()
    (when (and buffer-file-name
               (string-match-p "\\.jsonl\\'" buffer-file-name))
      (apheleia-mode -1)))))

(use-package
 jsonian
 :straight
 '(jsonian
   :type git
   :host github
   :repo "iwahbe/jsonian"
   :build (:not autoloads)))

(use-package
 minuet
 :demand t ; Force immediate loading
 :bind
 (:map
  minuet-active-mode-map
  ("M-RET" . minuet-accept-suggestion)
  ("M-n" . minuet-next-suggestion)
  ("M-p" . minuet-previous-suggestion))

 :hook
 ((python-ts-mode
   python-mode
   emacs-lisp-mode
   js-ts-mode
   typescript-ts-mode
   rust-ts-mode
   c++-ts-mode
   c-ts-mode
   yaml-ts-mode)
  . minuet-auto-suggestion-mode)

 :config
 (setq minuet-provider 'openai-fim-compatible)
 (setq minuet-request-timeout 10)
 (setq minuet-context-window 256)
 (setq minuet-n-completions 1)

 (setq minuet-auto-suggestion-debounce-delay 0.2)
 (setq minuet-auto-suggestion-throttle-delay 0.5))

(use-package
 copilot
 :straight
 (:host
  github
  :repo "zerolfx/copilot.el"
  :files ("dist" "*.el")
  :pre-build
  (lambda (_)
    (unless (file-exists-p "./dist/copilot.js")
      (message
       "Running copilot-install-server after fresh install...")
      ;; We need to delay the server installation until after the package is properly set up
      (with-eval-after-load 'copilot
        (copilot-install-server)))))
 :bind
 (:map
  copilot-completion-map ("M-<return>" . copilot-accept-completion))
 :hook
 ((prog-mode yaml-mode org-mode direnv-envrc-mode conf-mode)
  .
  my/copilot-mode-setup)
 (python-mode . (lambda () (setq tab-width 4)))
 (yaml-mode . (lambda () (setq tab-width 0)))
 :config
 (setq copilot-max-char -1)
 (setq copilot-indent-offset-warning-disable t)

 (defun my/copilot-mode-setup ()
   "Disable copilot-mode if connected to a 'coder.*' host."
   (let ((remote-host (file-remote-p default-directory 'host)))
     (unless (and remote-host
                  (string-match-p "^coder\\." remote-host))
       (copilot-mode 1)))))

(use-package
 c3po
 :straight (:host github :repo "d1egoaz/c3po.el")
 :config
 (setq chat-api-key
       (f-read-text (expand-file-name "~/.openai/emacs-key.txt"))))

(use-package
 openai
 :straight
 (openai :type git :host github :repo "emacs-openai/openai")
 :init (setq openai-key (getenv "OPENAI_API_KEY")))
(use-package
 chatgpt
 :straight (chatgpt :type git :host github :repo "emacs-openai/chatgpt")
 ;; :config (setq chatgpt-model "gpt-4-0613")
 )
(use-package
 codegpt
 :straight
 (codegpt :type git :host github :repo "emacs-openai/codegpt"))
(use-package
 dall-e
 :straight
 (dall-e :type git :host github :repo "emacs-openai/dall-e"))

(use-package llm)
(use-package
 ellama
 :init
 (setopt
  ellama-provider (make-llm-ollama :chat-model "codellama:34b")))

(use-package
 aider
 :straight (:host github :repo "tninja/aider.el" :files ("aider.el"))
 :config
 ;; Use claude-3-5-sonnet cause it is best in aider benchmark
 (setq aider-args
       '("--model"
         "bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0"))
 (global-set-key (kbd "C-c a") 'aider-transient-menu))

(use-package
 flycheck
 :init
 (define-fringe-bitmap 'my-flycheck-fringe-indicator
   (vector
    #b00000000
    #b00000000
    #b00000000
    #b00000000
    #b00000000
    #b00000000
    #b00000000
    #b00011100
    #b00111110
    #b00111110
    #b00111110
    #b00011100
    #b00000000
    #b00000000
    #b00000000
    #b00000000
    #b00000000))
 (flycheck-define-error-level
  'error
  :severity 2
  :overlay-category 'flycheck-error-overlay
  :fringe-bitmap 'my-flycheck-fringe-indicator
  :fringe-face 'flycheck-fringe-error)
 (flycheck-define-error-level
  'warning
  :severity 1
  :overlay-category 'flycheck-warning-overlay
  :fringe-bitmap 'my-flycheck-fringe-indicator
  :fringe-face 'flycheck-fringe-warning)
 (flycheck-define-error-level
  'info
  :severity 0
  :overlay-category 'flycheck-info-overlay
  :fringe-bitmap 'my-flycheck-fringe-indicator
  :fringe-face 'flycheck-fringe-info)
 ;; :config
 ;; (use-package flycheck-pos-tip )
 ;; (flycheck-pos-tip-mode)
 ; Flycheck
 (setq flycheck-idle-change-delay 0.1)
 (setq flycheck-display-errors-delay 0.1)
 (setq flycheck-idle-buffer-switch-delay 0.1)

 (setq flycheck-checkers (remove 'python-pylint flycheck-checkers))
 (setq flycheck-checkers (remove 'python-pycompile flycheck-checkers))
 (setq flycheck-checkers (remove 'python-pyright flycheck-checkers))

 (add-hook 'after-init-hook #'global-flycheck-mode)
 (setq flycheck-global-modes
       '(python-base-mode js-mode python-mode python-ts-mode))

 (defun debug-flycheck-ruff-disabled (symbol newval operation where)
   "Log debug information when python-ruff is added to flycheck--automatically-disabled-checkers."
   (when (and (eq operation 'set) (member 'python-ruff newval))
     (let ((debug-on-error t)
           (debug-buffer (get-buffer-create "*flycheck-ruff-debug*")))
       (with-current-buffer debug-buffer
         (goto-char (point-max))
         (insert "\n\n")
         (insert
          (format-time-string
           "Debug info captured at %Y-%m-%d %H:%M:%S\n\n"))
         (insert
          "python-ruff has been added to automatically disabled checkers.\n\n")
         (insert (format "All disabled checkers: %s\n\n" newval))
         (insert
          (format ":enabled predicate returned: %s\n\n"
                  (flycheck-checker-get 'python-ruff :enabled)))
         (insert
          (format "Error threshold: %s\n\n"
                  flycheck-checker-error-threshold))
         (insert "Stack trace:\n")
         (insert
          (with-output-to-string
            (backtrace)))
         (insert "\n\nEnd of debug info.\n"))
       (display-buffer debug-buffer))))

 (add-variable-watcher
  'flycheck--automatically-disabled-checkers
  #'debug-flycheck-ruff-disabled)

 (setq flycheck-checker-error-threshold nil)
 (setq flycheck-debug t))

(defvar should-delete-flycheck-list-buffer nil)
(defun my/flycheck-list-errors ()
  "Open flycheck list if it doesn't exist.  If it does, close it."
  (interactive)
  (let* ((target-buffer-name "*Flycheck errors*")
         (target-buffer (get-buffer target-buffer-name))
         (target-window (get-buffer-window target-buffer)))
    (if (and target-buffer target-window)
        ;; the target buffer exists and window is visible
        (progn
          (when should-delete-flycheck-list-buffer
            (delete-window target-window))
          (kill-buffer target-buffer))
      ;; the target buffer doesn't exist or the window isn't visible
      (let* ((starting-window-count (count-windows)))
        (flycheck-list-errors)
        (setq should-delete-flycheck-list-buffer
              (> (count-windows) starting-window-count))))))

(define-key flycheck-mode-map (kbd "M-C") 'my/flycheck-list-errors)

(use-package flymake :ensure t)
(add-hook 'python-ts-mode-hook 'flymake-mode)

(use-package flymake-ruff :ensure t :config (flymake-ruff-load))

(use-package flymake-json :ensure t :config (flymake-json-load))

(defun flymake-ruff--check-buffer ()
  "Generate a list of diagnostics for the current buffer."
  (let ((code-buffer (current-buffer))
        (start-line (line-number-at-pos (point-min) t))
        (code-content
         (without-restriction
           (buffer-substring-no-properties (point-min) (point-max))))
        (dxs '()))
    (with-temp-buffer
      (insert code-content)
      (let* ((config
              (and (project-current)
                   (seq-find
                    #'file-readable-p
                    (mapcar
                     (lambda (f)
                       (expand-file-name
                        f
                        (project-root (project-current))))
                     flymake-ruff--default-configs))))
             (args
              (if config
                  (append
                   (list "check" "--config" config)
                   flymake-ruff-program-args)
                (cons "check" flymake-ruff-program-args))))
        (apply #'call-process-region
               (point-min)
               (point-max)
               flymake-ruff-program
               t
               t
               nil
               args))
      (goto-char (point-min))
      (while (search-forward-regexp flymake-ruff--output-regex
                                    (point-max)
                                    t)
        (when (match-string 2)
          (let* ((line (string-to-number (match-string 2)))
                 (col (string-to-number (match-string 3)))
                 (code (match-string 4))
                 (msg (match-string 5))
                 (description (format "Ruff: %s %s" code msg))
                 (region
                  (flymake-diag-region
                   code-buffer (1+ (- line start-line)) col))
                 (dx
                  (flymake-make-diagnostic
                   code-buffer
                   (car region)
                   (cdr region)
                   :error description)))
            (add-to-list 'dxs dx)))))
    dxs))
(setq flymake-ruff-program-args
      '("--output-format" "concise" "--exit-zero" "--quiet" "-"))
(defun my-python-ruff-setup ()
  (add-hook 'flymake-diagnostic-functions #'flymake-ruff--run-checker nil t))
(add-hook 'python-base-mode-hook #'my-python-ruff-setup)

(setq enable-remote-dir-locals nil)
(setq tramp-chunksize 4050)
(setq tramp-verbose 10)
(setq vc-ignore-dir-regexp
      (format "\\(%s\\)\\|\\(%s\\)"
              vc-ignore-dir-regexp
              tramp-file-name-regexp))
(defun open-remote-dired ()
  "Opens a Dired buffer at the path specified by REMOTE_HOST and REMOTE_PATH environment variables."
  (interactive)
  (condition-case nil
      (let ((remote-host (getenv "REMOTE_HOST"))
            (remote-path (getenv "REMOTE_PATH")))
        (if (and remote-host remote-path)
            (progn
              (message "Attempting to open remote directory...")
              (dired (concat "/ssh:" remote-host ":" remote-path))
              (message "Remote directory opened."))
          (message
           "Error: REMOTE_HOST or REMOTE_PATH environment variables not set.")))
    (error
     (message
      "Error: Unable to open remote directory. Check your connection and environment variables."))))

;; Bind the function to M-R globally
(global-set-key (kbd "M-R") 'open-remote-dired)

(defun my-setup-tramp-path ()
  (let ((local-path (cdr (assoc 'my-project-specific-path dir-local-variables-alist))))
    (when local-path
      (add-to-list 'tramp-remote-path
                   (concat "/sshx:your_username@remote_host:" local-path)))))
(add-hook 'hack-dir-local-variables-hook #'my-setup-tramp-path)

(defun my/eglot-project-function (dir)
  "Custom project function for Eglot that avoids using Projectile for remote directories."
  (if (file-remote-p dir)
      (cons 'transient dir)  ; Treat remote dirs as transient projects
    (project-try-vc dir)))   ; Use VC-based detection for local dirs

(setq eglot-project-function #'my/eglot-project-function)

(defun my-tramp-file-name-handler (operation &rest args)
  "Disable file locks for TRAMP files."
  (if (eq operation 'vc-registered)
      nil
    (let ((file-name-handler-alist
           (remove (cons "\\`/\\(ssh\\|scp\\|ftp\\):" 'my-tramp-file-name-handler)
                   file-name-handler-alist)))
      (apply operation args))))

(add-to-list 'file-name-handler-alist
             '("\\`/\\(ssh\\|scp\\|ftp\\):" . my-tramp-file-name-handler))

(defun my/setup-tramp-backup-options ()
  "Disable backups and auto-save for remote files accessed via TRAMP."
  (when (file-remote-p default-directory)
    (setq-local backup-inhibited t) ;; Disable backup
    (setq-local auto-save-default nil) ;; Disable auto save
    (setq-local create-lockfiles nil))) ;; Disable lock files as well

(defcustom my-direnv-enabled-hosts nil
  "List of remote hosts to use Direnv on.

Each host must have `direnv' executable accessible in the default
environment."
  :type '(repeat string)
  :group 'my)

(defun tramp-sh-handle-start-file-process@my-direnv (args)
  "Enable Direnv for hosts in `my-direnv-enabled-hosts'."
  (with-parsed-tramp-file-name
   (expand-file-name default-directory) nil
   (if (member host my-direnv-enabled-hosts)
       (progn (pcase-let ((`(,name ,buffer ,program . ,args) args))
         `(,name ,buffer "direnv" "exec" ,localname ,program ,@args)) (debug))
     args)))

(with-eval-after-load "tramp-sh"
  (advice-add
   'tramp-sh-handle-start-file-process
   :filter-args #'tramp-sh-handle-start-file-process@my-direnv))

(defun edit-current-file-as-root ()
  "Reopen the current file as root."
  (interactive)
  (let ((file (buffer-file-name)))
    (if (not (file-writable-p file))
        (find-file (concat "/sudo::" file))
      (message "File is already writable"))))

(defun my/tramp-ssh-completion-filter (completions)
  (cl-remove-if-not
   (lambda (completion)
     (not (or (string-match-p "^coder-vscode--:$" completion)         ; Exclude "coder-vscode--:"
              (string-match-p "^coder-vscode\\.coder\\.infiniaml\\.net--:$" completion)  ; Exclude "coder-vscode.coder.infiniaml.net--:"
              (string-match-p "^coder\\.:$" completion))))             ; Exclude "coder.:"
   completions))

(advice-add 'tramp-completion-handle-file-name-all-completions
            :filter-return #'my/tramp-ssh-completion-filter)

(add-to-list
 'auto-mode-alist
 '("\\.dir-locals\\(?:-2\\)?\\.el\\'" . emacs-lisp-mode))

(defun my/dir-local-error-warning (orig-fun &rest args)
  "Advice to display a warning on directory local variable read errors."
  (condition-case err
      (apply orig-fun args)
    (error
     (display-warning
      'dir-locals
      (format "Error reading .dir-locals.el: %s"
              (error-message-string err))
      :error))))
(advice-add
 'hack-dir-local-variables
 :around #'my/dir-local-error-warning)

(put 'flymake-diagnostic-functions 'safe-local-variable
     (lambda (value)
       (and (listp value)
            (cl-every #'symbolp value))))

(put 'python-flymake-command 'safe-local-variable
     (lambda (value)
       (and (listp value)
            (cl-every #'stringp value))))

(use-package
 dockerfile-mode
 :config (setq dockerfile-mode-command "docker"))
(use-package docker
  :ensure t
  :bind ("C-c d" . docker))

(use-package
 compile-angel
 :ensure t
 :demand t
 :custom (compile-angel-verbose nil)
 :config
 (compile-angel-on-load-mode)
 (add-hook 'emacs-lisp-mode-hook #'compile-angel-on-save-local-mode))

;; From minimal-emacs.d: Better session management settings

;; Auto-revert: Update buffers when files change on disk
(global-auto-revert-mode 1)
(setq global-auto-revert-non-file-buffers t)
(setq auto-revert-verbose nil)

;; recentf: Track recently opened files
(recentf-mode 1)
(setq recentf-max-saved-items 300)
(setq recentf-max-menu-items 15)
(add-hook 'kill-emacs-hook #'recentf-cleanup)

;; savehist: Save minibuffer history
(savehist-mode 1)
(setq history-length 300)
(setq savehist-additional-variables
      '(kill-ring
        register-alist
        mark-ring global-mark-ring
        search-ring regexp-search-ring))

;; save-place: Remember cursor position in files
(save-place-mode 1)
(setq save-place-limit 600)

;; From minimal-emacs.d: Better file handling settings

;; Backup settings for better file safety
(setq backup-by-copying t)
(setq delete-old-versions t)
(setq version-control t)
(setq kept-new-versions 5)
(setq kept-old-versions 5)

;; Auto-save for crash protection
(setq auto-save-default t)
(setq auto-save-interval 300)
(setq auto-save-timeout 30)
(setq auto-save-visited-interval 5)
(auto-save-visited-mode 1)

;; From minimal-emacs.d: Better UI responsiveness settings

;; Smoother scrolling
(setq scroll-conservatively 101)
(setq scroll-margin 0)
(setq scroll-preserve-screen-position t)
(setq auto-window-vscroll nil)

;; Enable pixel-scroll precision mode for smoother scrolling
(unless (and (eq window-system 'mac)
             (bound-and-true-p mac-carbon-version-string))
  (setq pixel-scroll-precision-use-momentum nil)
  (pixel-scroll-precision-mode 1))

;; Window dividers configuration
(window-divider-mode 1)
(setq window-divider-default-bottom-width 1
      window-divider-default-places t
      window-divider-default-right-width 1)

;; Don't stretch cursor for wide characters
(setq x-stretch-cursor nil)

;; No cursor in non-selected windows
(setq-default cursor-in-non-selected-windows nil)
(setq highlight-nonselected-windows nil)

;; From minimal-emacs.d: Better code folding

(use-package outline-indent
  :ensure t
  :custom
  (outline-indent-ellipsis " ▼ ")
  :init
  (add-hook 'python-mode-hook #'outline-indent-minor-mode)
  (add-hook 'python-ts-mode-hook #'outline-indent-minor-mode)
  (add-hook 'yaml-mode-hook #'outline-indent-minor-mode)
  (add-hook 'yaml-ts-mode-hook #'outline-indent-minor-mode))

(use-package
 heroku
 :ensure t
 :defer t
 :bind (:map global-map ("C-c h" . heroku-command-map))
 :commands
 (heroku-list
  heroku-logs
  heroku-restart
  heroku-dynos-kill
  heroku-run-detached
  heroku-run-python
  heroku-run-bash)
 :init
 (define-prefix-command 'heroku-command-map)
 (define-key heroku-command-map (kbd "l") 'heroku-list)
 (define-key heroku-command-map (kbd "s") 'heroku-sql)
 :config
 ;; Function to get app name, falling back to the default
 (defun my/heroku-get-app-name ()
   (or (and (boundp 'heroku-app-name) heroku-app-name)
       (getenv "HEROKU_APP_NAME")
       heroku-default-app))

 ;; Advice to use our custom function
 (advice-add 'heroku-get-app-name :override #'my/heroku-get-app-name)

 :custom
 (heroku-timestamp-regex
  "^[[:digit:]]\\{4\\}-[[:digit:]]\\{2\\}-[[:digit:]]\\{2\\}T[[:digit:]:\+\.]*")
 (heroku-app-name-re "^[[:alnum:]-]*")
 (heroku-region-re "\(\\([[:alnum:]]*\\)\)")
 (heroku-collab-re "[[:alnum:]]*@[[:alnum:]\.-_]*"))

(defun org-src-format-and-save ()
  (interactive)
  (when (provided-mode-derived-p major-mode 'python-base-mode)
    (if (and (boundp 'apheleia-formatter)
             (seq-contains-p apheleia-formatter 'ruff))
        (apheleia-format-buffer 'ruff)
      (apheleia-format-buffer 'black)))
  (when (eq major-mode 'emacs-lisp-mode)
    (elisp-autofmt-buffer))
  (sit-for 0.100)
  (org-edit-src-save))

(use-package
 org
 :defer t
 :hook (org-mode-hook . visual-line-mode)
 :hook (org-babel-after-execute-hook . org-display-inline-images)
 :hook (org-babel-after-execute-hook . append)
 :hook
 (org-mode
  .
  (lambda ()
    (remove-hook
     'completion-at-point-functions #'pcomplete-completions-at-point
     t)
    (remove-hook
     'completion-at-point-functions #'ispell-completion-at-point
     t)))
 :bind
 (:map
  org-mode-map
  ("C-'" . nil)
  ("C-c C-c" . org-ctrl-c-ctrl-c)
  ("C-M-<return>" . my/org-babel-execute-and-next)
  ("C-c <" . nil)
  ("M-g o" . consult-org-heading)
  :map
  org-src-mode-map
  ("C-x C-s" . org-src-format-and-save))
 :config
 (setq org-format-latex-options
       (plist-put org-format-latex-options :scale 2.0))
 (setq org-latex-create-formula-image-program 'dvisvgm)

 (defun my/org-babel-execute-and-next ()
   (interactive)
   (org-babel-execute-src-block)
   (org-babel-next-src-block))

 (org-babel-do-load-languages
  'org-babel-load-languages
  '((emacs-lisp . t)
    (sqlite . t)
    (shell . t)
    (jq . t)
    (jupyter . nil)
    (python . t)))
 ; Needed to make org-babel-jupyter work, want to refresh the kernels to see what is visible in venv
 (defun my/load-org-jupyter ()
   (org-babel-do-load-languages
    'org-babel-load-languages '((jupyter . t)))
   (org-babel-jupyter-aliases-from-kernelspecs 'refresh))
 (visual-line-mode t)

 ; Org-babel stuff
 (setf (alist-get "bash" org-src-lang-modes nil nil #'equal)
       'bash-ts)

 (setq org-log-done t)

 ;; adding this does some weird stuff in colors
 (setq org-startup-indented nil)

 ;; fontify code in code blocks
 (setq org-src-fontify-natively t)
 (setq org-confirm-babel-evaluate nil) ;don't prompt me to confirm everytime I want to evaluate a block
 (setq org-src-preserve-indentation t)

 (defun my-update-direnv-in-org-src ()
   "Update direnv environment variables for org-src buffers."
   (when (and (bound-and-true-p direnv-mode)
              (eq major-mode 'org-mode))
     (let ((org-file-path (buffer-file-name (buffer-base-buffer))))
       (when org-file-path
         (direnv-update-environment org-file-path)))))

 (add-hook 'org-src-mode-hook 'my-update-direnv-in-org-src))

(setq ob-ipython-command "jupyter")
(use-package
 plantuml-mode
 :after org
 :config
 (setq plantuml-default-exec-mode 'executable)
 (setq org-plantuml-exec-mode 'plantuml)
 (add-to-list 'auto-mode-alist '("\\.plantuml\\'" . plantuml-mode)))
(use-package ob-napkin)
(use-package mermaid-mode)
(use-package ob-mermaid)
(use-package htmlize :after org)

(use-package
 org-bullets
 :after org
 :hook (org-mode-hook . org-bullets-mode))
;;nil means to wrap lines in org mode
(setq org-startup-truncated nil)

(use-package org-modern :after org :config (global-org-modern-mode))
(use-package
 org-modern-indent
 :after org
 :straight
 '(org-modern-indent
   :type git
   :host github
   :repo "jdtsmith/org-modern-indent")
 :config
 (setq org-startup-indented t)
 (add-hook 'org-mode-hook #'org-modern-indent-mode 90))

(defun my/dropbox-directory ()
  "Return the absolute path to the user's Dropbox folder on macOS (or fallback)."
  (let* ((info-json-path (expand-file-name "~/.dropbox/info.json"))
         (json-object-type 'alist)
         (json-key-type 'string)
         (json-array-type 'list))
    (if (file-exists-p info-json-path)
        (let* ((json-data (json-read-file info-json-path))
               (personal (cdr (assoc "personal" json-data)))
               (business (cdr (assoc "business" json-data))))
          (or (and personal (cdr (assoc "path" personal)))
              (and business (cdr (assoc "path" business)))
              (expand-file-name "~/Dropbox")))
      (expand-file-name "~/Dropbox"))))

(use-package
 org-roam
 :ensure t
 :custom
 (org-roam-directory
  (file-truename
   (expand-file-name "org-roam" (my/dropbox-directory))))
 :bind
 (("C-c n l" . org-roam-buffer-toggle)
  ("C-c n f" . org-roam-node-find)
  ("C-c n g" . org-roam-graph)
  ("C-c n i" . org-roam-node-insert)
  ("C-c n c" . org-roam-capture)
  ;; Dailies
  ("C-c n j" . org-roam-dailies-capture-today))
 :init
 ;; Delay setting org-id-locations-file until after org-roam is loaded
 (with-eval-after-load 'org-roam
   (setq org-id-locations-file
         (expand-file-name "org-id-locations" org-roam-directory)))
 :config
 ;; Customize node display
 (setq org-roam-node-display-template
       (concat
        "${title:*} " (propertize "${tags:10}" 'face 'org-tag)))

 ;; Sync the database automatically
 (org-roam-db-autosync-mode)

 ;; Generate org-id-locations file if missing
 (unless (file-exists-p org-id-locations-file)
   (message
    "Org-id-locations file not found. Generating a new one...")
   (org-roam-update-org-id-locations))

 ;; Enable org-roam-protocol if available
 (require 'org-roam-protocol))

    (use-package
     zmq
     :straight (zmq :type git :host github :repo "nnicandro/emacs-zmq")
     :config (require 'zmq)
     (defun zmq--download-module (tag)
       (let ((msg "Check%s for compatible module binary to download%s")
             ;; Save original value but don't modify global state
             (original-interactive-value (bound-and-true-p noninteractive))
             (temp-noninteractive t))
         (when (or temp-noninteractive (y-or-n-p (format msg "" "? ")))
           (when temp-noninteractive
             (message msg "ing" ""))
           (catch 'failure
             (let* ((api-url
                     "https://api.github.com/repos/nnicandro/emacs-zmq/")
                    (repo-url "https://github.com/nnicandro/emacs-zmq/")
                    (release-url (concat api-url "releases/"))
                    (info
                     (zmq--download-url
                      (concat release-url tag) (require 'json)
                      (let ((json-object-type 'plist))
                        (ignore-errors
                          (json-read)))))
                    (tag-name
                     (or (plist-get info :tag_name) (throw 'failure nil)))
                    (ezmq-sys
                     (if (and (string-prefix-p
                               "aarch64" system-configuration)
                              (string-match
                               "darwin" system-configuration))
                         "emacs-zmq-arm64-apple-darwin"
                       (concat "emacs-zmq-" (zmq--system-configuration))))
                    (assets
                     (cl-remove-if-not
                      (lambda (x) (string-prefix-p ezmq-sys x))
                      (mapcar
                       (lambda (x) (plist-get x :name))
                       (append (plist-get info :assets) nil)))))
               (when assets
                 (let* ((tgz-file
                         (cl-find-if
                          (lambda (x)
                            (string-suffix-p ".tar.gz" x))
                          assets))
                        (tgz-dir
                         (expand-file-name
                          (substring
                           tgz-file
                           0 (- (length tgz-file) (length ".tar.gz"))))))
                   (zmq--download-and-extract-file
                    (concat
                     repo-url "releases/download/" tag-name)
                    tgz-file)
                   (let* ((pat "emacs-zmq\\.\\(dll\\|so\\|dylib\\)$")
                          (lib (car (directory-files tgz-dir t pat))))
                     (copy-file
                      lib
                      (expand-file-name (file-name-nondirectory lib))))
                   t))))))))
    

    (defun my/zmq-initialize ()
      "Initialize ZMQ by attempting to download the binary, then building if necessary."
      (require 'zmq)
      (unless (featurep 'zmq-core)
        (let ((zmq--subprocess-debug nil)
              (noninteractive t))
          (condition-case err
              (progn
                (message "Attempting to download ZMQ binary...")
                (zmq-load))
            (error
             (message "Failed to download ZMQ binary. Attempting to build locally...")
             (let* ((default-directory (file-name-directory (locate-library "zmq.el")))
                    (emacs (file-truename (expand-file-name invocation-name invocation-directory)))
                    (make-command (concat "make" (when emacs (concat " EMACS=" (shell-quote-argument emacs))))))
               (if (zerop (call-process-shell-command make-command))
                   (progn
                     (message "ZMQ built successfully.")
                     (zmq-load))
                 (message "Failed to build ZMQ: %s" (error-message-string err))
                 (signal (car err) (cdr err)))))))))
    
    (use-package zmq
      :straight '(zmq :host github :repo "nnicandro/emacs-zmq")
      :init
      (my/zmq-initialize))
    

    (use-package
     zmq
     :straight '(zmq :host github :repo "nnicandro/emacs-zmq")
     :config
     ;; Override the zmq-emacs-version constant to "v1.0.1"
     ;; TODO: This is a hack to get zmq to work with the latest version of emacs, eventually i'd undo this
     (defconst zmq-emacs-version "v1.0.1")
     :init
     ; macro to wrap loading
     (defmacro safe-wrap (fn &rest clean-up)
       `(unwind-protect
            (let (retval)
              (condition-case ex
                  (setq retval
                        (progn
                          ,fn))
                ('error
                 (message (format "Caught exception: [%s]" ex))
                 (setq retval (cons 'exception (list ex)))))
              retval)
          ,@clean-up))
    
     (defun fix-zmq-file-naming ()
       "copy .so to .dylib so that we can proceed with installing zmq"
       (let* ((tag (concat "tags/" zmq-emacs-version))
              (api-url
               "https://api.github.com/repos/nnicandro/emacs-zmq/")
              (repo-url "https://github.com/nnicandro/emacs-zmq/")
              (release-url (concat api-url "releases/"))
              (info
               (zmq--download-url
                (concat release-url tag) (require 'json)
                (let ((json-object-type 'plist))
                  (ignore-errors
                    (json-read)))))
              (tag-name
               (or (plist-get info :tag_name) (throw 'failure nil)))
              (ezmq-sys (concat "emacs-zmq-" (zmq--system-configuration)))
              (assets
               (cl-remove-if-not
                (lambda (x) (string-prefix-p ezmq-sys x))
                (mapcar
                 (lambda (x) (plist-get x :name))
                 (append (plist-get info :assets) nil)))))
         (when assets
           (let ((default-directory
                  (file-name-directory (locate-library "zmq"))))
             ;; We have a signature file and a tar.gz file for each binary so the
             ;; minimum number of files is two.
             (if (> (length assets) 2)
                 (error "TODO More than one file found")
               (let* ((tgz-file
                       (cl-find-if
                        (lambda (x) (string-suffix-p "tar.gz" x)) assets))
                      (lib
                       (expand-file-name (concat
                                          "emacs-zmq" module-file-suffix)
                                         (expand-file-name
                                          (file-name-sans-extension
                                           (file-name-sans-extension
                                            tgz-file))))))
                 (let* ((source-file
                         (concat (file-name-sans-extension lib) ".so")))
                   (when (not (f-exists? lib))
                     (print (format "Copy from %s to %s" source-file lib))
                     (copy-file source-file lib)))
                 t))))))
    
     (let ((was-interactive (not (bound-and-true-p noninteractive))))
       ;; Use cl-letf to temporarily bind noninteractive without global side effects
       (cl-letf (((symbol-value 'noninteractive) t))
         (safe-wrap
          (condition-case nil
              (require 'zmq)
            (error
             (fix-zmq-file-naming)
             (require 'zmq))))))
    

    (defun zmq--download-module-test (tag)
      (let ((msg "Check%s for compatible module binary to download%s"))
        (message "Starting zmq--download-module with tag: %s" tag)
        (when (or noninteractive (y-or-n-p (format msg "" "? ")))
          (when noninteractive
            (message msg "ing" ""))
          (let* ((api-url "https://api.github.com/repos/nnicandro/emacs-zmq/")
                 (repo-url "https://github.com/nnicandro/emacs-zmq/")
                 (release-url (concat api-url "releases/"))
                 (info (progn
                         (message "Fetching release info from: %s" (concat release-url tag))
                         (zmq--download-url (concat release-url tag)
                                            (require 'json)
                                            (let ((json-object-type 'plist))
                                              (ignore-errors (json-read))))))
                 (tag-name (or (plist-get info :tag_name)
                               (error "Tag name not found in release info")))
                 (ezmq-sys (concat "emacs-zmq-" (zmq--system-configuration)))
                 (assets (cl-remove-if-not
                          (lambda (x)
                            (string-prefix-p ezmq-sys x))
                          (mapcar (lambda (x) (plist-get x :name))
                                  (append (plist-get info :assets) nil)))))
            (message "Release tag name: %s" tag-name)
            (message "System configuration for emacs-zmq: %s" ezmq-sys)
            (message "Expected system configuration: %s" ezmq-sys)
            (message "Assets fetched: %s" assets)
            (if (not assets)
                (error "No assets found matching system configuration")
              (if (> (length assets) 2)
                  (error "More than one file found, need manual selection")
                (let* ((tgz-file (cl-find-if (lambda (x) (string-suffix-p ".tar.gz" x))
                                             assets))
                       (tgz-dir (expand-file-name
                                 (substring tgz-file 0 (- (length tgz-file)
                                                          (length ".tar.gz"))))))
                  (message "Downloading and extracting: %s" tgz-file)
                  (zmq--download-and-extract-file
                   (concat repo-url "releases/download/" tag-name) tgz-file)
                  (let* ((pat "emacs-zmq\\.\\(dll\\|so\\|dylib\\)$")
                         (lib (car (directory-files tgz-dir t pat))))
                    (message "Library file found: %s" lib)
                    (copy-file lib (expand-file-name (file-name-nondirectory lib))))
                  t)))))))
    (zmq--download-module-test (concat "tags/" zmq-emacs-version))
    

(use-package
 jupyter
 :demand t
 :custom (jupyter-repl-echo-eval-p t)
 :config
 (defun my-org-babel-jupyter-use-python-ts-mode (&rest _)
   "Set python-ts-mode for jupyter-python in org-src-lang-modes."
   (setf (alist-get "jupyter-python" org-src-lang-modes
                    nil
                    nil
                    #'equal)
         "python-ts"))
 (advice-add
  'org-babel-jupyter-make-local-aliases
  :after #'my-org-babel-jupyter-use-python-ts-mode))

(use-package ox-jekyll-md :init (setq org-jekyll-md-include-yaml-front-matter nil))

(use-package
 ox-jekyll-lite
 :after org
 :straight
 '(ox-jekyll-lite
   :type git
   :host github
   :repo "jsigman/ox-jekyll-lite"))

(use-package
 org-appear
 :straight
 '(org-appear :type git :host github :repo "awth13/org-appear")
 :after org
 :hook (org-mode-hook . org-appear-mode))

(use-package request)
(use-package
 org-ref
 :after org
 :config
 (setq org-latex-pdf-process
       (list "latexmk -shell-escape -bibtex -f -pdf %f")))

(use-package
 magit
 :demand t
 :init
 (setq magit-delete-by-moving-to-trash nil)
 :bind
 (:map
  magit-mode-map
  ("C-x g" . nil)
  ("M-G" . nil)
  ("M-0" . nil)
  ("M-1" . nil)
  ("M-2" . nil)
  ("M-3" . nil))
 :bind (:map global-map ("M-G" . magit-status))
 :config (use-package transient))

(use-package
 forge
 :after magit
 :config
 ; This is so we can access forge information
 (setq auth-sources '("~/.authinfo.gpg"))
 (setq epa-pinentry-mode 'loopback)
 (setq forge-status-buffer-default-topic-filters
       (forge--topics-spec
        :type 'pullreq
        :active t
        :state 'open
        :order 'newest)))
(use-package ghub :defer t)

;; Set up the llm package
(use-package llm :straight t :custom (llm-warn-on-nonfree nil))

;; Configure the Ollama provider
(use-package
 forge-llm
 :straight (:host gitlab :repo "rogs/forge-llm")
 :after forge
 :custom
 ;; These settings can still be set immediately
 (forge-llm-temperature 0.2) (forge-llm-max-tokens 1000)
 :config
 ;; This runs after both the package and custom.el are loaded
 (setq forge-llm-llm-provider
       (lambda ()
         (require 'llm-ollama)
         (llm-ollama-make-provider
          :chat-model
          (car
           (plist-get minuet-openai-fim-compatible-options :model))
          :default-chat-temperature 0.2)))
 (forge-llm-setup))

(use-package
 magit-todos
 :straight t
 :after magit
 :hook (magit-mode . magit-todos-mode)
 :config
 (setq magit-todos-scanner 'magit-todos--scan-with-rg)
 (setq magit-todos-keywords '("TODO" "FIXME" "BUG" "HACK"))
 (setq magit-todos-ignore-case t)
 (setq magit-todos-search-regexp "\\b(TODO|FIXME|BUG|HACK)\\b")
 (setq magit-todos-keyword-suffix "")
 (magit-todos-mode 1))

(require 'magit)

(defface magit-todos-line-number
  '((t :inherit magit-filename :weight bold))
  "Face for line numbers in Magit-Todos."
  :group 'magit-faces)

(defvar magit-todos-debug nil
  "Enable debug messages for magit-todos.")

(defun magit-todos-debug-message (format-string &rest args)
  "Print a debug message if `magit-todos-debug' is non-nil."
  (when magit-todos-debug
    (apply #'message
           (concat "magit-todos debug: " format-string)
           args)))

(defun magit-todos-jump-to-file (file line-number)
  "Jump to FILE at LINE-NUMBER."
  (magit-todos-debug-message "Jumping to %s:%s" file line-number)
  (let ((full-path (expand-file-name file (magit-toplevel))))
    (if (file-exists-p full-path)
        (progn
          (find-file full-path)
          (goto-char (point-min))
          (forward-line (1- line-number)))
      (message "File not found: %s" full-path))))

(defun magit-todos-jump-to-todo ()
  "Jump to the TODO at point."
  (interactive)
  (let ((file (get-text-property (point) 'magit-todos-file))
        (line-number (get-text-property (point) 'magit-todos-line)))
    (magit-todos-debug-message
     "magit-todos-jump-to-todo called with %s:%s"
     file line-number)
    (if (and file line-number)
        (magit-todos-jump-to-file file line-number)
      (magit-todos-debug-message
       "No file or line number found at point"))))

(defun magit-insert-todos ()
  "Insert a section for TODOs found in comments."
  (magit-todos-debug-message "Inserting TODOs section")
  (magit-insert-section
   (todos) (magit-insert-heading "TODOs")
   (let* ((root (magit-toplevel))
          (todos-output
           (shell-command-to-string
            (concat "rg --vimgrep '(#|//|;|<!--)\\s*TODO' " root)))
          (todos-list '()))
     (magit-todos-debug-message "Found %d lines of TODOs"
                                (length
                                 (split-string todos-output "\n" t)))
     ;; Parse and collect todos
     (dolist (line (split-string todos-output "\n" t))
       (when (string-match
              "\\([^:]+\\):\\([0-9]+\\):\\([0-9]+\\):\\(.*\\)" line)
         (let ((file (file-relative-name (match-string 1 line) root))
               (line-number (string-to-number (match-string 2 line)))
               (content (match-string 4 line)))
           (push (list file line-number content) todos-list))))
     ;; Sort todos by filename and line number
     (setq todos-list
           (sort todos-list
                 (lambda (a b)
                   (or (string< (car a) (car b))
                       (and (string= (car a) (car b))
                            (< (cadr a) (cadr b)))))))
     (magit-todos-debug-message "Sorted %d TODOs" (length todos-list))
     ;; Insert sorted todos
     (dolist (todo todos-list)
       (let* ((file (nth 0 todo))
              (line-number (nth 1 todo))
              (content (nth 2 todo))
              (todo-string
               (concat
                (propertize file 'face 'magit-filename) ":"
                (propertize (number-to-string line-number)
                            'face 'magit-todos-line-number)
                ": " content)))
         (magit-insert-section
          (todo)
          (insert
           (propertize todo-string
                       'magit-todos-file
                       file
                       'magit-todos-line
                       line-number
                       'keymap
                       (let ((map (make-sparse-keymap)))
                         (define-key
                          map (kbd "RET") 'magit-todos-jump-to-todo)
                         (define-key
                          map [mouse-1] 'magit-todos-jump-to-todo)
                         map)
                       'mouse-face
                       'highlight
                       'help-echo
                       "mouse-1 or RET: visit this TODO"))
          (insert "\n") (magit-insert-heading)))))))

(define-minor-mode magit-todos-mode
  "Display TODOs in Magit status using rg."
  :lighter " Magit-Todos"
  :global
  t
  (if magit-todos-mode
      (magit-todos-mode-enable)
    (magit-todos-mode-disable)))

(defun magit-todos-mode-enable ()
  "Enable Magit-Todos integration."
  (magit-todos-debug-message "Enabling magit-todos-mode")
  (add-hook 'magit-status-sections-hook 'magit-insert-todos t))

(defun magit-todos-mode-disable ()
  "Disable Magit-Todos integration."
  (magit-todos-debug-message "Disabling magit-todos-mode")
  (remove-hook 'magit-status-sections-hook 'magit-insert-todos))

(provide 'magit-todos)

;;; magit-todos.el ends here

;; Automatically enable the mode
(magit-todos-mode 1)

(use-package
 git-gutter
 :straight t
 :config
 ;; Add a special mode for TRAMP buffers
 (defun my/tramp-file-mode ()
   "Mode for TRAMP files."
   (when (file-remote-p (or buffer-file-name default-directory))
     (setq-local mode-name "TRAMP")))

 ;; Add this mode to git-gutter's disabled modes
 (add-to-list 'git-gutter:disabled-modes 'my/tramp-file-mode)

 ;; Add the mode to remote files
 (add-hook 'find-file-hook #'my/tramp-file-mode)

 ;; Rest of your configuration
 (global-git-gutter-mode t)
 (setq git-gutter:modified-sign "  ")
 (setq git-gutter:added-sign "+")
 (setq git-gutter:deleted-sign "-")
 (set-face-foreground 'git-gutter:modified "magenta")
 (set-face-foreground 'git-gutter:added "dark green")
 (set-face-foreground 'git-gutter:deleted "red")

 ;; Optional: Increase the verbosity for debugging
 (setq git-gutter:verbosity 4))

(use-package
 git-gutter+
 :config (global-git-gutter+-mode t)

 (setq git-gutter+-modified-sign " ") ;; two space
 (setq git-gutter+-added-sign "+") ;; multiple character is OK
 (setq git-gutter+-deleted-sign "-")

 (set-face-foreground 'git-gutter+-modified "magenta")
 (set-face-foreground 'git-gutter+-added "dark green")
 (set-face-foreground 'git-gutter+-deleted "red"))

; add this so that git gutter plus does not screw up tramp sessions
; it disables GGP during tramp
(defun git-gutter+-refresh ()
  (git-gutter+-clear)
  (when (not (file-remote-p (buffer-file-name)))
    (let ((file (buffer-file-name)))
      (when (and file (file-exists-p file))
        (if (file-remote-p file)
            (let* ((repo-root (git-gutter+-root-directory file))
                   (default-directory
                    (git-gutter+-remote-default-directory
                     repo-root file)))
              (git-gutter+-process-diff
               (git-gutter+-remote-file-path repo-root file)))
          (git-gutter+-process-diff
           (git-gutter+-local-file-path file)))))))

(use-package
 diff-hl
 :config (global-diff-hl-mode)
 (add-hook 'magit-pre-refresh-hook 'diff-hl-magit-pre-refresh)
 (add-hook 'magit-post-refresh-hook 'diff-hl-magit-post-refresh))

(use-package
 ediff
 :defer t
 :init (setq ediff-split-window-function 'split-window-horizontally)
 (setq ediff-window-setup-function
       'ediff-setup-windows-plain)
 (setq ediff-diff-options "-w"))

(use-package
 treemacs
 :bind (("M-P" . treemacs))
 :config (setq treemacs-persist-file "treemacs-persist"))

(use-package treemacs-projectile)

(use-package
 treemacs-icons-dired
 :config
 (defun my/maybe-enable-treemacs-icons ()
   (unless (file-remote-p default-directory)
     (treemacs-icons-dired-mode)))
 (add-hook 'dired-mode-hook #'my/maybe-enable-treemacs-icons))

;; Treat all themes as safe; no query before use.
(setf custom-safe-themes 't)
(setq frame-title-format nil)

(use-package leuven-theme
  :config
  (load-theme 'leuven-dark t))

(use-package
 catppuccin-theme
 :config
 (load-theme 'catppuccin :no-confirm)
 (setq catppuccin-flavor 'frappe)
 (catppuccin-reload))

(use-package ef-themes :config (load-theme 'ef-day t))

(use-package
 gruvbox-theme
 :ensure t
 :config (load-theme 'gruvbox-dark-hard :no-confirm)
 ;; :after (centered-window-mode) :hook (centered-window-mode . cwm-update-fringe-background)
)

(use-package
 nano
 :straight
 (nano-emacs :type git :host github :repo "rougier/nano-emacs")
 :config (require 'nano))

(use-package rainbow-mode :hook (LaTeX-mode . rainbow-mode))
(use-package dired-hacks :hook (emacs-lisp-mode . rainbow-mode))

(add-hook 'emacs-startup-hook
          (lambda ()
            (when (fboundp 'cwm-update-fringe-background)
              (cwm-update-fringe-background))))