emacs.el

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; early-init.el
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(setq
 package-enable-at-startup nil
 gc-cons-threshold most-positive-fixnum
 read-process-output-max (* 1024 1024)
 redisplay-dont-pause t
 gc-cons-percentage 0.6
 frame-resize-pixelwise t
 inhibit-compacting-font-caches t
 frame-inhibit-implied-resize t
 frame-resize-pixelwise t)

(menu-bar-mode -1)
(scroll-bar-mode -1)
(tool-bar-mode -1)
(tooltip-mode -1)

(provide 'early-init)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; init.el
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; Package Management
(require 'package)
(add-to-list 'package-archives '("melpa" . "https://melpa.org/packages/") t)
(package-initialize)
(require 'use-package)
(setq use-package-always-ensure t)

;; Add sepi directory to load-path
(add-to-list 'load-path (expand-file-name "sepi" user-emacs-directory))

;;; Core Settings
(use-package emacs
  :ensure nil
  :init
  (setq make-backup-files nil
        auto-save-default nil
        create-lockfiles nil
        custom-file (expand-file-name "custom.el" user-emacs-directory)
        inhibit-startup-message t
        initial-buffer-choice t
        initial-scratch-message ""
        visible-bell t
        ring-bell-function 'ignore
        tab-width 2
        scroll-step 1
        scroll-conservatively 10000
        use-short-answers t)
  :custom
  (frame-resize-pixelwise t)
  (pixel-scroll-precision-mode t)
  (pixel-scroll-precision-use-momentum nil)
  (use-dialog-box nil)
  (use-file-dialog nil)

		

  :config
  ;; (add-hook 'prog-mode-hook #'hs-minor-mode)
  (delete-selection-mode 1)
  (put 'upcase-region 'disabled nil)
  (when (file-exists-p custom-file) (load custom-file))
  (menu-bar-mode -1)
  (tool-bar-mode -1)
  (scroll-bar-mode -1)
  (global-unset-key (kbd "C-t"))
  (global-unset-key (kbd "C-\\"))
	(global-set-key (kbd "C-;") 'hs-hide-block)
	(global-set-key (kbd "C-'") 'hs-show-block)
	(global-set-key (kbd "C-:") 'hs-hide-all)
	(global-set-key (kbd "C-\"") 'hs-show-all)
  (global-set-key (kbd "C-l") #'goto-line)
  (global-set-key (kbd "C-\\") 'dabbrev-expand)
  (global-set-key (kbd "s-s") (lambda () (interactive)
                                (call-interactively 'occur)
                                (pop-to-buffer "*Occur*"))))

;;; UI Customization
(use-package frame
  :ensure nil
  :hook (emacs-startup . (lambda ()
                           (setq-default mode-line-format
                                         '("%e" mode-line-front-space
                                           "%b ░ %* ░ %l:%c"
					   " ░ " vc-mode
                                           mode-line-format-right-align
                                           " ░ " mode-name
                                           mode-line-end-spaces))))
  :config
  (add-to-list 'custom-theme-load-path "~/.emacs.d/themes/")
  (load-theme 'default-black t)
  (set-display-table-slot standard-display-table 'truncation ?░)
  (set-fringe-mode 0)
  (set-face-attribute 'default nil :font "Cascadia Code" :height 140)
  (global-display-line-numbers-mode -1)
  (add-to-list 'default-frame-alist '(undecorated . t))
  (add-to-list 'default-frame-alist '(ns-transparent-titlebar . nil))
  (add-to-list 'default-frame-alist '(ns-appearance . dark)))

;;; Keybindings
(use-package windmove
  :bind (("M-<left>" . windmove-left)
         ("M-<right>" . windmove-right)
         ("M-<up>" . windmove-up)
         ("M-<down>" . windmove-down)))

(use-package project
  :bind (("s-<escape>" . project-shell-command)
         ("M-ESC" . project-async-shell-command)
         ("s-b" . project-switch-to-buffer)
         ("s-f" . project-find-file)
         ("s-d" . project-dired)))

(use-package helpful
  :defer t
  :bind (("C-h f" . helpful-callable)
         ("C-h v" . helpful-variable)
         ("C-h k" . helpful-key)
         ("C-h x" . helpful-command)
         ("C-c C-d" . helpful-at-point)
         ("C-h F" . helpful-function)))

;;; Custom Sepi Packages
(use-package sepi-recenter
  :ensure nil
  :bind ("s-l" . sepi-recenter-and-pulse))

(use-package sepi-pulse
  :ensure nil
  :config (sepi-enable-pulse-copy-paste))

(use-package sepi-toggle
  :ensure nil
  :bind (("C-t l" . sepi-toggle-line-numbers-and-fringe)
         ("C-t w" . sepi-toggle-line-wrap)))

(use-package sepi-init
  :ensure nil
  :bind ("s-," . sepi-open-init-file))

(use-package sepi-smart-bol
  :ensure nil
  :config
  (sepi-smart-bol-mode 1)
  :bind (("C-a" . sepi-smart-bol)))


(use-package dired
  :ensure nil
  :init
  (setq ls-lisp-use-insert-directory-program nil
        ls-lisp-dirs-first t
        dired-listing-switches "-lh"
        dired-kill-when-opening-new-dired-buffer t
        dired-dwim-target t)
  :config
  (global-set-key (kbd "C-x d") #'dired)
  (global-set-key (kbd "C-x C-d") #'dired)
  :hook (dired-mode . (lambda ()
                        (local-set-key (kbd ".") 'dired-toggle-hidden)
                        (dired-hide-details-mode 1)))
  :config
  (defun dired-toggle-hidden ()
    "Toggle hidden files in Dired."
    (interactive)
    (if (string-match "a" dired-actual-switches)
        (dired-sort-other (replace-regexp-in-string "a" "" dired-actual-switches))
      (dired-sort-other (concat dired-actual-switches "a")))))

;;; Buffer Management
(use-package ibuffer
  :ensure nil
  :config (defalias 'list-buffers 'ibuffer))

;;; Completion
(use-package minibuffer
  :ensure nil
  :init
  (setq completion-show-help nil
        completion-styles '(basic flex)
        completions-detailed nil
        enable-recursive-minibuffers t
        completion-auto-select 'second-tab
        completion-auto-help 'always
        completions-format 'one-column
        completions-sort 'historical
        completions-max-height 20
        completion-ignore-case t)
  :config (completion-preview-mode t))

;; Use rtags for C/C++ navigation
(use-package cc-mode
  :ensure nil
  :mode ("\\.c\\'" . c-ts-mode))

(use-package c-ts-mode
  :if (treesit-language-available-p 'c)
  :custom
  (c-ts-mode-indent-offset 2)
  :init
  (add-to-list 'major-mode-remap-alist '(c-mode . c-ts-mode))
  (add-to-list 'major-mode-remap-alist '(c++-mode . c++-ts-mode))
  (add-to-list 'major-mode-remap-alist '(c-or-c++-mode . c-or-c++-ts-mode))
  :config
  (setq tags-revert-without-query t)
  (setq tags-add-tables nil) ;; don't prompt when visiting tags


  ;; Format on save
  (defun sepi/format-c-buffer-on-save ()
    (when (executable-find "clang-format")
      (add-hook 'before-save-hook #'clang-format-buffer nil t)))
  (add-hook 'c-ts-mode-hook #'sepi/format-c-buffer-on-save)

  ;; TAGS/xref config
  (defvar sepi/ctags-dir (expand-file-name "ctags" user-emacs-directory))

  (defun sepi/project-name ()
    (file-name-nondirectory (directory-file-name (project-root (project-current)))))

  (defun sepi/project-tags-file ()
    (expand-file-name (format "%s/TAGS" (sepi/project-name)) sepi/ctags-dir))

  (defun sepi/generate-ctags ()
    (interactive)
    (when-let ((project (project-current)))
      (let ((default-directory (project-root project))
            (tags-file (sepi/project-tags-file)))
        (make-directory (file-name-directory tags-file) :parents)
        (start-process "ctags" "*ctags*" "ctags" "-e" "-R" "-f" tags-file "."))))

  (defun sepi/use-project-tags ()
    "Set tags for xref from centralized ~/.emacs.d/ctags location."
    (let ((tags-file (sepi/project-tags-file)))
      (when (file-exists-p tags-file)
	(setq-local tags-file-name tags-file)
	(add-to-list 'tags-table-list tags-file))))

  (defun sepi/update-ctags-on-save ()
    (when (and (buffer-file-name) (project-current))
      (sepi/generate-ctags)))

  (add-hook 'c-ts-mode-hook #'sepi/use-project-tags)
  (add-hook 'c-ts-mode-hook
            (lambda ()
              (add-hook 'after-save-hook #'sepi/update-ctags-on-save nil t)))
  (add-hook 'c-ts-mode-hook
            (lambda ()
              (unless (file-exists-p (sepi/project-tags-file))
                (sepi/generate-ctags))))

  ;; Xref jump and reference (optional, if you want custom keybindings)
  (defun sepi/jump-to-definition ()
    (interactive)
    (xref-find-definitions (thing-at-point 'symbol t)))

  (defun sepi/find-references ()
    (interactive)
    (xref-find-references (thing-at-point 'symbol t)))

  (global-set-key (kbd "M-RET") #'sepi/jump-to-definition)
  (global-set-key (kbd "s-<return>") #'sepi/find-references))

(use-package python
  :ensure nil
  :hook (python-mode . (lambda () (setq python-indent-offset 2))))

(use-package lua-mode
  :defer t
  :hook (lua-mode . (lambda () (setq lua-indent-level 2))))

;;; Additional Tools
(use-package xref
  :ensure nil
  :bind (("s-[" . xref-go-back)
	 ("s-]" . xref-go-forward))
  :config
  (with-eval-after-load 'xref
    (define-key xref--xref-buffer-mode-map (kbd "RET") 'xref-quit-and-goto-xref)
    (define-key xref--xref-buffer-mode-map (kbd "TAB") 'xref-goto-xref)))

(use-package isearch
  :ensure nil
  :init
  (advice-add 'isearch-repeat :after
            (lambda (&rest _) (recenter)))
  (setq isearch-wrap-pause 'no
        isearch-lazy-count t
        isearch-lazy-highlight t))

(use-package rg
  :defer t
  :commands (rg-run)
  :bind (:map rg-mode-map
              ("h" . rg-menu))
  :config
  (rg-enable-default-bindings)
  (setq display-buffer-alist
        '(("\\*rg\\*" display-buffer-reuse-window display-buffer-same-window))))

(use-package multiple-cursors
  :ensure t
  :bind (("C-." . mc/mark-next-like-this)
         ("C-," . mc/mark-previous-like-this)
         ("C-s-<return>" . mc/mark-all-like-this))
  :config
  (setq mc/keymap (let ((map (make-sparse-keymap)))
                    (define-key map (kbd "C-g") 'mc/keyboard-quit)
                    map)))

(use-package expreg
  :defer t
  :bind (("C-=" . expreg-expand)
	 ("C--" . expreg-contract)))

(use-package ctrlf
  :defer t
  :config
  (ctrlf-mode +1)
  :bind (("M-s-." . ctrlf-forward-symbol-at-point)))

;;; External Packages
(use-package markdown-mode :defer t)
(use-package format-all :defer t)
(use-package magit :defer t)
(use-package which-key :config (which-key-mode))

(put 'downcase-region 'disabled nil)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; sepi-init.el
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; Code:
(defun sepi-open-init-file ()
  "Open init.el configuration file."
  (interactive)
  (find-file user-init-file))

(provide 'sepi-init)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; sepi-pulse.el
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; Code:
(defun sepi-pulse-region (beg end)
  "Pulse the region between BEG and END if pulse function is available."
  (when (and (fboundp 'pulse-momentary-highlight-region) beg end)
    (pulse-momentary-highlight-region beg end)))

(defun sepi-pulse-after-copy (beg end &optional _)
  "Pulse the region between BEG and END after copying."
  (interactive "r")
  (sepi-pulse-region beg end))

(defun sepi-pulse-after-paste (&rest _)
  "Pulse the pasted region after insertion."
  (interactive)
  (when (and (mark) (not (equal (point) (mark))))
    (sepi-pulse-region (min (point) (mark)) (max (point) (mark)))))

(defun sepi-enable-pulse-copy-paste ()
  "Enable pulsing for copy and paste operations."
  (interactive)
  (advice-add 'kill-ring-save :after #'sepi-pulse-after-copy)
  (advice-add 'yank :after #'sepi-pulse-after-paste))

(defun sepi-disable-pulse-copy-paste ()
  "Disable pulsing for copy and paste operations."
  (interactive)
  (advice-remove 'kill-ring-save #'sepi-pulse-after-copy)
  (advice-remove 'yank #'sepi-pulse-after-paste))

(provide 'sepi-pulse)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; sepi-recenter.el
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; Code:
(defun sepi-recenter-and-pulse ()
  "Recenter window and pulse current line."
  (interactive)
  (recenter)
  (when (fboundp 'pulse-momentary-highlight-one-line)
    (pulse-momentary-highlight-one-line (point))))

(provide 'sepi-recenter)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; sepi-smart-bol.el
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defvar sepi-smart-bol--toggle-state nil
  "Internal state to toggle between beginning of line and indentation.")

;;;###autoload
(defun sepi-smart-bol ()
  "Alternate between beginning of line and first non-whitespace character."
  (interactive)
  (if sepi-smart-bol--toggle-state
      (beginning-of-line)
    (back-to-indentation))
  (setq sepi-smart-bol--toggle-state (not sepi-smart-bol--toggle-state)))

(defun sepi-smart-bol--reset-state ()
  "Reset toggle state unless last command was `sepi-smart-bol`."
  (unless (eq this-command #'sepi-smart-bol)
    (setq sepi-smart-bol--toggle-state nil)))

;;;###autoload
(define-minor-mode sepi-smart-bol-mode
  "Minor mode to enable smart beginning-of-line behavior."
  :global t
  (if sepi-smart-bol-mode
      (add-hook 'post-command-hook #'sepi-smart-bol--reset-state)
    (remove-hook 'post-command-hook #'sepi-smart-bol--reset-state)))

(provide 'sepi-smart-bol)


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; sepi-toggle.el
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;; Code:
(defun sepi-toggle-line-numbers-and-fringe ()
  "Toggle line numbers and fringe display."
  (interactive)
  (if display-line-numbers-mode
      (progn
        (global-display-line-numbers-mode -1)
        (set-fringe-mode 0))
    (progn
      (global-display-line-numbers-mode 1)
      (set-fringe-mode 8))))

(defun sepi-toggle-line-wrap ()
  "Toggle line wrapping."
  (interactive)
  (setq truncate-lines (not truncate-lines))
  (redraw-display))

(provide 'sepi-toggle)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;