add pomodoro

org/elpa/pomidor-20240601.1617/pomidor-autoloads.el

@@ -0,0 +1,30 @@
+;;; pomidor-autoloads.el --- automatically extracted autoloads (do not edit)   -*- lexical-binding: t -*-
+;; Generated by the `loaddefs-generate' function.
+
+;; This file is part of GNU Emacs.
+
+;;; Code:
+
+(add-to-list 'load-path (or (and load-file-name (directory-file-name (file-name-directory load-file-name))) (car load-path)))
+
+
+
+;;; Generated autoloads from pomidor.el
+
+(autoload 'pomidor "pomidor" "\
+A simple and cool pomodoro technique timer." t)
+(register-definition-prefixes "pomidor" '("pomidor-"))
+
+;;; End of scraped data
+
+(provide 'pomidor-autoloads)
+
+;; Local Variables:
+;; version-control: never
+;; no-byte-compile: t
+;; no-update-autoloads: t
+;; no-native-compile: t
+;; coding: utf-8-emacs-unix
+;; End:
+
+;;; pomidor-autoloads.el ends here

org/elpa/pomidor-20240601.1617/pomidor-pkg.el

@@ -0,0 +1,16 @@
+(define-package "pomidor" "20240601.1617" "Simple and cool pomodoro timer"
+  '((emacs "24.3")
+    (alert "1.2")
+    (dash "2.17.0"))
+  :commit "de71c34a1a9aff745181107094d3389816dbeca5" :authors
+  '(("TatriX" . "tatrics@gmail.com"))
+  :maintainers
+  '(("TatriX" . "tatrics@gmail.com"))
+  :maintainer
+  '("TatriX" . "tatrics@gmail.com")
+  :keywords
+  '("tools" "time" "applications" "pomodoro technique")
+  :url "https://github.com/TatriX/pomidor")
+;; Local Variables:
+;; no-byte-compile: t
+;; End:

org/elpa/pomidor-20240601.1617/pomidor.el

@@ -0,0 +1,715 @@
+;;; pomidor.el --- Simple and cool pomodoro timer
+
+;; Author: TatriX <tatrics@gmail.com>
+;; URL: https://github.com/TatriX/pomidor
+;; Keywords: tools, time, applications, pomodoro technique
+;; Version: 0.6.2
+;; Package-Requires: ((emacs "24.3") (alert "1.2") (dash "2.17.0"))
+
+;; This program is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 2, or (at your option)
+;; any later version.
+;;
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; pomidor is a simple and cool
+;; [[http://www.pomodorotechnique.com/][pomodoro technique]] timer.
+
+;;; Code:
+
+(require 'cl-lib)
+(require 'alert)
+(require 'dash)
+(require 'json)
+(require 'parse-time)
+
+;;; Customs
+(defgroup pomidor nil
+  "Customs for `pomidor'"
+  :group 'productivity)
+
+(defcustom pomidor-buffer-name "*pomidor*"
+  "Name of the pomidor buffer."
+  :type 'string :group 'pomidor)
+
+(defcustom pomidor-history-buffer-name "*pomidor-history*"
+  "Name of the pomidor history buffer."
+  :type 'string :group 'pomidor)
+
+(defcustom pomidor-seconds (* 25 60)
+  "Time length of a Podomoro round."
+  :type 'integer :group 'pomidor)
+
+(defcustom pomidor-break-seconds (* 5 60)
+  "Time length of a Podomoro break."
+  :type 'integer :group 'pomidor)
+
+(defcustom pomidor-update-interval 60
+  "Interval in seconds when pomidor should run hooks and play overwork sounds."
+  :type 'integer :group 'pomidor)
+
+(defcustom pomidor-confirm-end-break t
+  "If t ask for confirmation before ending a break and starting new a pomodoro."
+  :type 'boolean :group 'pomidor)
+
+;;; Vars
+(defcustom pomidor-time-format "%H:%M:%S"
+  "Time format for podomoro clock."
+  :type 'string :group 'pomidor)
+
+(defcustom pomidor-history-date-format "%Y-%m-%dT%H:%M:%S"
+  "Date format used to save the session ended value."
+  :type 'string :group 'pomidor)
+
+(defcustom pomidor-duration-format "%H:%M:%S"
+  "Time format for duration intervals."
+  :type 'string :group 'pomidor)
+
+(defconst pomidor-dir (file-name-directory (or load-file-name buffer-file-name))
+  "Pomidor directory in which sounds store.")
+
+(defcustom pomidor-sound-tick (expand-file-name (concat pomidor-dir "tick.wav"))
+  "Tick sound during a pomoro run."
+  :type '(file :must-match t)
+  :group 'pomidor)
+
+(defcustom pomidor-sound-tack (expand-file-name (concat pomidor-dir "tack.wav"))
+  "Tick sound during a pomoro run."
+  :type '(file :must-match t)
+  :group 'pomidor)
+
+(defcustom pomidor-sound-overwork (expand-file-name (concat pomidor-dir "overwork.wav"))
+  "Overwork sound."
+  :type '(file :must-match t)
+  :group 'pomidor)
+
+(defcustom pomidor-sound-break-over (expand-file-name (concat pomidor-dir "overwork.wav"))
+  "Break over sound."
+  :type '(file :must-match t)
+  :group 'pomidor)
+
+(defcustom pomidor-save-session-file (expand-file-name "pomidor-session.json" user-emacs-directory)
+  "Pomidor session store file."
+  :type '(file :must-match t)
+  :group 'pomidor)
+
+(defcustom pomidor-breaks-before-long 4
+  "How many short breaks before the long break."
+  :type 'integer :group 'pomidor)
+
+(defcustom pomidor-long-break-seconds (* 20 60)
+  "Time length of a Podomoro long break."
+  :type 'integer :group 'pomidor)
+
+;; libnotify for some reason can't display svg
+(defvar pomidor-icon (concat data-directory "images/icons/hicolor/16x16/apps/emacs.png")
+  "Default pomidor icon.")
+
+(defun pomidor-default-alert-message ()
+  "Default pomidor alert message if any."
+  (cond
+   ((and (pomidor-overwork-p) (pomidor-should-long-break-p))
+    (format "Take a long break!\nOverwork: [%s]"
+            (format-time-string "%H:%M:%S" (pomidor-overwork-duration) t)))
+   ((pomidor-overwork-p)
+    (format "Take a break!\nOverwork: [%s]"
+            (format-time-string "%H:%M:%S" (pomidor-overwork-duration) t)))
+   ((pomidor-break-over-notify-p)
+    (format "Go back to work!\nBreak: [%s]"
+            (format-time-string "%H:%M:%S" (pomidor-break-duration) t)))))
+
+(defun pomidor-default-alert ()
+  "Default pomidor alert."
+  (let ((message (pomidor-default-alert-message)))
+    (when message
+      (alert message
+             :severity 'normal
+             :icon pomidor-icon
+             :title "Pomidor"
+             :category 'pomidor))))
+
+(defcustom pomidor-alert #'pomidor-default-alert
+  "Pomidor alert function.
+To disable alerts, set to nil."
+  :type '(choice (const nil)
+                 function)
+  :group 'pomidor)
+
+(defun pomidor-play-sound-file-emacs (file)
+  "Play FILE by starting new Emacs process."
+  (if (fboundp 'play-sound-internal)
+      (start-process "pomidor-play-sound-file-emacs"
+                     nil
+                     (car command-line-args)
+                     "-Q"
+                     "--batch"
+                     "--eval" (format "(play-sound-file \"%s\")" file))
+    (warn "This Emacs binary lacks sound support")))
+
+(defcustom pomidor-play-sound-file #'pomidor-play-sound-file-emacs
+  "Function to play sounds (preferably async).
+To disable sounds, set to nil."
+  :type '(choice (const nil)
+                 function)
+  :group 'pomidor)
+
+(defvar pomidor-update-hook nil)
+
+;;; Faces
+(defface pomidor-time-face
+  '((t (:height 4.0)))
+  "pomidor face for time"
+  :group 'pomidor)
+
+(defface pomidor-date-face
+  '((t (:height 4.0)))
+  "pomidor face for date"
+  :group 'pomidor)
+
+(defface pomidor-timer-face
+  '((t (:height 5.0)))
+  "pomidor face for timer"
+  :group 'pomidor)
+
+(defface pomidor-work-face
+  '((t (:inherit success)))
+  "pomidor face for work"
+  :group 'pomidor)
+
+(defface pomidor-overwork-face
+  '((t (:inherit warning)))
+  "pomidor face for overwork"
+  :group 'pomidor)
+
+(defface pomidor-break-face
+  '((t (:inherit font-lock-keyword-face)))
+  "pomidor face for break"
+  :group 'pomidor)
+
+(defface pomidor-skip-face
+  '((t (:inherit font-lock-comment-face)))
+  "pomidor face for skip"
+  :group 'pomidor)
+
+
+;;; Vars
+(defvar pomidor-timer nil
+  "Pomidor timer.")
+
+(defvar pomidor-global-state nil
+  "Pomidor global state.")
+
+(defvar pomidor-graph-char ?█
+  "Pomidor char for displaying tubes.")
+
+(defvar pomidor-header-separator " — "
+  "Pomidor string to separate time and duration in header.")
+
+(defvar pomidor-header-session-name-separator " : "
+  "Pomidor string to separate the regular header from the session name in history mode.")
+
+(defvar pomidor--current-history-session nil
+  "Hold the current visible pomidor history snapshot.")
+
+(defvar pomidor--count-short-breaks 0
+  "Pomidor integer of how many short breaks we have before a long break.")
+
+(defvar pomidor--system-on-hold-p nil
+  "Pomidor control of hold in system.")
+
+;;; Private
+
+(defun pomidor--current-state ()
+  "Return current state."
+  (car (last pomidor-global-state)))
+
+(defun pomidor--reset ()
+  "Delete current global state."
+  (setq pomidor-global-state (list (pomidor--make-state))))
+
+(defun pomidor--make-state ()
+  "Make pomidor state."
+  (list :started (current-time)
+        :break nil
+        :stopped nil
+        :snooze nil))
+
+(defun pomidor--started (state)
+  "Return started time for STATE."
+  (plist-get state :started))
+
+(defun pomidor--break (state)
+  "Return break time for STATE."
+  (plist-get state :break))
+
+(defun pomidor--stopped (state)
+  "Return stopped time for STATE.
+It's a time when user started a new timer after this one."
+  (plist-get state :stopped))
+
+(defun pomidor--ended (state)
+  "Return ended time for STATE.
+It's either stopped time or current time."
+  (or (pomidor--stopped state) (current-time)))
+
+(defun pomidor--work-duration (state)
+  "Return work time for STATE."
+  (let* ((started (pomidor--started state))
+         (ended (or (pomidor--break state) (pomidor--ended state)))
+         (work (time-subtract ended started))
+         (max (seconds-to-time pomidor-seconds)))
+    (if (time-less-p work max)
+        work
+      max)))
+
+(defun pomidor--overwork-duration (state)
+  "Return overwork time for STATE or nil."
+  ;; (cur - started) - (cur - break) - max
+  (let* ((started (pomidor--started state))
+         (break (or (pomidor--break state) (pomidor--ended state)))
+         (work (pomidor--work-duration state))
+         (ended (pomidor--ended state))
+         (max (seconds-to-time pomidor-seconds))
+         (overwork (time-subtract (time-subtract (time-subtract ended started)
+                                                 (time-subtract ended break))
+                                  max)))
+    (when (> (time-to-seconds overwork) 0)
+      overwork)))
+
+(defun pomidor-running-p ()
+  "Return t if pomidor is running right now."
+  (timerp pomidor-timer))
+
+(defun pomidor-overwork-p ()
+  "Return t if current state is overwork."
+  (let* ((state (pomidor--current-state))
+         (overwork (pomidor--overwork-duration state)))
+    (and overwork (null (pomidor--break state)))))
+
+(defun pomidor-should-long-break-p ()
+  "Return t if current state should take a long break."
+  (cl-equalp pomidor--count-short-breaks (1+ pomidor-breaks-before-long)))
+
+(defun pomidor-break-over-notify-p ()
+  "Return t if current break is over and user should be notified about it.
+To snooze the notification use `pomidor-break'."
+  (and (pomidor-break-over-p) (not (pomidor-snooze-p))))
+
+(defun pomidor-break-over-p ()
+  "Return t if current break is over."
+  (let* ((state (pomidor--current-state))
+         (break (pomidor--break-duration state))
+         (expected-break-seconds (if (pomidor-should-long-break-p)
+                                     pomidor-long-break-seconds
+                                   pomidor-break-seconds)))
+    (and break (> (time-to-seconds break) expected-break-seconds))))
+
+(defun pomidor-snooze-p ()
+  "Return t if user snooze end of break alarm."
+  (plist-get (pomidor--current-state) :snooze))
+
+(defun pomidor--total-duration (state)
+  "Return total time for STATE."
+  (time-subtract (pomidor--ended state) (pomidor--started state)))
+
+(defun pomidor--break-duration (state)
+  "Return break time for STATE."
+  (let ((break (pomidor--break state)))
+    (and break (time-subtract (pomidor--ended state) break))))
+
+(defun pomidor--format-header (time state face)
+  "Return formated header for TIME with FACE."
+  (let ((freezed-time (plist-get state :session-ended)))
+    (concat (pomidor--with-face (concat (pomidor--format-time (or freezed-time (current-time)))
+                                        pomidor-header-separator)
+                                'pomidor-time-face)
+            (propertize (pomidor--format-duration time)
+                        'face `(:inherit (,face pomidor-timer-face)))
+            (when (eq major-mode 'pomidor-history-mode)
+              (pomidor--with-face (concat pomidor-header-session-name-separator
+                                          (format-time-string "%Y-%m-%d" freezed-time))
+                                  'pomidor-date-face)))))
+
+(defun pomidor--header (state)
+  "Return header."
+  (let* ((break (pomidor--break-duration state))
+         (overwork (pomidor--overwork-duration state))
+         (work (pomidor--work-duration state)))
+    (cond
+     (break (pomidor--format-header break state 'pomidor-break-face))
+     (overwork (pomidor--format-header overwork state 'pomidor-overwork-face))
+     (work (pomidor--format-header work state 'pomidor-work-face)))))
+
+
+(defun pomidor--format-time (time)
+  "Format TIME as of `pomidor-time-format'."
+  (format-time-string pomidor-time-format time))
+
+(defun pomidor--format-duration (time)
+  "Format TIME as of `pomidor-duration-format'.
+TIME may be nil."
+  (format-time-string pomidor-duration-format (or time (seconds-to-time 0)) t))
+
+(defun pomidor--window-width ()
+  "Return pomidor buffer width in chars."
+  (window-total-width (get-buffer-window (pomidor--get-buffer-create))))
+
+(defun pomidor--with-face (string face)
+  "Retrun STRING with FACE."
+  (propertize string 'font-lock-face face))
+
+(defun pomidor--format-time-string (time face)
+  "Format graph string for TIME with FACE."
+  (pomidor--with-face (make-string (round (/ (time-to-seconds time)
+                                     (/ (float pomidor-seconds) (/ (pomidor--window-width) 2))))
+                                   pomidor-graph-char)
+                      face))
+
+(defun pomidor--graph (work overwork break)
+  "Format graph based on WORK, OVERWORK and BREAK time."
+  (concat
+   (pomidor--format-time-string work 'pomidor-work-face)
+   (let ((skip (- pomidor-seconds (time-to-seconds work))))
+     (when (> skip 0)
+       (pomidor--format-time-string (seconds-to-time skip) 'pomidor-skip-face)))
+   (and overwork (pomidor--format-time-string overwork 'pomidor-overwork-face))
+   (and break (pomidor--format-time-string break 'pomidor-break-face))))
+
+(defun pomidor--play-sound-file (file)
+  "Play FILE using `pomidor-play-sound-file' function if any."
+  (when (and file (functionp pomidor-play-sound-file))
+    (funcall pomidor-play-sound-file file)))
+
+(defun pomidor--tick-tack (ellapsed)
+  "Play tick or tack based on ELLAPSED."
+  (pomidor--play-sound-file
+   (if (zerop (mod ellapsed 2))
+       pomidor-sound-tick
+     pomidor-sound-tack)))
+
+(defun pomidor--update ()
+  "Update pomidor state."
+  (let* ((state (pomidor--current-state))
+         (total (pomidor--total-duration state))
+         (ellapsed (round (time-to-seconds total))))
+    (pomidor--tick-tack ellapsed)
+    (when (zerop (mod ellapsed pomidor-update-interval))
+      (when (functionp pomidor-alert)
+        (funcall pomidor-alert))
+      (run-hooks 'pomidor-update-hook)
+      (cond
+       ((pomidor-overwork-p)
+        (pomidor--play-sound-file pomidor-sound-overwork))
+       ((pomidor-break-over-notify-p)
+        (pomidor--play-sound-file pomidor-sound-break-over)))))
+  (pomidor--render (pomidor--get-buffer-create) pomidor-global-state))
+
+(defun pomidor--render (buffer states)
+  "Render pomidor state."
+  (when (get-buffer-window buffer t)
+    (with-current-buffer buffer
+      (read-only-mode -1)
+      (erase-buffer)
+      (insert (pomidor--header (car (last states)))
+              "\n")
+      (cl-loop
+       for i from 1
+       for state in states
+
+       as work = (pomidor--work-duration state)
+       as overwork = (pomidor--overwork-duration state)
+       as break = (pomidor--break-duration state)
+       as total = (pomidor--total-duration state)
+
+       with sum-work = (seconds-to-time 0)
+       with sum-overwork = (seconds-to-time 0)
+       with sum-break = (seconds-to-time 0)
+       with sum-total = (seconds-to-time 0)
+
+       do (progn
+            (setq sum-work (time-add sum-work work)
+                  sum-total (time-add sum-total total))
+            (when overwork
+              (setq sum-overwork (time-add sum-overwork overwork)))
+            (when break
+              (setq sum-break (time-add sum-break break)))
+            (insert
+             "\n     "
+             (make-string 79 ?-)
+             "\n"
+             (format "%3d) [%s] | [%s] | [%s] | [%s]\t\t %s → %s"
+                     i
+                     (pomidor--with-face (pomidor--format-duration work) 'pomidor-work-face)
+                     (pomidor--with-face (pomidor--format-duration overwork) 'pomidor-overwork-face)
+                     (pomidor--with-face (pomidor--format-duration break) 'pomidor-break-face)
+                     (pomidor--format-duration total)
+                     (pomidor--format-time (pomidor--started state))
+                     (pomidor--format-time (pomidor--ended state)))
+             "\n     "
+             (pomidor--graph work overwork break)))
+       finally
+       (insert "\n     "
+               (make-string 79 ?-)
+               "\n\n"
+               (format "     Work\t[%s]\n"
+                       (pomidor--with-face (pomidor--format-duration sum-work) 'pomidor-work-face))
+               (format "     Overwork\t[%s]\n"
+                       (pomidor--with-face (pomidor--format-duration sum-overwork) 'pomidor-overwork-face))
+               (format "     Break\t[%s]\n"
+                       (pomidor--with-face (pomidor--format-duration sum-break) 'pomidor-break-face))
+               (format "     Total\t[%s]\n"
+                       (pomidor--format-duration sum-total)))
+       )
+      (read-only-mode +1))))
+
+(defun pomidor--get-buffer-create ()
+  "Return a pomidor buffer."
+  (get-buffer-create pomidor-buffer-name))
+
+(defun pomidor--get-history-buffer-create ()
+  "Create a history pomidor buffer."
+  (get-buffer-create pomidor-history-buffer-name))
+
+(defun pomidor--cancel-timer ()
+  "Cancel pomidor timer."
+  (when (timerp pomidor-timer)
+    (cancel-timer pomidor-timer)
+    (setq pomidor-timer nil)))
+
+(defun pomidor--read-session (preserve-timestamp?)
+  "Read the saved sessions."
+  (let* ((json-object-type 'plist)
+         (json-array-type 'list)
+         (data (json-read-file pomidor-save-session-file)))
+    (if preserve-timestamp?
+        data
+      (-map (lambda (pomidor)
+              (-map (lambda (v) (if (stringp v)
+                               (parse-iso8601-time-string v)
+                             v))
+                    pomidor))
+            data))))
+
+(defun pomidor--valid-sessions-dates (session-dates direction)
+  "Get valid date of SESSION-DATES from history data to move in correct DIRECTION."
+  (let ((fun (lambda (v)
+               (if (cl-equalp direction :backward)
+                   (time-less-p v pomidor--current-history-session)
+                 (time-less-p pomidor--current-history-session v)))))
+    (if pomidor--current-history-session
+        (-filter (lambda (dt) (funcall fun dt)) session-dates)
+      session-dates)))
+
+;;; Public
+
+(defvar pomidor-mode-map
+  (let ((map (make-keymap)))
+    (define-key map (kbd "q") #'quit-window)
+    (define-key map (kbd "Q") #'pomidor-quit)
+    (define-key map (kbd "R") #'pomidor-reset)
+    (define-key map (kbd "h") #'pomidor-hold)
+    (define-key map (kbd "H") #'pomidor-unhold)
+    (define-key map (kbd "RET") #'pomidor-stop)
+    (define-key map (kbd "SPC") #'pomidor-break)
+    (suppress-keymap map)
+    map))
+
+(defun pomidor-work-duration ()
+  "Return current work duration."
+  (pomidor--work-duration (pomidor--current-state)))
+
+(defun pomidor-overwork-duration ()
+  "Return current overwork duration."
+  (pomidor--overwork-duration (pomidor--current-state)))
+
+(defun pomidor-break-duration ()
+  "Return current break duration."
+  (pomidor--break-duration (pomidor--current-state)))
+
+(defun pomidor-total-duration ()
+  "Return current total duration."
+  (pomidor--total-duration (pomidor--current-state)))
+
+(defun pomidor-quit ()
+  "Turn off Pomidor."
+  (interactive)
+  (when (y-or-n-p "Are you sure you want to turn off pomidor? ")
+    (kill-buffer (pomidor--get-buffer-create))))
+
+(defun pomidor--reset-long-break-counter ()
+  "Reset the pomidor counter after `pomidor-breaks-before-long' short breaks."
+  (when (pomidor-should-long-break-p)
+    (setq pomidor--count-short-breaks 0)))
+
+(defun pomidor-break ()
+  "Break current working pomidor."
+  (interactive)
+  (let ((state (pomidor--current-state)))
+    (if (pomidor--break state)
+        (progn
+          (plist-put state :snooze t)
+          (when (or (not pomidor-confirm-end-break)
+                    (yes-or-no-p "Stop break and start new pomidor?"))
+            (pomidor-stop))
+          (pomidor--reset-long-break-counter))
+      (progn
+        (plist-put state :break (current-time))
+        (setq pomidor--count-short-breaks (1+ pomidor--count-short-breaks))))))
+
+(defun pomidor-reset ()
+  "Delete current global state."
+  (interactive)
+  (when (y-or-n-p "Are you sure you want reset pomidors? ")
+    (setq pomidor--count-short-breaks 0)
+    (pomidor--reset)))
+
+(defun pomidor-stop ()
+  "Stop current working pomidor."
+  (interactive)
+  (let ((state (pomidor--current-state)))
+    (plist-put state :stopped (current-time)))
+  (pomidor--reset-long-break-counter)
+  (nconc pomidor-global-state (list (pomidor--make-state))))
+
+(defun pomidor-hold ()
+  "Stop the current working pomidor and puts the system on hold."
+  (interactive)
+  (let ((state (pomidor--current-state)))
+    (plist-put state :stopped (current-time)))
+  (setq pomidor--system-on-hold-p t)
+  (pomidor--cancel-timer))
+
+(defun pomidor-unhold ()
+  "Unhold and start a new pomidor."
+  (interactive)
+  (when pomidor--system-on-hold-p
+    (nconc pomidor-global-state (list (pomidor--make-state)))
+    (setq pomidor--system-on-hold-p nil)
+    (setq pomidor-timer (run-at-time nil 1 #'pomidor--update))))
+
+(defun pomidor-save-session ()
+  "Save the current session in a file."
+  (interactive)
+  (let ((time-asked-to-save (current-time)))
+    (pomidor-quit)
+    (plist-put (pomidor--current-state) :stopped time-asked-to-save)
+    (let* ((fmt-time (lambda (time) (when time (format-time-string pomidor-history-date-format time))))
+           (history-state (if (file-exists-p pomidor-save-session-file)
+                              (pomidor--read-session :preserve-iso-timestamp)
+                            (list)))
+           (global-state (-map (lambda (pomidor)
+                                 (list :started (funcall fmt-time (plist-get pomidor :started))
+                                       :break (funcall fmt-time (plist-get pomidor :break))
+                                       :stopped (funcall fmt-time (plist-get pomidor :stopped))
+                                       :snooze (plist-get pomidor :snooze)
+                                       :session-ended (funcall fmt-time time-asked-to-save)))
+                               pomidor-global-state))
+           (new-history (append history-state global-state))
+           (new-history (-filter (lambda (pomidor) (or (plist-get pomidor :stopped)
+                                                  (plist-get pomidor :break)
+                                                  (plist-get pomidor :snooze)))
+                                 new-history)))
+      (with-temp-file pomidor-save-session-file
+        (insert (json-encode (vconcat new-history))))))
+  (message "Pomidor session saved!"))
+
+(defun pomidor-history-previous ()
+  "Move backward in your pomidor history."
+  (interactive)
+  (let* ((session-data (pomidor--read-session nil))
+         (session-dates (-map (lambda (pomidor)
+                                (plist-get pomidor :session-ended))
+                              session-data)))
+    (if (= (length session-dates) 0)
+        (message "You have no session saved.")
+      (let* ((valid-session-dates (pomidor--valid-sessions-dates session-dates :backward)))
+        (if valid-session-dates
+            (progn
+              (setq pomidor--current-history-session (car (last valid-session-dates)))
+              (pomidor--render
+               (pomidor--get-history-buffer-create)
+               (-filter (lambda (pomidor)
+                          (equal (car (last valid-session-dates))
+                                 (plist-get pomidor :session-ended)))
+                        session-data)))
+          (message "History is over, go forward."))))))
+
+(defun pomidor-history-next ()
+  "Move forward in your pomidor history."
+  (interactive)
+  (let* ((session-data (pomidor--read-session nil))
+         (session-dates (-map (lambda (pomidor)
+                                (plist-get pomidor :session-ended))
+                              session-data)))
+    (if (= (length session-dates) 0)
+        (message "You have no sessions saved.")
+      (let* ((valid-session-dates (pomidor--valid-sessions-dates session-dates :forward)))
+        (if valid-session-dates
+            (progn
+              (setq pomidor--current-history-session (car valid-session-dates))
+              (pomidor--render
+               (pomidor--get-history-buffer-create)
+               (-filter (lambda (pomidor)
+                          (equal (car valid-session-dates)
+                                 (plist-get pomidor :session-ended)))
+                        session-data)))
+          (message "History is over, go backward."))))))
+
+
+(defun pomidor-history ()
+  "A simple pomodoro history feature. Compare your work over time."
+  (interactive)
+  (if (not (file-exists-p pomidor-save-session-file))
+      (message "You should save at least one session first.")
+    (switch-to-buffer (pomidor--get-history-buffer-create))
+    (unless (eq major-mode 'pomidor-history-mode)
+      (pomidor-history-mode))
+    (pomidor-history-previous)))
+
+(defvar pomidor-history-mode-map
+  (let ((map (make-keymap)))
+    (define-key map (kbd "q") #'quit-window)
+    (define-key map (kbd "n") #'pomidor-history-next)
+    (define-key map (kbd "p") #'pomidor-history-previous)
+    (suppress-keymap map)
+    map))
+
+(define-derived-mode pomidor-history-mode special-mode "pomidor-history"
+  "Major mode for Pomidor History.
+
+\\{pomidor-history-mode-map}"
+  (setq pomidor-timer nil)
+  (setq pomidor--current-history-session nil))
+
+(define-derived-mode pomidor-mode special-mode "pomidor"
+  "Major mode for Pomidor.
+
+\\{pomidor-mode-map}"
+  (setq pomidor-timer (run-at-time nil 1 #'pomidor--update))
+  (setq-local tab-width 8)
+  (add-hook 'kill-buffer-hook #'pomidor--cancel-timer nil t)
+  (pomidor--reset))
+
+;;;###autoload
+(defun pomidor ()
+  "A simple and cool pomodoro technique timer."
+  (interactive)
+  (switch-to-buffer (pomidor--get-buffer-create))
+  (unless (eq major-mode 'pomidor-mode)
+    (setq pomidor--count-short-breaks 0)
+    (pomidor-mode))
+  (pomidor--update))
+
+
+(provide 'pomidor)
+
+;;; pomidor.el ends here

org/init.el

@@ -328,6 +328,43 @@
 (when kmn/is-termux
     (load "~/.emacs.d.profiles/org/config-org-mobile.el"))
 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; pomidor
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(use-package pomidor
+  :bind (("C-w p" . pomidor))
+  :config (setq pomidor-alert nil
+                pomidor-sound-tick nil
+                pomidor-sound-tack nil
+                pomidor-sound-overwork nil
+                pomidor-sound-break-over nil)
+  :hook (pomidor-mode . (lambda ()
+                          (display-line-numbers-mode -1) ; Emacs 26.1+
+                          (setq left-fringe-width 0 right-fringe-width 0)
+                          (setq left-margin-width 2 right-margin-width 0)
+                          ;; force fringe update
+                          (set-window-buffer nil (current-buffer)))))
+
+(setq pomidor-update-interval 30) ; seconds
+(setq pomidor-seconds (* 25 60)) ; 25 minutes for the work period
+(setq pomidor-warmup-seconds (* 5 60)) ; 5 minutes for warmup period
+(setq pomidor-break-seconds (* 5 60)) ; 5 minutes break time
+(setq pomidor-breaks-before-long 4) ; wait 4 short breaks before long break
+(setq pomidor-long-break-seconds (* 20 60)) ; 20 minutes long break time
+
+(defun my-pomidor-update-hook ()
+  (let* ((state (pomidor--current-state))
+         (total (pomidor--total-duration state))
+         (ellapsed (round (time-to-seconds total))))
+      (if (<= ellapsed pomidor-warmup-seconds)
+        (setq pomidor-header-separator " 🌡️↑ ")
+        (setq pomidor-header-separator " — ")
+      )
+  )
+)
+(add-hook 'pomidor-update-hook #'my-pomidor-update-hook)
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ; origami + super agenda config
 (defvar ap/org-super-agenda-auto-hide-groups
@@ -372,7 +409,8 @@
  '(custom-safe-themes
    '("dde643b0efb339c0de5645a2bc2e8b4176976d5298065b8e6ca45bc4ddf188b7" "bfc0b9c3de0382e452a878a1fb4726e1302bf9da20e69d6ec1cd1d5d82f61e3d" default))
  '(package-selected-packages
-   '((org-tidy org-auto-expand ox-pandoc ox-hugo org-super-agenda org-alert burnt-toast alert)
+   '(pomidor
+	 (org-tidy org-auto-expand ox-pandoc ox-hugo org-super-agenda org-alert burnt-toast alert)
 	 (devdocs devdocs-browser magit helm-ls-git xclip)
 	 (which-key all-the-icons revert-buffer-all centaur-tabs scratch persistent-scratch persp-mode rainbow-mode rainbow-delimiters markdown-mode focus zoom popwin dired-single diredfl doominhibitinhibit-modeline helpful helm helm-org dired-rainbow dired-rainbow-listing dired-single dash s origami modus-themes use-package)))
  '(safe-local-variable-values