CORPUS STATISTICS:
  Total unique works:       2690
  Greek texts:              2316
  English translations:     757
  Latin texts:              374

TRANSLATION COVERAGE:
  Greek with English:       571 (24%)
  Greek with Latin:         0 (0%)
  All three languages:      0
  Greek without translation:1745 (75%)
  English-only works:       0
  Latin-only works:         188

(defun thanos/wtype-text (text)
  "Process TEXT for wtype, handling newlines properly."
  (let* ((has-final-newline (string-match-p "\n$" text))
         (lines (split-string text "\n"))
         (last-idx (1- (length lines))))
    (string-join
     (cl-loop for line in lines
              for i from 0
              collect (cond
                       ;; Last line without final newline
                       ((and (= i last-idx) (not has-final-newline))
                        (format "wtype -s 350 \"%s\""
                                (replace-regexp-in-string "\"" "\\\\\"" line)))
                       ;; Any other line
                       (t
                        (format "wtype -s 350 \"%s\" && wtype -k Return"
                                (replace-regexp-in-string "\"" "\\\\\"" line)))))
     " && ")))

(defun thanos/type ()
  "Launch a temporary frame with a clean buffer for typing."
  (interactive)
  (let ((frame (make-frame '((name . "emacs-float")
                             (fullscreen . 0)
                             (undecorated . t)
                             (width . 70)
                             (height . 20))))
        (buf (get-buffer-create "emacs-float")))
    (with-selected-frame frame
      (switch-to-buffer buf)
      (with-current-buffer buf
    (erase-buffer)
    (org-mode)
    (setq-local header-line-format
                    (format " %s to insert text or %s to cancel."
                            (propertize "C-c C-c" 'face 'help-key-binding)
                (propertize "C-c C-k" 'face 'help-key-binding)))
    (local-set-key (kbd "C-c C-k")
               (lambda () (interactive)
             (kill-new (buffer-string))
             (delete-frame)))
    (local-set-key (kbd "C-c C-c")
               (lambda () (interactive)
             (call-process-shell-command
                          (thanos/wtype-text (buffer-string))
                          nil 0)
             (delete-frame)))))))

bind = $mainMod, j, exec, emacsclient --eval '(thanos/type)'
windowrulev2 = float,class:^(emacs)$,title:^(emacs-float)$ # Launch as a floating window.

(use-package org-gnosis
  :ensure t
  :init
  (define-prefix-command 'thanos/notes-map)
  (define-prefix-command 'thanos/journal-map)
  :config
  ;; I put my databse inside org-gnosis-dir to keep it in sync
  ;; between machines, using git.
  (setf org-gnosis-db (emacsql-sqlite-open
             (expand-file-name "data.db" org-gnosis-dir)))

  (setf org-gnosis-dir "~/Notes"
  org-gnosis-node-templates
  '(("Default" (lambda () "" "#+startup: content\n")))
  org-gnosis-journal-templates
  '(("2050 Plan" journal/plan-2050)
    ("Empty" (lambda () "" "#+startup: content\n")))
  org-gnosis-show-tags t
  org-gnosis-create-as-gpg t
  org-gnosis-completing-read-func #'org-completing-read)

  (defun journal/plan-2050 ()
    "My journaling template for 2050-01-01."
    (let ((days-remaining (- (time-to-days (encode-time 0 0 0 1 1 2050))
               (time-to-days (current-time)))))
      (format
       "\nDays until 2050: *%s* \n\n* Records\n\n* Daily notes\n* Goals\n%s"
       days-remaining (org-gnosis-todos))))

  :bind (("C-c n" . thanos/notes-map)
   ("C-c j" . thanos/journal-map)
   :map thanos/notes-map
         ("f" . org-gnosis-find)
   ("i" . org-gnosis-insert)
   ("t" . org-gnosis-find-by-tag)
   :map thanos/journal-map
   ("j" . org-gnosis-journal)
   ("f" . org-gnosis-journal-find)
   ("i" . org-gnosis-journal-insert)
   :map org-gnosis-mode-map
   ("C-c C-." . org-gnosis-insert-tags)
   ("C-c i" . org-id-get-create)
   ("C-c C-o" . thanos/org-open-at-point)))

(use-package epa
  :defer t
  :config
  (setf epa-keys-select-method 'minibuffer
  epa-file-encrypt-to '("your-pgp-key")
  ;; Do not prompt for key selection, we are only using the above key.
  epa-file-select-keys 'silent))

(use-package shell
  :defer t
  :config
  (defun thanos/shell (n)
    "Create or switch to a shell buffer."
    (interactive "P")
    (let* ((num (if n (prefix-numeric-value n) nil))
           (buf-name (if num (format "*shell<%d>*" num) "*shell*")))
      (shell buf-name)))
  :bind (("C-c v" . thanos/shell)
         :map shell-mode-map
         ("C-l" . 'comint-clear-buffer))
  :hook ((shell-mode . (lambda () (display-line-numbers-mode -1)))))

(use-package esh-mode
  :defer t
  :config
  ;; Prompt
  (defun eshell-git-info ()
    "Return a string with git info."
    (when (eq (call-process "git" nil nil nil "rev-parse" "--is-inside-work-tree") 0)
      (let* ((branch-raw (shell-command-to-string "git rev-parse --abbrev-ref HEAD"))
             (branch (if (or (string-match-p "^fatal" branch-raw)
                             (string-match-p "^error" branch-raw))
                         "Unknown"
                       (string-trim branch-raw)))
             (dirty (not
                     (string= "" (string-trim (shell-command-to-string "git status --porcelain")))))
             (dirty-info (if dirty " ✎" " ✔")))
        (concat (propertize "⎇ " 'face 'modus-themes-fg-green-warmer)
                (propertize branch 'face 'modus-themes-fg-magenta-warmer)
                (propertize dirty-info 'face
                            (if dirty 'modus-themes-fg-red 'modus-themes-fg-green))))))

  (defun eshell-prompt-multiline ()
    "Eshell Multiline Git prompt."
    (let ((separator (propertize " | " 'face 'font-lock-comment-face))
          (hr (propertize (concat "\n" (make-string (/ (window-total-width) 2) ?─) "\n") 'face 'font-lock-comment-face))
          (dir (propertize (format "%s" (abbreviate-file-name (eshell/pwd))) 'face 'modus-themes-fg-yellow-warmer))
          (git-info (eshell-git-info))
          (time (propertize (format-time-string "%H:%M:%S") 'face 'font-lock-comment-face))
          (sign (if (= (user-uid) 0)
                    (propertize "\n#" 'face 'modus-themes-fg-blue-intense)
                  (propertize "\nλ" 'face 'modus-themes-fg-red-warmer))))
      (concat hr dir separator git-info separator time sign " ")))

  (setf eshell-prompt-function 'eshell-prompt-multiline
        eshell-highlight-prompt nil)
  ;; Aliases
  (defun eshell/o (file)
    "Open FILE."
    (find-file file))

  (defvar thanos/aliases
    '((ll . "ls -lah")
      (clear . clear-scrollback)))

  (defun thanos/set-eshell-aliases (aliases)
    "Set ALIASES as eshell aliases."
    ;; Remove aliases file
    (when (and eshell-aliases-file
               (file-exists-p eshell-aliases-file))
      (delete-file eshell-aliases-file))
    (mapc (lambda (alias)
            (let ((name (symbol-name (car alias)))
                  (command (cdr alias)))
              (eshell/alias name
                            (cond
                             ((stringp command) command)
                             ((symbolp command) (symbol-name command))
                             (t (error "Unsupported alias command type"))))))
          aliases))

  ;; Rebinds
  (defun thanos/eshell-clear ()
    "Interactive call for clear-scrollback."
    (interactive)
    (eshell/clear-scrollback))

  (defun thanos/eshell-preview-insert ()
    (interactive)
    (completion-preview-insert)
    ;; This funciton just deletes the extra space inserted after
    ;; completion.
    (delete-char -1))
  :bind (("C-c e" . eshell)
         :map eshell-mode-map
         ("C-l" . 'thanos/eshell-clear)
         ("<tab>" . 'thanos/eshell-preview-insert)
         ("C-M-i" . 'completion-at-point))
  :hook ((eshell-mode . (lambda ()
                          (thanos/set-eshell-aliases thanos/aliases)
                          (display-line-numbers-mode -1)
                          (eshell-cmpl-mode -1)))))

(use-package eat
  :ensure t
  :config
  (setf eshell-visual-commands nil
        eat-term-name "xterm-256color")
  :bind (("C-c V" . eat))
  :hook ((eshell-mode . eat-eshell-mode)
         (eshell-mode . eat-eshell-visual-command-mode)
         (eat-mode . (lambda () (visual-line-mode -1)))))

(use-package gnosis
  :init
  (define-prefix-command 'my/gnosis-map)
  (define-prefix-command 'my/gnosis-nodes-map)
  (define-prefix-command 'my/journal-map)
  :config
  (setf gnosis-journal-file (expand-file-name "journal.org.gpg" gnosis-journal-dir)
        gnosis-journal-as-gpg t
        gnosis-nodes-show-tags t
        gnosis-script-input-method-alist
        '((greek . "greek-polytonic")
          (cyrillic . "cyrillic-translit")))

  (setf gnosis-custom-values
        '((:tag "demo" (:proto (1 3) :anagnosis 3 :amnesia 0.45 :epignosis 0.5
                                 :agnoia 0.4 :lethe 2))
          (:tag "English" (:amnesia 0.55 :proto (0 1 3) :lethe 2
                                      :epignosis))
          (:tag "vocabulary" (:amnesia 0.65 :proto (0 1 3))))
        gnosis-nodes-timestring t)
  :bind (("C-c c" . 'my/gnosis-map)
         ("C-c n" . 'my/gnosis-nodes-map)
         ("C-c j" . 'my/journal-map)
         :map my/gnosis-map
         ("d" . 'gnosis-dashboard)
         ("j j" . 'gnosis-journal)
         ("j f" . 'gnosis-journal-find)
         ("n i" . 'gnosis-nodes-insert)
         ("n t" . 'gnosis-nodes-insert-template)
         ("S" . 'gnosis-nodes-db-sync)
         :map my/gnosis-nodes-map
         ("f" . 'gnosis-nodes-find)
         ("S" . 'gnosis-nodes-db-sync)
         ("t" . 'gnosis-nodes-insert-template)
         ("i" . 'gnosis-nodes-insert)
         ("d" . 'gnosis-nodes-delete-file)
         :map my/journal-map
         ("j" . 'gnosis-journal)
         ("f" . 'gnosis-journal-find)
         :map gnosis-nodes-mode-map
         ("C-c i" . 'org-id-get-create))
  :custom
  (gnosis-vc-auto-push t)
  (gnosis-default-average-review-period 30)
  (gnosis-algorithm-day-start-hour 3))

$ curl -sL https://thanosapollo.org/key.asc | gpg --import