nixos-dotfiles

;;; telescope.el --- Telescope-like fuzzy finder -*- lexical-binding: t -*-

(require 'posframe)

(defgroup telescope nil

  "Telescope-like fuzzy finder."

  :group 'convenience)

(defcustom telescope-fd-command "fd -t f --color=never --hidden --exclude .git"

  "Command to list files."

  :type 'string

  :group 'telescope)

(defcustom telescope-results-width-pct 0.35

  "Width of results window as percentage of frame."

  :type 'float

  :group 'telescope)

(defcustom telescope-preview-width-pct 0.50

  "Width of preview window as percentage of frame."

  :type 'float

  :group 'telescope)

(defcustom telescope-height-pct 0.70

  "Height of telescope as percentage of frame."

  :type 'float

  :group 'telescope)

(defcustom telescope-gap 2

  "Gap between results and preview panes in characters."

  :type 'integer

  :group 'telescope)

(defcustom telescope-padding 2

  "Internal padding within panes in characters."

  :type 'integer

  :group 'telescope)

;; Internal state

(defvar telescope--input "")

(defvar telescope--files nil)

(defvar telescope--filtered nil)

(defvar telescope--selected 0)

(defvar telescope--base-dir nil)

(defvar telescope--results-buffer " *telescope-results*")

(defvar telescope--preview-buffer " *telescope-preview*")

(defun telescope--get-files (dir)

  "Get all files in DIR using fd."

  (let ((default-directory dir))

    (split-string

     (shell-command-to-string (concat telescope-fd-command " ."))

     "\n" t)))

(defun telescope--fzf-filter (files query)

  "Filter FILES with QUERY using fzf --filter."

  (if (or (null files) (string-empty-p query))

      (seq-take files 100)

    (with-temp-buffer

      (insert (string-join files "\n"))

      (call-process-region (point-min) (point-max) "fzf" t t nil "--filter" query)

      (split-string (buffer-string) "\n" t))))

(defun telescope--render-results ()

  "Render the results buffer."

  (with-current-buffer (get-buffer-create telescope--results-buffer)

    (let* ((inhibit-read-only t)

           (pad (make-string telescope-padding ?\s))

           (max-results (- telescope--height 5))  ; leave room for prompt/footer/padding

           (content-width (- telescope--results-width (* telescope-padding 2) 2))

           (separator (make-string (min content-width 80) ?─)))

      (erase-buffer)

      ;; Top padding

      (insert "\n")

      ;; Prompt

      (insert pad)

      (insert (propertize "> " 'face '(:foreground "#87afff" :weight bold)))

      (insert telescope--input)

      (insert (propertize "█" 'face 'cursor))

      (insert "\n")

      (insert pad)

      (insert (propertize separator 'face '(:foreground "#444444")))

      (insert "\n")

      ;; Results

      (if (null telescope--filtered)

          (progn

            (insert pad)

            (insert (propertize "  No matches\n" 'face '(:foreground "#666666" :slant italic))))

        (let ((idx 0))

          (dolist (file (seq-take telescope--filtered max-results))

            (let* ((max-len (- content-width 4))

                   (display (if (> (length file) max-len)

                                (concat "..." (substring file (- 3 max-len)))

                              file))

                   (selected (= idx telescope--selected))

                   (face (if selected

                             '(:background "#3a3a3a" :weight bold)

                           nil))

                   (prefix (if selected "→ " "  ")))

              (insert pad)

              (insert (propertize (concat prefix display "\n") 'face face)))

            (cl-incf idx))))

      ;; Footer

      (insert pad)

      (insert (propertize separator 'face '(:foreground "#444444")))

      (insert "\n")

      (insert pad)

      (insert (propertize (format "%d/%d"

                                  (min (1+ telescope--selected) (length telescope--filtered))

                                  (length telescope--filtered))

                          'face '(:foreground "#666666"))))))

(defun telescope--update-preview ()

  "Update preview buffer with selected file content."

  (with-current-buffer (get-buffer-create telescope--preview-buffer)

    (let ((inhibit-read-only t)

          (pad (make-string telescope-padding ?\s)))

      (erase-buffer)

      (if-let* ((selected (nth telescope--selected telescope--filtered))

                (path (expand-file-name selected telescope--base-dir))

                (_ (and (file-exists-p path)

                        (file-regular-p path)

                        (not (file-directory-p path)))))

          (condition-case nil

              (progn

                ;; Top padding

                (insert "\n")

                ;; File name header

                (insert pad)

                (insert (propertize (file-name-nondirectory path) 'face '(:foreground "#87afff" :weight bold)))

                (insert "\n")

                (insert pad)

                (insert (propertize (make-string (min 60 (- telescope--preview-width 4)) ?─) 'face '(:foreground "#444444")))

                (insert "\n")

                ;; Content with left padding

                (let ((start (point)))

                  (insert-file-contents path nil 0 10000)

                  (goto-char start)

                  ;; Add padding to each line

                  (while (not (eobp))

                    (insert pad)

                    (forward-line 1)))

                (goto-char (point-min))

                ;; Apply syntax highlighting

                (when-let ((mode (assoc-default path auto-mode-alist 'string-match)))

                  (delay-mode-hooks (funcall mode))

                  (font-lock-ensure)))

            (error

             (erase-buffer)

             (insert "\n" pad)

             (insert (propertize "Cannot preview file" 'face '(:foreground "#666666")))))

        (insert "\n" pad)

        (insert (propertize "No preview available" 'face '(:foreground "#666666")))))))

(defvar telescope--results-x 0)

(defvar telescope--results-y 0)

(defvar telescope--preview-x 0)

(defvar telescope--results-width 55)

(defvar telescope--preview-width 75)

(defvar telescope--height 25)

(defun telescope--calc-dimensions ()

  "Calculate frame dimensions based on percentages."

  (let ((frame-cols (frame-width))

        (frame-rows (frame-height)))

    (setq telescope--results-width (max 30 (floor (* frame-cols telescope-results-width-pct))))

    (setq telescope--preview-width (max 40 (floor (* frame-cols telescope-preview-width-pct))))

    (setq telescope--height (max 15 (floor (* frame-rows telescope-height-pct))))))

(defun telescope--calc-positions ()

  "Calculate frame positions."

  (telescope--calc-dimensions)

  (let* ((char-width (frame-char-width))

         (char-height (frame-char-height))

         (border-px 4)

         (gap-px (* telescope-gap char-width))

         (total-pixel-width (+ (* telescope--results-width char-width)

                               (* telescope--preview-width char-width)

                               (* 2 border-px)

                               gap-px))

         (total-pixel-height (* telescope--height char-height))

         (start-x (max 0 (/ (- (frame-pixel-width) total-pixel-width) 2)))

         (start-y (max 0 (/ (- (frame-pixel-height) total-pixel-height) 2))))

    (setq telescope--results-x start-x)

    (setq telescope--results-y start-y)

    (setq telescope--preview-x (+ start-x (* telescope--results-width char-width) border-px gap-px))))

(defun telescope--results-poshandler (_info)

  "Position handler for results frame."

  (cons telescope--results-x telescope--results-y))

(defun telescope--preview-poshandler (_info)

  "Position handler for preview frame."

  (cons telescope--preview-x telescope--results-y))

(defun telescope--show-frames ()

  "Display the telescope posframes."

  (telescope--calc-positions)

  ;; Results frame (left)

  (posframe-show telescope--results-buffer

                 :position (point-min)

                 :poshandler #'telescope--results-poshandler

                 :width telescope--results-width

                 :height telescope--height

                 :border-width 2

                 :border-color "#5f5fff"

                 :background-color "#1c1c1c"

                 :foreground-color "#d0d0d0"

                 :override-parameters '((cursor-type . nil)))

  ;; Preview frame (right)

  (posframe-show telescope--preview-buffer

                 :position (point-min)

                 :poshandler #'telescope--preview-poshandler

                 :width telescope--preview-width

                 :height telescope--height

                 :border-width 2

                 :border-color "#5f87af"

                 :background-color "#1c1c1c"

                 :foreground-color "#d0d0d0"

                 :override-parameters '((cursor-type . nil))))

(defun telescope--hide-frames ()

  "Hide telescope posframes."

  (posframe-hide telescope--results-buffer)

  (posframe-hide telescope--preview-buffer))

(defun telescope--refresh ()

  "Refresh filtered results and display."

  (setq telescope--filtered (telescope--fzf-filter telescope--files telescope--input))

  (setq telescope--selected (min telescope--selected

                                  (max 0 (1- (length telescope--filtered)))))

  (telescope--render-results)

  (telescope--update-preview)

  (telescope--show-frames))

(defun telescope--select-next ()

  "Select next item."

  (when telescope--filtered

    (let ((max-visible (- telescope--height 5)))

      (setq telescope--selected

            (min (1+ telescope--selected)

                 (1- (min (length telescope--filtered) max-visible)))))

    (telescope--render-results)

    (telescope--update-preview)

    (telescope--show-frames)))

(defun telescope--select-prev ()

  "Select previous item."

  (setq telescope--selected (max 0 (1- telescope--selected)))

  (telescope--render-results)

  (telescope--update-preview)

  (telescope--show-frames))

(defun telescope--backspace ()

  "Delete last character from input."

  (when (> (length telescope--input) 0)

    (setq telescope--input (substring telescope--input 0 -1))

    (telescope--refresh)))

(defun telescope--insert-char (char)

  "Insert CHAR into input."

  (setq telescope--input (concat telescope--input (char-to-string char)))

  (telescope--refresh))

;;;###autoload

(defun telescope-find-files (&optional dir)

  "Find files in DIR using telescope interface."

  (interactive)

  (let ((dir (expand-file-name (or dir default-directory))))

    (setq telescope--base-dir dir)

    (setq telescope--input "")

    (setq telescope--selected 0)

    (setq telescope--files (telescope--get-files dir))

    (setq telescope--filtered (seq-take telescope--files 100))

    (telescope--render-results)

    (telescope--update-preview)

    (telescope--show-frames)

    (let ((result nil))

      (unwind-protect

          (while (null result)

            (let ((key (read-key (propertize " " 'face '(:height 0.1)))))

              (cond

               ;; Quit

               ((memq key '(?\e ?\C-g ?\C-c))

                (setq result 'cancel))

               ;; Confirm selection

               ((memq key '(?\r ?\C-m))

                (if telescope--filtered

                    (setq result (expand-file-name

                                   (nth telescope--selected telescope--filtered)

                                   telescope--base-dir))

                  (setq result 'cancel)))

               ;; Navigation

               ((or (memq key '(?\C-n ?\C-j)) (equal key 'down))

                (telescope--select-next))

               ((or (memq key '(?\C-p ?\C-k)) (equal key 'up))

                (telescope--select-prev))

               ;; Scroll

               ((memq key '(?\C-d))

                (dotimes (_ 5) (telescope--select-next)))

               ((memq key '(?\C-u))

                (dotimes (_ 5) (telescope--select-prev)))

               ;; Delete

               ((memq key '(?\C-h ?\C-? 127 backspace))

                (telescope--backspace))

               ;; Clear input

               ((memq key '(?\C-w))

                (setq telescope--input "")

                (telescope--refresh))

               ;; Regular character input

               ((and (characterp key) (>= key 32) (<= key 126))

                (telescope--insert-char key)))))

        ;; Cleanup

        (telescope--hide-frames))

      ;; Handle result

      (unless (eq result 'cancel)

        (find-file result)))))

(provide 'telescope)

;;; telescope.el ends here