init-evil.el

(use-package undo-tree :ensure t)

(use-package evil
  :ensure t
  :init
  (setq evil-want-C-i-jump nil)
  (setq evil-want-integration t)
  (setq evil-want-keybinding nil)
  :config
  (require 'undo-tree)
  (evil-mode 1)
  (evil-set-undo-system 'undo-tree)

  (defun minibuffer-keyboard-quit ()
    (interactive)
    (if (and delete-selection-mode transient-mark-mode mark-active)
	(setq deactivate-mark  t)
      (when (get-buffer "*Completions*") (delete-windows-on "*Completions*"))
      (abort-recursive-edit)))

  (defun amir/visual-select-end-of-block ()
    (interactive)
    (evil-insert-state)
    (evil-next-line)
    (ruby-beginning-of-block)
    (evil-visual-line)
    (ruby-end-of-block))

  (evil-define-operator evil-replace-and-indent (beg end type)
    :motion nil
    (interactive "<R>")
    (save-excursion
      (goto-char beg)
      (while (search-forward "," end t)
        (replace-match ",\n" nil t))
      (evil-indent beg end)))

  (define-key evil-visual-state-map (kbd "g RET") 'evil-replace-and-indent)
  (define-key evil-insert-state-map (kbd "C-G") 'copilot-accept-completion-by-line)
  (define-key evil-normal-state-map [escape] 'keyboard-quit)
  (define-key evil-visual-state-map [escape] 'keyboard-quit)
  (define-key minibuffer-local-map [escape] 'minibuffer-keyboard-quit)
  (define-key minibuffer-local-ns-map [escape] 'minibuffer-keyboard-quit)
  (define-key minibuffer-local-completion-map [escape] 'minibuffer-keyboard-quit)
  (define-key minibuffer-local-must-match-map [escape] 'minibuffer-keyboard-quit)
  (define-key minibuffer-local-isearch-map [escape] 'minibuffer-keyboard-quit)
  (define-key evil-normal-state-map (kbd "g s") 'amir/switch-to-scratch-buffer)
  (define-key evil-normal-state-map (kbd "g o") 'evil-goto-definition)
  (define-key evil-normal-state-map (kbd "g j") 'ruby-end-of-block)
  (define-key evil-normal-state-map (kbd "g k") 'ruby-beginning-of-block)
  (define-key evil-normal-state-map (kbd "g c") 'breadcrumb-jump)
  (define-key evil-visual-state-map (kbd "g j") 'ruby-end-of-block)
  (define-key evil-visual-state-map (kbd "g k") 'ruby-beginning-of-block)
  (global-set-key [escape] 'evil-exit-emacs-state)

  ;; mapping for ctrl-r in insert mode
  (defun amir/evil-paste-from-register (orig-fun &rest args)
    (interactive)
    (if (copilot--overlay-visible)
	(call-interactively 'copilot-accept-completion)
        (apply orig-fun args)))

  ;; mapping for ctrl-w in insert mode
  (defun amir/evil-delete-backward-word (orig-fun &rest args)
    (interactive)
    (if (copilot--overlay-visible)
	(call-interactively 'copilot-accept-completion-by-word)
        (apply orig-fun args)))

  (advice-add 'evil-paste-from-register :around #'amir/evil-paste-from-register)
  (advice-add 'evil-delete-backward-word :around #'amir/evil-delete-backward-word)

  (defun amir/evil-search-word-forward ()
    (interactive)
    (evil-search-word-forward)
    (evil-search-previous))

  (with-eval-after-load 'evil-maps
    (define-key evil-visual-state-map "," nil)
    (define-key evil-normal-state-map "," nil)
    (define-key evil-motion-state-map (kbd "*") 'amir/evil-search-word-forward))


  ;; (defun amir/copilot-next-completion ()
  ;;   (interactive)
  ;;   (if (copilot--overlay-visible)
  ;; 	(call-interactively #'copilot-next-completion)
  ;;       (call-interactively #'copilot-complete)))

  ;; (defun amir/copilot-previous-completion ()
  ;;   (interactive)
  ;;   (if (copilot--overlay-visible)
  ;; 	(call-interactively #'copilot-previous-completion)
  ;;       (call-interactively #'copilot-complete)))

  (eval-after-load 'dired
    '(progn
       (customize-set-variable 'copilot-enable-predicates '(evil-insert-state-p))
       ;; (evil-define-key 'insert copilot-mode-map (kbd "C-n") #'amir/copilot-next-completion)
       ;; (evil-define-key 'insert copilot-mode-map (kbd "C-N") #'amir/copilot-previous-completion)
       (define-key dired-mode-map (kbd "n") nil)
       (define-key dired-mode-map (kbd "g") nil)
       (define-key dired-mode-map (kbd "G") nil)
       (define-key dired-mode-map (kbd "C-r") 'revert-buffer))))

(use-package evil-terminal-cursor-changer
  :ensure t
  :init
  (evil-terminal-cursor-changer-activate)
  (setq evil-motion-state-cursor 'box)
  (setq evil-visual-state-cursor 'box)
  (setq evil-normal-state-cursor 'box)
  (setq evil-insert-state-cursor 'bar)
  (setq evil-emacs-state-cursor  'hbar))

(use-package evil-collection
  :ensure t
  :after evil
  :config
  (evil-collection-init))

(use-package evil-leader
  :ensure t
  :config

  (global-evil-leader-mode)
  (evil-leader/set-leader "SPC")
  (evil-leader/set-key
    "h" 'magit-log-buffer-file
    "TAB" 'amir/resize-equal
    "z" 'amir/zoom-buffer
    "t" 'amir/touch
    "o" 'org-open-at-point
    "r" 'roam
    "f" 'next-error
    "d" 'previous-error
    "b" 'ido-switch-buffer
    "c" 'comment-dwim
    "j" 'avy-goto-line
    "W" 'avy-goto-word-1-above
    "w" 'avy-goto-word-1-below
    "g" 'amir/find-file
    "s" 'magit-status
    "S" 'ssl
    "." 'ido-dired
    "v" 'swiper-all
    "q" 'amir/previous-code-buffer
    "m" 'amir/split-and-find
    "e" 'amir/narrow-to-region-indirect
    "C-r" 'redo-region
    "p" 'amir/next-code-buffer))

(use-package evil-surround
  :ensure t
  :config
  (global-evil-surround-mode 1))

(use-package evil-exchange
  :ensure t
  :config
  (evil-exchange-install))

(load "~/.emacs.d/custom-packages/evil-tmux-navigator/navigate.el")
(require 'navigate)

(load "~/.emacs.d/custom-packages/org-modern-indent/org-modern-indent.el")
(require 'org-modern-indent)

init-functions.el

(defmacro alias (from to)
  `(defun ,from ()
     (interactive)
     (call-interactively #',to)))

(defmacro foreach (i list &rest body)
  `(dolist (,i ,list)
     ,@body))

(defmacro call-i (name)
  `(call-interactively #',name))

(alias er eval-region)
(alias dk describe-key)
(alias ctags visit-tags-table)
(alias pic projectile-invalidate-cache)
(alias ic projectile-invalidate-cache)
(alias ap ag-project)
(alias df describe-function)
(alias roam org-roam-node-find)
(alias eb eval-buffer)
(alias ee eval-expression)
(alias ele amir/eval-last-sexp)
(alias es org-edit-special)
(alias chat gptel)
(alias afm auto-fill-mode)
(alias artm auto-revert-tail-mode)
(alias lspd lsp-disconnect)

(defun uv ()
  (interactive)
  (call-interactively #'undo-tree-visualize)
  (call-interactively #'undo-tree-visualizer-toggle-diff))

(defun cm ()
  (interactive)
  (call-interactively #'company-mode)
  (call-interactively #'copilot-mode)
  (call-interactively #'company-mode))

(defun dc ()
  (interactive)
  ;; if hl-line-mode is on, turn it off
  (when hl-line-mode
    (hl-line-mode -1))
  (call-interactively #'describe-char)
  ;; turn hl-line-mode back on if it was on
  (when (bound-and-true-p hl-line-mode)
    (hl-line-mode 1)))

(defun ss ()
  (interactive)
  (let* ((prompt (read-string "input: "))
	 (prompt-escaped (shell-quote-argument prompt))
	 (ss-result (shell-command-to-string (concat "~/how-do-i.rb " prompt-escaped))))
    (progn (kill-new ss-result)
	   (message ss-result))))

(defun ssl ()
  (interactive)
  (let* ((prompt (string-trim (buffer-substring (line-beginning-position) (line-end-position))))
	 (prompt-escaped (shell-quote-argument prompt))
	 (language (car (split-string (symbol-name major-mode))))
	 (ss-result (shell-command-to-string (concat "~/how-do-i.rb " language " " prompt-escaped))))
    (progn (kill-new (concat "\n" ss-result))
	   (call-interactively #'evil-last-non-blank)
	   (call-interactively #'evil-paste-after)
	   (message ss-result))))

(defun my-fancy-run-command ()
  (interactive)
  (shell-command-to-string "echo hello world"))

(defun cfp ()
  "Copy the current buffer file name to the clipboard."
  (interactive)
  (let ((filename (if (equal major-mode 'dired-mode)
                      default-directory
                    (buffer-file-name))))
    (when filename
      (kill-new filename)
      (message "Copied buffer file name '%s' to clipboard." filename))))

(defun wipel ()
  (interactive)
  (evil-edit "~/.emacs.d"))


(defun touch ()
  (interactive)
  (call-interactively #'dired-create-empty-file)
  (call-interactively #'projectile-invalidate-cache))

(defun amir/find-file ()
  (interactive)
  (dired ".")
  (projectile-find-file))

(defun amir/split-and-find ()
  "Opens a new split window and brings up dired so I can search."
  (interactive)
  (evil-window-vsplit)
  (dired ".")
  (projectile-find-file))

(defun amir/turn-on-show-trailing-whitespace ()
  (interactive)
  (setq show-trailing-whitespace t))

(defun amir/touch ()
  "Run touch command on current file."
  (interactive)
  (when buffer-file-name
    (shell-command (concat "touch " (shell-quote-argument buffer-file-name)))
    (clear-visited-file-modtime)))

(defun kill_dr ()
  (interactive)
  (shell-command "ruby ~/projects/zrb/main.rb --function kill_dr"))

(defun amir/zoom-buffer ()
  (interactive)
  (progn
    (evil-window-set-width (frame-width))
    (evil-window-set-height (frame-height))
    (redraw-display)))

(defun amir/resize-equal ()
  (interactive)
  (balance-windows)
  (redraw-display))

(defun rb ()
  (interactive)
  (revert-buffer))

(defun amir/next-code-buffer ()
  (interactive)
  (let (( bread-crumb (buffer-name) ))
    (next-buffer)
    (while
	(and
	 (string-match-p "^\*" (buffer-name))
	 (not ( equal bread-crumb (buffer-name) )) )
      (next-buffer))))

(defun amir/previous-code-buffer ()
  (interactive)
  (let (( bread-crumb (buffer-name) ))
    (previous-buffer)
    (while
	(and
	 (string-match-p "^\*" (buffer-name))
	 (not ( equal bread-crumb (buffer-name) )) )
      (previous-buffer))))

(defun amir/narrow-to-region-indirect (start end)
  "Restrict editing in this buffer to the current region, indirectly."
  (interactive "r")
  (deactivate-mark)
  (let ((buf (clone-indirect-buffer nil nil)))
    (with-current-buffer buf
      (narrow-to-region start end))
    (switch-to-buffer buf))
  (call-i evil-goto-first-line)
  (rename-buffer (string-trim (thing-at-point 'line))))

(defun amir/eval-last-sexp ()
  (interactive)
  (call-i evil-forward-sentence-begin)
  (call-i evil-append)
  (call-i eval-last-sexp)
  (call-i evil-normal-state))

(defun amir/switch-to-scratch-buffer ()
  (interactive)
  (switch-to-buffer "*scratch*"))

init-general.el

(use-package general
  :ensure t
  :config
  (general-evil-setup t)

  (general-create-definer comma-leader :prefix ",")

  (defun amir/lispy-slurp-at-line-end ()
    (interactive)
    (let ((char-under-cursor (string (char-after))))
      (if (evil-eolp)
	  (progn
	    (call-interactively #'evil-append)
	    (call-interactively #'lispy-slurp)
	    (call-interactively #'evil-normal-state)
	    (call-interactively #'evil-forward-char))
	(progn
	  (call-interactively #'lispy-slurp)))))

  (defun amir/lispy-add-parens-at-end ()
    (interactive)
    (call-interactively #'lispy-right)
    (call-interactively #'evil-append)
    (call-interactively #'lispy-parens)
    (call-interactively #'evil-normal-state))

  (defun amir/org-insert-heading-after-current ()
    (interactive)
    (call-interactively #'org-insert-heading-after-current)
    (call-interactively #'evil-insert))

  (defun amir/org-insert-heading ()
    (interactive)
    (call-interactively #'org-insert-heading)
    (call-interactively #'evil-insert))

  (comma-leader
   :keymaps 'normal
   "o h" 'amir/org-insert-heading-after-current
   "o H" 'amir/org-insert-heading
   "l w" 'lispy-ace-paren
   "l s" 'lispy-slurp
   "l a" 'amir/lispy-slurp-at-line-end
   "l (" 'amir/lispy-add-parens-at-end
   "l b" 'lispy-barf))

init.el

(require 'package)

(push '("melpa" . "http://melpa.org/packages/") package-archives)
(push '("org" . "http://orgmode.org/elpa/") package-archives)
(push '("melpa-stable" . "https://stable.melpa.org/packages/") package-archives)

(package-initialize)

(unless package-archive-contents (package-refresh-contents))

(unless (package-installed-p 'use-package) (package-install 'use-package))

(use-package atom-one-dark-theme
  :ensure t
  :init
  (load-theme 'atom-one-dark t))

(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))

(straight-use-package 'use-package)

(load "~/.emacs.d/init-evil.el")
(load "~/.emacs.d/init-functions.el")
(load "~/.emacs.d/init-company.el")
(load "~/.emacs.d/init-general.el")
(load "/Users/amiralirajan/projects/llvm-project/llvm/utils/emacs/tablegen-mode.el")


(use-package undo-tree
  :defer
  :ensure t
  :config
  (global-undo-tree-mode)
  (setq undo-tree-auto-save-history t)
  (setq undo-tree-history-directory-alist '(("." . "~/.emacs.d/undo"))))

(use-package editorconfig
  :ensure t
  :config
  (global-undo-tree-mode)
  (global-hl-line-mode)
  (editorconfig-mode 1)
  (menu-bar-mode -1)
  (setq inhibit-splash-screen t)
  (setq-default truncate-lines t)
  (setq create-lock-files nil)
  (setq backup-directory-alist '(("." . "~/.emacs.d/backups")))
  (setq backup-by-copying t)

  ;; (setq major-mode-remap-alist
  ;; 	'((ruby-mode . ruby-ts-mode)))

  (setq
   backup-by-copying t     ; don't clobber symlinks
   kept-new-versions 10    ; keep 10 latest versions
   kept-old-versions 10    ; don't bother with old versions
   delete-old-versions t   ; don't ask about deleting old versions
   version-control t       ; number backups
   vc-make-backup-files t) ; backup version controlled files
  (setq auto-save-file-name-transforms '((".*" "~/.emacs.d/auto-save-list/" t)))
  (setq large-file-warning-threshold 20000000)
  (global-display-line-numbers-mode)
  (add-hook 'emacs-lisp-mode-hook     #'(lambda () (modify-syntax-entry ?- "w")))
  (add-hook 'ruby-mode-hook  #'(lambda ()
				 (progn
                                   (setq tab-width 8)
				   (hl-line-mode)
				   (modify-syntax-entry ?_ "w"))))
  (add-hook 'c-mode-hook     #'(lambda ()
				 (setq tab-width 2)
				 (modify-syntax-entry ?_ "w")))
  (add-hook 'c-mode-hook     #'(lambda () (modify-syntax-entry ?_ "w")))
  (add-hook 'c++-mode-hook   #'(lambda () (modify-syntax-entry ?_ "w")))
  (add-hook 'lua-mode-hook   #'(lambda () (modify-syntax-entry ?_ "w")))
  (add-hook 'objc-mode-hook  #'(lambda () (modify-syntax-entry ?_ "w")))
  (add-hook 'cmake-mode-hook  #'(lambda () (modify-syntax-entry ?_ "w")))
  (add-hook 'scheme-mode-hook  #'(lambda ()
                                   (paredit-mode 1)
                                   (rainbow-delimiters-mode 1)
                                   (lispy-mode 1)))
  (add-hook 'dired-mode-hook
            (lambda ()
              (dired-hide-details-mode)))
  ;; (add-hook 'before-save-hook 'delete-trailing-whitespace)
  (add-hook 'prog-mode-hook #'(lambda ()
				(progn
				  (amir/turn-on-show-trailing-whitespace))))

  (savehist-mode)
  (add-to-list 'auto-mode-alist '("\\.html\\'" . web-mode)))

(use-package projectile
  :defer
  :ensure t
  :config
  (projectile-global-mode)
  (setq projectile-indexing-method 'hybrid)
  (setq projectile-enable-caching t)
  (add-to-list 'projectile-globally-ignored-directories "node_modules")
  (add-to-list 'projectile-globally-ignored-files "*.png"))

(use-package osx-clipboard
  :ensure t
  :config
  (osx-clipboard-mode 1))

(use-package avy
  :defer
  :ensure t
  :config
  (setq avy-styles-alist '((avy-goto-word-0 . at-full) (avy-goto-line . at-full)))
  (setq avy-all-windows nil))

(use-package ido
  :ensure t
  :config
  (ido-mode 1)
  (ido-everywhere 1)

  (defun vim-like-ido-keys ()
    "Add vim like keybindings for ido."
    (define-key ido-completion-map (kbd "<down>") 'ido-next-match)
    (define-key ido-completion-map (kbd "C-n") 'ido-next-match)
    (define-key ido-completion-map (kbd "C-j") 'ido-next-match)
    (define-key ido-completion-map (kbd "C-p") 'ido-prev-match)
    (define-key ido-completion-map (kbd "C-k") 'ido-prev-match)
    (define-key ido-completion-map (kbd "<up>") 'ido-prev-match))

  (add-hook 'ido-setup-hook 'vim-like-ido-keys))

(use-package ido-vertical-mode
  :ensure t
  :config
  (ido-vertical-mode 1))

(use-package flx-ido
  :ensure t
  :config
  (flx-ido-mode 1)
  (setq ido-enable-flex-matching t)
  (setq ido-use-faces t)
  (setq ido-enable-flex-matching t))

(use-package cmake-mode :defer :ensure t)
(use-package paredit :defer :ensure t)
(use-package ag :defer :ensure t)
(use-package magit :defer :ensure t :defer 3)
(use-package ruby-mode :defer :ensure t)

(use-package ivy
  :ensure t
  :config
  (ivy-mode 1)
  (define-key ivy-minibuffer-map (kbd "C-n") nil)
  (define-key ivy-minibuffer-map (kbd "C-j") 'ivy-next-line)
  (define-key ivy-minibuffer-map (kbd "C-p") nil)
  (define-key ivy-minibuffer-map (kbd "C-k") 'ivy-previous-line)
  (setq ivy-re-builders-alist
        '((t . ivy--regex-fuzzy)))

  (setq ivy-use-virtual-buffers t)
  (setq ivy-count-format "(%d/%d) ")

  (defun my-action-1 (x)
    "action one was invoked")

  (defun my-action-2 (x)
    (message "action-2: %s" x))

  (defun my-action-3 (x)
    (message "action-3: %s" x))

  ;; This is a sample function that shows the power of
  ;; Ivy. This method can be invoked via M-x / :.
  ;; Once invoked, it will present an auto complete list
  ;; with three values: foo bar baz.
  ;; On selecting a value, the respective `action(x)` callback
  ;; will be invoked with the string value they entered.
  (defun my-command-with-3-actions ()
    (interactive)
    (ivy-read "test: "
              '("foo" "bar" "baz")
              :action
              (lambda (x)
                (cond
                 ((string= x "foo") (message "foo was called"))
                 ((string= x "bar") (message "bar was called"))
                 ((string= x "baz") (message "baz was called"))
                 (t (message "no match")))))))

(use-package org-roam
  :defer
  :ensure t
  :init
  (setq org-roam-directory (file-truename "~/.life"))
  :config
  (org-roam-db-autosync-mode))

(use-package yasnippet
  :ensure t
  :config
  (yas-global-mode 1))

(use-package ws-butler
  :ensure t
  :init
  (ws-butler-global-mode))

(use-package swiper :ensure t :defer)
(use-package org-modern :ensure t :defer)
(use-package web-mode :ensure t :defer
  :config
  (setq web-mode-markup-indent-offset 2))

(use-package gptel :ensure t :defer
  :config
  (add-hook 'gptel-mode-hook 'visual-line-mode))

(use-package dumb-jump :ensure t :defer)

(use-package copilot
  :straight (:host github :repo "copilot-emacs/copilot.el" :files ("dist" "*.el"))
  :ensure t
  :config
  (define-key copilot-mode-map (kbd "C-p") 'copilot-previous-completion)
  (define-key copilot-mode-map (kbd "C-n") 'copilot-next-completion)
  (define-key copilot-mode-map (kbd "C-g") 'copilot-clear-overlay))

(use-package breadcrumb
  :ensure t
  :config
  (breadcrumb-mode 1))

(load "~/.emacs.d/custom-packages/metal-mode/metal-mode.el")
(require 'metal-mode)

(custom-set-variables
 ;; custom-set-variables was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 '(Info-breadcrumbs-depth 0)
 '(beacon-blink-duration 1.0)
 '(beacon-blink-when-buffer-changes t)
 '(beacon-blink-when-focused t)
 '(beacon-blink-when-point-moves-horizontally nil)
 '(beacon-blink-when-point-moves-vertically 10)
 '(beacon-blink-when-window-changes t)
 '(beacon-color "#f8f8ff")
 '(beacon-dont-blink-major-modes nil)
 '(beacon-size 40)
 '(blink-cursor-mode nil)
 '(breadcrumb-imenu-crumb-separator "/")
 '(breadcrumb-mode t)
 '(breadcrumb-project-crumb-separator ">")
 '(combobulate-key-prefix "C-c p")
 '(copilot-max-char -1)
 '(counsel-ag-base-command '("ag" "--vimgrep" "%s"))
 '(custom-safe-themes
   '("171d1ae90e46978eb9c342be6658d937a83aaa45997b1d7af7657546cae5985b" default))
 '(dimmer-adjustment-mode :foreground)
 '(dimmer-fraction 0.05)
 '(elfeed-feeds
   '("https://rss.samharris.org/feed/bce045ee-04d2-4071-830e-533d4223e9ff"))
 '(evil-default-cursor nil)
 '(evil-leader/leader "SPC")
 '(evil-mode t)
 '(evil-want-C-i-jump nil)
 '(evil-want-keybinding t)
 '(global-evil-collection-unimpaired-mode t)
 '(global-evil-surround-mode t)
 '(global-undo-tree-mode t)
 '(gptel-api-key "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")
 '(gptel-model "gpt-4")
 '(indent-tabs-mode nil)
 '(ivy-count-format "(%d/%d) ")
 '(ivy-mode t)
 '(ivy-preferred-re-builders
   '((ivy--regex-fuzzy . "fuzzy")
     (ivy--regex-plus . "ivy")
     (ivy--regex-ignore-order . "order")))
 '(ivy-sort-matches-functions-alist
   '((t)
     (ivy-completion-in-region . ivy--shorter-matches-first)
     (ivy-switch-buffer . ivy-sort-function-buffer)))
 '(ivy-use-selectable-prompt t)
 '(ivy-use-virtual-buffers t)
 '(js-indent-level 2)
 '(org-modern-block-name '("‣" . "‣"))
 '(org-modern-hide-stars " ")
 '(package-selected-packages
   '(dumb-jump elfeed eglot lsp-mode rainbow-mode back-button ninja-mode lsp-ui tree-sitter lsp-java gitlab-pipeline terraform-mode omnisharp crystal-mode auto-complete vterm gptel auto-indent-mode command-log-mode company-box powershell applescript-mode consult-ag consult svelte-mode typescript-mode yaml-mode sass-mode scss-mode glsl-mode focus dimmer block-nav web-mode org-modern basic-mode request rust-mode swift-mode rainbow-delimiters evil-lispy swiper which-key sublimity smooth-scroll beacon markdown-mode lua-mode yasnippet-lean typit counsel smooth-scrolling yasnippet use-package undo-tree projectile persistent-scratch paredit osx-clipboard org-roam magit ivy ido-vertical-mode flx-ido evil-terminal-cursor-changer evil-surround evil-snipe evil-leader evil-exchange evil-collection editorconfig csharp-mode company cmake-mode bison-mode avy atom-one-dark-theme ag))
 '(projectile-mode t nil (projectile))
 '(projectile-sort-order 'recently-active)
 '(quote
   (package-selected-packages
    '(evil-snipe bison-mode csharp-mode yasnippet company org-roam persistent-scratch ivy cmake-mode flx-ido ido-vertical-mode magit atom-one-dark-theme ## evil-terminal-cursor-changer evil use-package)))
 '(ring-bell-function 'ignore)
 '(ruby-align-chained-calls t)
 '(ruby-block-indent t)
 '(ruby-deep-arglist t)
 '(ruby-indent-level 2)
 '(safe-local-variable-values
   '((etags-regen-ignores "test/manual/etags/")
     (etags-regen-regexp-alist
      (("c" "objc")
       "/[ \11]*DEFVAR_[A-Z_ \11(]+\"\\([^\"]+\\)\"/\\1/" "/[ \11]*DEFVAR_[A-Z_ \11(]+\"[^\"]+\",[ \11]\\([A-Za-z0-9_]+\\)/\\1/"))
     (whitespace-line-column . 80)))
 '(undo-tree-enable-undo-in-region t)
 '(warning-suppress-types
   '(((copilot copilot-no-mode-indent))
     (emacs)
     (org-roam)
     (org-roam)
     (org-roam)
     (org-roam)))
 '(web-mode-code-indent-offset 2)
 '(web-mode-css-indent-offset 2))

(custom-set-faces
 ;; custom-set-faces was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 '(default ((t (:inherit nil :extend nil :stipple nil :background "#000000" :foreground "#abb2bf" :inverse-video nil :box nil :strike-through nil :overline nil :underline nil :slant normal :weight normal :height 140 :width normal :foundry "default" :family "Dank Mono"))))
 '(beacon-fallback-background ((t (:background "#fffaf0"))))
 '(bold ((t (:foreground "#e5e5e5" :weight ultra-heavy))))
 '(custom-variable-tag ((t (:foreground "#708090" :weight bold))))
 '(diff-added ((t (:inherit diff-changed :extend t))))
 '(diff-function ((t (:inherit diff-header :foreground "#000000"))))
 '(diff-hunk-header ((t (:inherit diff-header :foreground "#2f4f4f"))))
 '(diff-refine-added ((t (:inherit diff-refine-changed :background "#2e8b57" :foreground "#f5f5f5"))))
 '(diff-refine-removed ((t (:inherit diff-refine-changed :background "#cd5c5c" :foreground "#f5f5f5"))))
 '(diff-removed ((t (:inherit diff-changed :extend t))))
 '(font-lock-comment-face ((t (:foreground "#2e8b57" :slant italic))))
 '(hl-line ((t (:extend t))))
 '(italic ((t (:underline t :slant italic))))
 '(magit-blame-date ((t (:foreground "#5c6370"))))
 '(magit-blame-hash ((t (:foreground "#c678dd"))))
 '(magit-blame-heading ((t (:extend t :foreground "#828997"))))
 '(magit-blame-highlight ((t (:extend t :background "#cccccc" :foreground "#000000"))))
 '(magit-diff-added-highlight ((t (:extend t :background "#cceecc" :foreground "#228b22"))))
 '(magit-diff-removed-highlight ((t (:extend t :background "#eecccc" :foreground "#b22222"))))
 '(org-block ((t (:extend t :foreground "#bebebe"))))
 '(org-block-begin-line ((t (:extend t :background "darkslategray" :foreground "mediumaquamarine"))))
 '(org-code ((t (:inherit (fixed-pitch shadow) :foreground "#00cdcd"))))
 '(org-drawer ((t (:foreground "#6495ed"))))
 '(org-hide ((t (:foreground "#000000"))))
 '(org-indent ((t (:background "#000000" :foreground "#000000"))))
 '(org-level-4 ((t (:extend nil :foreground "lightseagreen"))))
 '(org-modern-tag ((t (:foreground "#00ffff"))))
 '(org-table ((t (:inherit fixed-pitch :foreground "#708090"))))
 '(org-todo ((t (:foreground "#cd5c5c" :weight bold))))
 '(undo-tree-visualizer-active-branch-face ((t (:foreground "#e5e5e5" :weight bold))))
 '(undo-tree-visualizer-default-face ((t (:foreground "#7f7f7f"))))
 '(vterm-color-blue ((t (:foreground "lightskyblue"))))
 '(vterm-color-yellow ((t (:foreground "lightgoldenrod"))))
 '(widget-field ((t (:extend t :background "#2f4f4f" :foreground "#f3f3f3")))))
(put 'dired-find-alternate-file 'disabled nil)