#+title: Aner's Emacs Lauretta Configuration
#+property: header-args :results silent

* Base setup
** Require

#+begin_src emacs-lisp
(require 'azos-emacs-base)
(require 'azos-emacs-dev)
(require 'azos-emacs-editor)
(require 'azos-emacs-exwm)
(require 'azos-emacs-station)
#+end_src

* Lauretta specific

** LLM

#+begin_src emacs-lisp
(setq
 gptel-model   'openai/gpt-oss-120b
 gptel-backend
 (gptel-make-openai "Groq"
   :host "api.groq.com"
   :endpoint "/openai/v1/chat/completions"
   :stream t
   :key "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"
   :models '(openai/gpt-oss-120b)))
#+end_src

** Agent Shell

#+begin_src emacs-lisp
(setq agent-shell-opencode-default-model-id "opencode/big-pickle")
;; (setq agent-shell-preferred-agent-config (agent-shell-opencode-make-agent-config))
#+end_src

** Headphones

#+begin_src emacs-lisp
(defun azos/connect-headphones ()
  (interactive)
    (start-process-shell-command "connect-headphones" nil "azos-connect-headphones-whmx4000"))

(define-key azos/global-minor-mode/open-keymap
    (kbd "h") 'azos/connect-headphones)
#+end_src

** Storage

#+begin_src emacs-lisp
(defun azos/storage--lsblk-field (dev field)
  "Get FIELD from lsblk DEV hash table."
  (when (hash-table-p dev)
    (gethash field dev)))

(defun azos/storage--list-devices ()
  "Return flat list of partitions/devices from lsblk, with bare disks included."
  (let* ((json-str (shell-command-to-string
                    "lsblk --json -o NAME,SIZE,LABEL,MOUNTPOINT,TYPE"))
         (data (condition-case nil (json-parse-string json-str) (error nil)))
         (devs '()))
    (when (hash-table-p data)
      (seq-do
       (lambda (dev)
         (let ((children (azos/storage--lsblk-field dev "children")))
           (if (and (vectorp children) (> (length children) 0))
               (seq-do (lambda (child) (push child devs)) children)
             (push dev devs))))
       (gethash "blockdevices" data)))
    (nreverse devs)))

(defun azos/storage--null-p (val)
  "Return t if VAL is a JSON null (i.e. :null)."
  (eq val :null))

(defun azos/storage--label-str (dev)
  "Format label for DEV, returning empty string if absent."
  (let ((label (azos/storage--lsblk-field dev "label")))
    (if (and label (not (azos/storage--null-p label)))
        (format "  [%s]" label)
      "")))

(defun azos/storage/mount ()
  "Mount an unmounted block device using udisksctl."
  (interactive)
  (let* ((devs (azos/storage--list-devices))
         (unmounted (seq-filter
                     (lambda (d)
                       (let ((mp (azos/storage--lsblk-field d "mountpoint"))
                             (type (azos/storage--lsblk-field d "type")))
                         (and (member type '("part" "disk"))
                              (or (null mp) (azos/storage--null-p mp)))))
                     devs))
         (choices (mapcar
                   (lambda (d)
                     (let ((name (azos/storage--lsblk-field d "name"))
                           (size (azos/storage--lsblk-field d "size")))
                       (cons (format "/dev/%s  %s%s" name size (azos/storage--label-str d))
                             (format "/dev/%s" name))))
                   unmounted)))
    (if choices
        (let* ((selected (completing-read "Mount device: " (mapcar #'car choices) nil t))
               (device (cdr (assoc selected choices))))
          (message "%s" (string-trim
                         (shell-command-to-string
                          (format "udisksctl mount -b %s" device)))))
      (message "No unmounted partitions found."))))

(defun azos/storage/unmount ()
  "Unmount a mounted block device using udisksctl."
  (interactive)
  (let* ((devs (azos/storage--list-devices))
         (mounted (seq-filter
                   (lambda (d)
                     (let ((mp (azos/storage--lsblk-field d "mountpoint")))
                       (and mp
                            (not (azos/storage--null-p mp))
                            (not (string-prefix-p "/nix" mp))
                            (not (string-prefix-p "/boot" mp))
                            (not (equal mp "/")))))
                   devs))
         (choices (mapcar
                   (lambda (d)
                     (let ((name (azos/storage--lsblk-field d "name"))
                           (size (azos/storage--lsblk-field d "size"))
                           (mp   (azos/storage--lsblk-field d "mountpoint")))
                       (cons (format "/dev/%s  %s  -> %s%s" name size mp (azos/storage--label-str d))
                             (format "/dev/%s" name))))
                   mounted)))
    (if choices
        (let* ((selected (completing-read "Unmount device: " (mapcar #'car choices) nil t))
               (device (cdr (assoc selected choices))))
          (message "%s" (string-trim
                         (shell-command-to-string
                          (format "udisksctl unmount -b %s" device)))))
      (message "No mounted user partitions found."))))

(define-key azos/global-minor-mode/open-keymap (kbd "s m") 'azos/storage/mount)
(define-key azos/global-minor-mode/open-keymap (kbd "s u") 'azos/storage/unmount)
#+end_src

** Tab bar setup

#+begin_src emacs-lisp
(when (fboundp #'azos/bat/enable-tab-display)
  (azos/bat/enable-tab-display))

(when (fboundp #'azos/network/enable-tab-display)
  (azos/network/enable-tab-display))

(when (fboundp #'azos/audio/enable-tab-display)
  (azos/audio/enable-tab-display))
#+end_src

** Nixpkgs Search

#+begin_src emacs-lisp
(defun azos/nixpkgs-parse-json-lines (str)
  "Parse JSON Lines format (one JSON object per line) from STR."
        (mapcar (lambda (line)
                  (and (not (string-empty-p line))
                       (string-match "^{" line)
                       (condition-case nil
                           (json-parse-string line)
                         (error nil))))
                (split-string (string-trim str) "\n" t)))

(defun azos/nixpkgs-g (key hash)
  "Get KEY from HASH table."
  (when (hash-table-p hash)
    (gethash key hash)))

(defun azos/nixpkgs-search ()
  "Search for a nixpkgs package and show its info."
  (interactive)
  (let* ((pattern (read-string "Search pattern: "))
         (json-output (shell-command-to-string
                       (format "nix-search --json --max-results 50 '%s'" pattern)))
         (results (and json-output
                       (not (string-empty-p json-output))
                       (azos/nixpkgs-parse-json-lines json-output)))
         (packages (delq nil (mapcar (lambda (item)
                                       (let ((pname (azos/nixpkgs-g "package_pname" item)))
                                         (when pname
                                           (cons pname item))))
                                     results))))
    (if packages
        (let* ((selected (completing-read "Package: " (mapcar #'car packages) nil t))
               (package-data (cdr (assoc-string selected packages))))
          (let ((buf (get-buffer-create "*nixpkgs-package-info*")))
            (with-current-buffer buf
              (erase-buffer)
              (if package-data
                  (progn
                    (insert (format "Package: %s\n\n" selected))
                    (insert (format "Version: %s\n" (or (azos/nixpkgs-g "package_pversion" package-data) "unknown")))
                    (insert (format "Attr: %s\n" (or (azos/nixpkgs-g "package_attr_name" package-data) "unknown")))
                    (insert (format "\nDescription: %s\n"
                                   (or (azos/nixpkgs-g "package_description" package-data) "none")))
                    (let ((programs (azos/nixpkgs-g "package_programs" package-data)))
                      (when (vectorp programs)
                        (insert (format "\nPrograms: %s\n"
                                       (mapconcat #'identity (append programs nil) " ")))))
                    (let ((homepage (let ((h (azos/nixpkgs-g "package_homepage" package-data)))
                                      (when (vectorp h) (aref h 0)))))
                      (when homepage
                        (insert (format "\nHomepage: %s\n" homepage))))
                    (let ((licenses (azos/nixpkgs-g "package_license" package-data)))
                      (when (vectorp licenses)
                        (insert (format "\nLicense: %s\n"
                                       (mapconcat (lambda (l)
                                                    (or (azos/nixpkgs-g "fullName" l) ""))
                                                  (append licenses nil) ", ")))))
                (insert (format "Package: %s\n\n" selected)
                        "\nNo additional info available.")))
              (goto-char (point-min)))
            (display-buffer buf)))
      (message "No packages found matching '%s'" pattern))))

(define-key azos/global-minor-mode/open-keymap
    (kbd "n") 'azos/nixpkgs-search)
#+end_src

** CalDAV / Org Sync

#+begin_src emacs-lisp
(require 'org-caldav)

(defvar azos/lauretta/nextcloud-user "aner"
  "Nextcloud username for CalDAV sync.")

(setq org-caldav-url "https://nextcloud.zakobar.com/remote.php/dav/calendars/1ddd03a6-4c2d-103c-9f7b-27b20313341d"
      org-caldav-calendar-id "personal"
      org-caldav-inbox "~/org/caldav-inbox.org"
      org-caldav-files '("~/org/todo.org")
      org-icalendar-timezone "Asia/Jerusalem")

(defun azos/caldav-sync ()
  "Sync org-caldav with Nextcloud calendar, reading password from pass."
  (interactive)
  (let* ((password (string-trim
                    (shell-command-to-string
                     (format "pass zakobar.com/users/%s" azos/lauretta/nextcloud-user))))
         (url-http-real-basic-auth-storage
          (list (list "nextcloud.zakobar.com:443"
                      (cons azos/lauretta/nextcloud-user password)))))
    (org-caldav-sync)))

(define-key azos/global-minor-mode/open-keymap
    (kbd "C") 'azos/caldav-sync)
#+end_src

* Provide

#+begin_src emacs-lisp
(provide 'azos-emacs-lauretta)
#+end_src