pttm 0.1.0__py3-none-any.whl

pttm/__init__.py

@@ -0,0 +1,3 @@
+# Pomodoro TUI Package Public API
+from pttm.config import load_config, save_config, CONFIG_FILE
+from pttm.clock import make_clock_ascii

pttm/app.py

@@ -0,0 +1,183 @@
+import json
+import os
+from textual.app import App, ComposeResult
+from textual.widgets import Header, TabbedContent, TabPane, Label, Input
+from pttm.config import load_config, save_config
+from pttm.widgets.dashboard import Dashboard
+from pttm.widgets.settings_tab import SettingsTab
+from pttm.widgets.shortcuts_screen import ShortcutsScreen
+from pttm.widgets.timer_widget import TimerWidget
+from pttm.widgets.task_list_widget import TaskListWidget
+
+class PomodoroApp(App):
+    CSS_PATH = "pttm.css"
+    TITLE = "TS PMO"
+    COMMANDS = set()
+    ENABLE_COMMAND_PALETTE = False
+
+    BINDINGS = [
+        ("q", "quit", "Quit"),
+        ("s", "toggle_timer", "Start/Pause"),
+        ("r", "reset_timer", "Reset"),
+        ("ctrl+r", "reset_session", "Reset Session"),
+        ("k", "skip_timer", "Skip"),
+        ("f", "set_mode_focus", "Focus Mode"),
+        ("g", "set_mode_short", "Short Break"),
+        ("b", "set_mode_long", "Long Break"),
+        ("t", "focus_todo_input", "Focus Todo"),
+        ("ctrl+p", "toggle_shortcuts", "Shortcuts"),
+    ]
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.config = load_config()
+        # Log config to startup file next to config file
+        from pttm.config import CONFIG_FILE
+        log_dir = os.path.dirname(CONFIG_FILE)
+        if log_dir:
+            os.makedirs(log_dir, exist_ok=True)
+            log_file = os.path.join(log_dir, "pmo_startup.log")
+        else:
+            log_file = "pmo_startup.log"
+        try:
+            with open(log_file, "w") as f:
+                f.write(json.dumps(self.config, indent=4))
+        except Exception:
+            pass
+        self.active_task_id = None
+
+    def compose(self) -> ComposeResult:
+        # yield Header(show_clock=True)
+        with TabbedContent(initial="timer-tab"):
+            with TabPane("Timer", id="timer-tab"):
+                yield TimerWidget()
+            with TabPane("Tasks", id="tasks-tab"):
+                yield TaskListWidget()
+            with TabPane("Settings", id="settings-tab"):
+                yield SettingsTab()
+
+    def action_toggle_timer(self) -> None:
+        try:
+            timer_widget = self.query_one(TimerWidget)
+            timer_widget.is_running = not timer_widget.is_running #type: ignore
+        except Exception:
+            pass
+
+    def action_reset_timer(self) -> None:
+        try:
+            timer_widget = self.query_one(TimerWidget)
+            timer_widget.reset_timer_to_mode()
+        except Exception:
+            pass
+
+    def action_skip_timer(self) -> None:
+        try:
+            timer_widget = self.query_one(TimerWidget)
+            timer_widget.transition_to_next()
+        except Exception:
+            pass
+
+    def action_set_mode_focus(self) -> None:
+        try:
+            timer_widget = self.query_one(TimerWidget)
+            timer_widget.mode = "Focus"
+            timer_widget.reset_timer_to_mode()
+        except Exception:
+            pass
+
+    def action_set_mode_short(self) -> None:
+        try:
+            timer_widget = self.query_one(TimerWidget)
+            timer_widget.mode = "Short Break"
+            timer_widget.reset_timer_to_mode()
+        except Exception:
+            pass
+
+    def action_set_mode_long(self) -> None:
+        try:
+            timer_widget = self.query_one(TimerWidget)
+            timer_widget.mode = "Long Break"
+            timer_widget.reset_timer_to_mode()
+        except Exception:
+            pass
+
+    def action_focus_todo_input(self) -> None:
+        try:
+            input_box = self.query_one("#new-task-input", Input)
+            input_box.focus()
+        except Exception:
+            pass
+
+    def action_toggle_shortcuts(self) -> None:
+        if isinstance(self.screen, ShortcutsScreen):
+            self.pop_screen()
+        else:
+            self.push_screen(ShortcutsScreen())
+
+    def action_reset_session(self) -> None:
+        try:
+            timer_widget = self.query_one(TimerWidget)
+            timer_widget.is_running = False #type: ignore
+            timer_widget.completed_focus_sessions = 0
+            self.config["completed_focus_sessions"] = 0
+            save_config(self.config)
+
+            timer_widget.query_one("#session-count-display", Label).update("Completed: 0 sessions")
+            timer_widget.mode = "Focus"
+            timer_widget.reset_timer_to_mode()
+            self.notify("Pomodoro session reset completely.", title="Session Reset", severity="information")
+        except Exception:
+            pass
+
+    def update_active_task_display(self) -> None:
+        try:
+            timer_widget = self.query_one(TimerWidget)
+            active_label = timer_widget.query_one("#active-task-display", Label)
+
+            active_task = None
+            if self.active_task_id:
+                for task in self.config.get("tasks", []):
+                    if task["id"] == self.active_task_id:
+                        active_task = task
+                        break
+
+            if active_task:
+                active_label.update(f"Active Task: [bold #f9e2af]{active_task['title']}[/bold #f9e2af]")
+                timer_widget.query_one("#timer-clock").add_class("timer-clock-active")
+            else:
+                active_label.update("No active task selected")
+                timer_widget.query_one("#timer-clock").remove_class("timer-clock-active")
+        except Exception:
+            pass
+
+    def increment_active_task_pomodoro(self) -> None:
+        if not self.active_task_id:
+            return
+
+        for task in self.config["tasks"]:
+            if task["id"] == self.active_task_id:
+                task["pomodoros"] += 1
+                self.notify(f"Pomodoro recorded for: {task['title']}", title="Task Updated", severity="success") #type: ignore
+                break
+        save_config(self.config)
+
+        try:
+            task_list_widget = self.query_one(TaskListWidget)
+            task_list_widget.refresh_tasks()
+        except Exception:
+            pass
+
+    def on_settings_updated(self) -> None:
+        try:
+            timer_widget = self.query_one(TimerWidget)
+            if not timer_widget.is_running:
+                timer_widget.reset_timer_to_mode()
+        except Exception:
+            pass
+
+def main():
+    app = PomodoroApp()
+    app.run()
+
+if __name__ == "__main__":
+    main()

pttm/clock.py

@@ -0,0 +1,28 @@
+# Big blocky font digits for the clock
+DIGITS = {
+    '0': ["███", "█ █", "█ █", "█ █", "███"],
+    '1': [" █ ", "██ ", " █ ", " █ ", "███"],
+    '2': ["███", "  █", "███", "█  ", "███"],
+    '3': ["███", "  █", "███", "  █", "███"],
+    '4': ["█ █", "█ █", "███", "  █", "  █"],
+    '5': ["███", "█  ", "███", "  █", "███"],
+    '6': ["███", "█  ", "███", "█ █", "███"],
+    '7': ["███", "  █", "  █", "  █", "  █"],
+    '8': ["███", "█ █", "███", "█ █", "███"],
+    '9': ["███", "█ █", "███", "  █", "███"],
+    ':': ["   ", " █ ", "   ", " █ ", "   "],
+    ' ': ["   ", "   ", "   ", "   ", "   "]
+}
+
+def make_clock_ascii(seconds: int) -> str:
+    mins = seconds // 60
+    secs = seconds % 60
+    time_str = f"{mins:02d}:{secs:02d}"
+
+    lines = ["", "", "", "", ""]
+    for char in time_str:
+        char_lines = DIGITS.get(char, DIGITS[' '])
+        for idx in range(5):
+            lines[idx] += char_lines[idx] + "  "
+
+    return "\n".join(lines)

pttm/config.py

@@ -0,0 +1,53 @@
+import json
+import os
+import platformdirs
+
+CONFIG_PATH_ENV = os.getenv("PMO_CONFIG_PATH")
+if CONFIG_PATH_ENV:
+    CONFIG_FILE = CONFIG_PATH_ENV
+else:
+    CONFIG_DIR = platformdirs.user_config_dir("pttm", appauthor=False)
+    CONFIG_FILE = os.path.join(CONFIG_DIR, "pttm_config.json")
+
+DEFAULT_CONFIG = {
+    "settings": {
+        "focus_time": 25,
+        "short_break_time": 5,
+        "long_break_time": 15,
+        "long_break_interval": 4
+    },
+    "completed_focus_sessions": 0,
+    "tasks": [
+        {"id": "1", "title": "Task 1", "completed": True, "pomodoros": 1},
+        {"id": "2", "title": "Task 2", "completed": False, "pomodoros": 0},
+        {"id": "3", "title": "Task 3", "completed": False, "pomodoros": 0}
+    ]
+}
+
+def load_config():
+    if os.path.exists(CONFIG_FILE):
+        try:
+            with open(CONFIG_FILE, "r") as f:
+                config = json.load(f)
+                # Ensure all sections exist
+                if "settings" not in config:
+                    config["settings"] = DEFAULT_CONFIG["settings"]
+                if "tasks" not in config:
+                    config["tasks"] = DEFAULT_CONFIG["tasks"]
+                if "completed_focus_sessions" not in config:
+                    config["completed_focus_sessions"] = 0
+                return config
+        except Exception:
+            return DEFAULT_CONFIG.copy()
+    return DEFAULT_CONFIG.copy()
+
+def save_config(config):
+    try:
+        dir_name = os.path.dirname(CONFIG_FILE)
+        if dir_name:
+            os.makedirs(dir_name, exist_ok=True)
+        with open(CONFIG_FILE, "w") as f:
+            json.dump(config, f, indent=4)
+    except Exception:
+        pass
+

pttm/pttm.css

@@ -0,0 +1,483 @@
+/* App wide styling */
+Screen {
+    background: #11111b; /* deep obsidian navy */
+    min-width: 80;
+    min-height: 24;
+}
+
+/* Tabs */
+TabbedContent {
+    background: #11111b;
+    height: 1fr;
+}
+
+TabPane {
+    padding: 1 1;
+    background: #11111b;
+    height: 1fr;
+}
+
+Tabs {
+    background: #1e1e2e;
+    color: #cdd6f4;
+}
+
+Tabs:focus {
+    background: #313244;
+}
+
+Tab {
+    background: #1e1e2e;
+    color: #a6adc8;
+}
+
+Tab:hover {
+    background: #313244;
+    color: #f5c2e7;
+}
+
+Tab.--active {
+    background: #11111b;
+    color: #cba6f7;
+    text-style: bold;
+}
+
+/* Dashboard Columns */
+Dashboard {
+    width: 100%;
+    height: 1fr;
+    layout: horizontal;
+}
+
+/* Timer Widget Styling */
+TimerWidget {
+    background: #181825;
+    border: double #cba6f7;
+    border-title-align: center;
+    border-title-style: bold;
+    padding: 1 2;
+    width: 1fr;
+    min-width: 38;
+    height: 1fr;
+    layout: vertical;
+    align: center middle;
+    margin-right: 2;
+}
+
+#timer-title {
+    text-align: center;
+    width: 100%;
+    height: 1;
+    color: #f5c2e7;
+    text-style: bold;
+    margin-bottom: 1;
+}
+
+#active-task-display {
+    text-align: center;
+    width: 100%;
+    height: 1;
+    color: #a6adc8;
+    margin-bottom: 1;
+}
+
+#timer-clock {
+    width: 100%;
+    height: 9;
+    content-align: center middle;
+    color: #cba6f7;
+    text-style: bold;
+    background: #1e1e2e;
+    border: solid #313244;
+    margin-bottom: 1;
+    padding: 1 1;
+}
+
+.timer-clock-active {
+    color: #f9e2af !important;
+    border: solid #f9e2af !important;
+}
+
+#timer-controls {
+    width: 100%;
+    height: 3;
+    align: center middle;
+    margin-bottom: 1;
+}
+
+#timer-controls Button {
+    margin: 0 1 0 0;
+    background: transparent;
+    border: none;
+    height: 1;
+    padding: 0;
+    color: #cdd6f4;
+}
+
+#start-btn {
+    width: 12;
+}
+
+#skip-btn {
+    width: 6;
+}
+
+#reset-btn {
+    width: 7;
+}
+
+#timer-controls Button:hover, #timer-controls Button:focus {
+    color: #f5c2e7;
+    text-style: underline bold;
+}
+
+#manual-modes {
+    width: 100%;
+    height: 3;
+    align: center middle;
+    margin-bottom: 1;
+}
+
+#manual-modes Button {
+    margin: 0 1 0 0;
+    background: transparent;
+    border: none;
+    height: 1;
+    padding: 0;
+    color: #cdd6f4;
+}
+
+#mode-focus-btn {
+    width: 7;
+}
+
+#mode-short-btn {
+    width: 7;
+}
+
+#mode-long-btn {
+    width: 6;
+}
+
+#manual-modes Button:hover, #manual-modes Button:focus {
+    color: #f5c2e7;
+    text-style: underline bold;
+}
+
+#session-count-display {
+    text-align: center;
+    width: 100%;
+    height: 1;
+    color: #f9e2af;
+    text-style: bold;
+}
+
+/* Hidden class for toggle button */
+.hidden {
+    display: none;
+}
+
+/* Todo Panel Styling */
+TaskListWidget {
+    background: #181825;
+    border: double #cba6f7;
+    padding: 1 1;
+    width: 1fr;
+    min-width: 38;
+    height: 1fr;
+    layout: vertical;
+}
+
+#todo-title {
+    text-align: center;
+    width: 100%;
+    height: 1;
+    color: #cba6f7;
+    text-style: bold;
+    margin-bottom: 1;
+}
+
+#todo-input-row {
+    width: 100%;
+    height: 3;
+    margin-bottom: 1;
+    align: left middle;
+}
+
+#new-task-input {
+    width: 1fr;
+    background: #1e1e2e;
+    color: #cdd6f4;
+    border: solid #313244;
+}
+
+#new-task-input:focus {
+    border: solid #cba6f7;
+}
+
+#add-task-btn {
+    background: transparent;
+    border: none;
+    height: 3;
+    width: auto;
+    padding: 0 1;
+    color: #cba6f7;
+    margin-left: 1;
+}
+
+#add-task-btn:hover, #add-task-btn:focus {
+    color: #f5c2e7;
+    text-style: underline bold;
+}
+
+#tasks-container {
+    width: 100%;
+    height: 1fr;
+    border: none;
+}
+
+/* Task Item Styling */
+TaskItem {
+    layout: horizontal;
+    align: left middle;
+    width: 100%;
+    height: 3;
+    margin-bottom: 1;
+    padding: 0 1;
+    background: #1e1e2e;
+    border: solid #313244;
+}
+
+TaskItem:hover {
+    background: #313244;
+}
+
+TaskItem.active-task {
+    background: #45475a;
+    border: double #f9e2af;
+}
+
+.task-title {
+    width: 1fr;
+    margin: 0 1;
+    color: #cdd6f4;
+}
+
+.task-title.completed {
+    text-style: strike;
+    color: #585b70;
+}
+
+.task-edit-input {
+    width: 1fr;
+    margin: 0 1;
+    height: 1;
+    border: none;
+    background: #313244;
+    color: #cdd6f4;
+    padding: 0 1;
+}
+
+.task-pomo {
+    width: auto;
+    margin-right: 1;
+    color: #f38ba8;
+}
+
+/* Sleek Text Link Button Styling */
+.task-check-btn, .task-edit-btn, .task-save-btn, .task-select-btn, .task-delete-btn {
+    background: transparent;
+    border: none;
+    height: 1;
+    min-width: 0;
+    padding: 0;
+    margin: 0;
+}
+
+.task-check-btn {
+    width: 3;
+    color: #89b4fa;
+    text-style: bold;
+}
+
+.task-check-btn:hover, .task-check-btn:focus {
+    color: #b4befe;
+}
+
+.task-edit-btn {
+    color: #a6e3a1;
+    margin-left: 1;
+    width: 6;
+}
+
+.task-edit-btn:hover, .task-edit-btn:focus {
+    text-style: underline;
+}
+
+.task-save-btn {
+    color: #a6e3a1;
+    margin-left: 1;
+    width: 6;
+}
+
+.task-save-btn:hover, .task-save-btn:focus {
+    text-style: underline;
+}
+
+.task-select-btn {
+    color: #cdd6f4;
+    margin-left: 1;
+    width: 10;
+}
+
+.task-select-btn:hover, .task-select-btn:focus {
+    text-style: underline;
+}
+
+TaskItem.active-task .task-select-btn {
+    color: #fab387;
+    text-style: bold;
+}
+
+.task-delete-btn {
+    color: #f38ba8;
+    margin-left: 1;
+    width: 5;
+}
+
+.task-delete-btn:hover, .task-delete-btn:focus {
+    text-style: underline;
+}
+
+/* Settings Styling */
+#settings-form {
+    background: #181825;
+    border: double #cba6f7;
+    padding: 2 4;
+    max-width: 1fr;
+    align: center middle;
+    margin: 2 4;
+}
+
+.settings-title {
+    text-align: center;
+    width: 100%;
+    height: 1;
+    color: #cba6f7;
+    text-style: bold;
+    margin-bottom: 2;
+}
+
+.settings-row {
+    width: 100%;
+    height: 3;
+    align: left middle;
+    margin-bottom: 1;
+}
+
+.settings-label {
+    width: 30;
+    color: #cdd6f4;
+}
+
+#settings-form Input {
+    width: 1fr;
+    background: #1e1e2e;
+    color: #cdd6f4;
+    border: solid #313244;
+}
+
+#settings-form Input:focus {
+    border: solid #cba6f7;
+}
+
+#save-settings-btn {
+    margin-top: 2;
+    background: transparent;
+    border: none;
+    height: 1;
+    width: auto;
+    padding: 0;
+    color: #cba6f7;
+    text-style: bold;
+}
+
+#save-settings-btn:hover, #save-settings-btn:focus {
+    color: #f5c2e7;
+    text-style: underline bold;
+}
+
+#settings-status {
+    text-align: center;
+    width: 100%;
+    height: 1;
+    margin-top: 1;
+    text-style: bold;
+}
+
+/* Focused Task Items & Todo Help */
+TaskItem:focus {
+    background: #313244;
+    border: solid #cba6f7;
+}
+
+TaskItem.active-task:focus {
+    background: #585b70;
+    border: double #f9e2af;
+}
+
+#todo-help {
+    text-align: center;
+    width: 100%;
+    height: 1;
+    color: #a6adc8;
+    margin-top: 1;
+}
+
+/* Keyboard Shortcuts Overlay Styling */
+ShortcutsScreen {
+    align: center middle;
+    background: rgba(0, 0, 0, 0.7);
+}
+
+#shortcuts-dialog {
+    width: 90%;
+    max-width: 80;
+    height: 90%;
+    max-height: 28;
+    background: #181825;
+    border: double #cba6f7;
+    padding: 1 2;
+}
+
+#shortcuts-title {
+    text-align: center;
+    width: 100%;
+    height: 1;
+    color: #cba6f7;
+    text-style: bold;
+    margin-bottom: 1;
+}
+
+#shortcuts-content {
+    width: 100%;
+    height: 1fr;
+    margin-bottom: 1;
+}
+
+.section-header {
+    color: #f5c2e7;
+    margin-top: 1;
+    text-style: bold;
+}
+
+.shortcut-entry {
+    color: #cdd6f4;
+}
+
+#shortcuts-close-btn {
+    text-align: center;
+    width: 100%;
+    color: #a6adc8;
+    margin-top: 1;
+}

pttm/widgets/__init__.py

@@ -0,0 +1 @@
+# Widgets package

pttm/widgets/dashboard.py

@@ -0,0 +1,9 @@
+from textual.widget import Widget
+from textual.app import ComposeResult
+from pttm.widgets.timer_widget import TimerWidget
+from pttm.widgets.task_list_widget import TaskListWidget
+
+class Dashboard(Widget):
+    def compose(self) -> ComposeResult:
+        yield TimerWidget(id="timer-widget")
+        yield TaskListWidget(id="task-list-widget")

pttm/widgets/settings_tab.py

@@ -0,0 +1,65 @@
+from textual.widget import Widget
+from textual.app import ComposeResult
+from textual.widgets import Label, Input, Button
+from textual.containers import Horizontal, VerticalScroll
+from pttm.config import save_config
+
+class SettingsTab(Widget):
+    def compose(self) -> ComposeResult:
+        with VerticalScroll(id="settings-form"):
+            yield Label("POMODORO SETTINGS", classes="settings-title")
+
+            with Horizontal(classes="settings-row"):
+                yield Label("Focus Session (mins):", classes="settings-label")
+                yield Input(placeholder="25", id="setting-focus", restrict=r"^[0-9]*$")
+
+            with Horizontal(classes="settings-row"):
+                yield Label("Short Break (mins):", classes="settings-label")
+                yield Input(placeholder="5", id="setting-short", restrict=r"^[0-9]*$")
+
+            with Horizontal(classes="settings-row"):
+                yield Label("Long Break (mins):", classes="settings-label")
+                yield Input(placeholder="15", id="setting-long", restrict=r"^[0-9]*$")
+
+            with Horizontal(classes="settings-row"):
+                yield Label("Sessions before Long Break:", classes="settings-label")
+                yield Input(placeholder="4", id="setting-interval", restrict=r"^[0-9]*$")
+
+            yield Button("[apply & save]", id="save-settings-btn")
+            yield Label("", id="settings-status")
+
+    def on_mount(self) -> None:
+        config = self.app.config.get("settings", {}) #type: ignore
+        self.query_one("#setting-focus", Input).value = str(config.get("focus_time", 25))
+        self.query_one("#setting-short", Input).value = str(config.get("short_break_time", 5))
+        self.query_one("#setting-long", Input).value = str(config.get("long_break_time", 15))
+        self.query_one("#setting-interval", Input).value = str(config.get("long_break_interval", 4))
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "save-settings-btn":
+            try:
+                focus_time = int(self.query_one("#setting-focus", Input).value)
+                short_break = int(self.query_one("#setting-short", Input).value)
+                long_break = int(self.query_one("#setting-long", Input).value)
+                interval = int(self.query_one("#setting-interval", Input).value)
+
+                if focus_time <= 0 or short_break <= 0 or long_break <= 0 or interval <= 0:
+                    raise ValueError("All values must be positive integers.")
+
+                self.app.config["settings"] = { #type: ignore
+                    "focus_time": focus_time,
+                    "short_break_time": short_break,
+                    "long_break_time": long_break,
+                    "long_break_interval": interval
+                }
+                save_config(self.app.config) #type: ignore
+
+                status_label = self.query_one("#settings-status", Label)
+                status_label.update("[OK] Settings saved successfully!")
+                status_label.styles.color = "#a6e3a1"
+
+                self.app.on_settings_updated() #type: ignore
+            except ValueError as e:
+                status_label = self.query_one("#settings-status", Label)
+                status_label.update(f"[Error] {str(e)}")
+                status_label.styles.color = "#f38ba8"

pttm/widgets/shortcuts_screen.py

@@ -0,0 +1,40 @@
+from textual.screen import ModalScreen
+from textual.app import ComposeResult
+from textual.containers import Vertical, VerticalScroll
+from textual.widgets import Label
+
+class ShortcutsScreen(ModalScreen):
+    BINDINGS = [
+        ("escape", "dismiss_dialog", "Close"),
+        ("ctrl+p", "dismiss_dialog", "Close"),
+    ]
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="shortcuts-dialog"):
+            yield Label("KEYBOARD SHORTCUTS", id="shortcuts-title")
+
+            with VerticalScroll(id="shortcuts-content"):
+                yield Label("[bold]Global Controls[/bold]", classes="section-header")
+                yield Label("  q         - Quit App", classes="shortcut-entry")
+                yield Label("  s         - Start / Pause Timer", classes="shortcut-entry")
+                yield Label("  r         - Reset Timer", classes="shortcut-entry")
+                yield Label("  Ctrl+R    - Reset Entire Session", classes="shortcut-entry")
+                yield Label("  k         - Skip Session", classes="shortcut-entry")
+                yield Label("  f         - Switch to Focus Session", classes="shortcut-entry")
+                yield Label("  g         - Switch to Short Break", classes="shortcut-entry")
+                yield Label("  b         - Switch to Long Break", classes="shortcut-entry")
+                yield Label("  t         - Focus Todo Creation Box", classes="shortcut-entry")
+                yield Label("  Ctrl+P    - Toggle Keyboard Shortcuts", classes="shortcut-entry")
+
+                yield Label("", classes="spacer")
+                yield Label("[bold]Todo Checklist Controls[/bold]", classes="section-header")
+                yield Label("  Tab       - Navigate through checklist", classes="shortcut-entry")
+                yield Label("  Space     - Toggle task completion", classes="shortcut-entry")
+                yield Label("  Enter / f - Set task as active target", classes="shortcut-entry")
+                yield Label("  e         - Rename task title inline", classes="shortcut-entry")
+                yield Label("  d         - Delete task from checklist", classes="shortcut-entry")
+
+            yield Label("[ Close [esc] ]", id="shortcuts-close-btn")
+
+    def action_dismiss_dialog(self) -> None:
+        self.dismiss()

pttm/widgets/task_item.py

@@ -0,0 +1,109 @@
+from textual.widget import Widget
+from textual.app import ComposeResult
+from textual.widgets import Label, Input
+from textual.message import Message
+from textual import events
+
+class TaskItem(Widget):
+    """A widget representing a single task item."""
+    
+    can_focus = True
+    
+    class Toggle(Message):
+        def __init__(self, task_item: "TaskItem", completed: bool):
+            super().__init__()
+            self.task_item = task_item
+            self.completed = completed
+            
+    class Select(Message):
+        def __init__(self, task_item: "TaskItem"):
+            super().__init__()
+            self.task_item = task_item
+            
+    class Delete(Message):
+        def __init__(self, task_item: "TaskItem"):
+            super().__init__()
+            self.task_item = task_item
+
+    class Rename(Message):
+        def __init__(self, task_item: "TaskItem", new_title: str):
+            super().__init__()
+            self.task_item = task_item
+            self.new_title = new_title
+
+    def __init__(self, task_id: str, title: str, completed: bool, pomodoros: int, is_active: bool = False):
+        super().__init__()
+        self.task_id = task_id
+        self.title = title
+        self.completed = completed
+        self.pomodoros = pomodoros
+        self.is_active = is_active
+
+    def compose(self) -> ComposeResult:
+        check_char = "[x]" if self.completed else "[ ]"
+        yield Label(check_char, classes="task-check-lbl")
+        
+        title_cls = "task-title completed" if self.completed else "task-title"
+        yield Label(self.title, classes=title_cls)
+        yield Input(value=self.title, classes="task-edit-input hidden")
+        
+        yield Label(f"({self.pomodoros})", classes="task-pomo")
+
+    def on_key(self, event: events.Key) -> None:
+        key = event.key
+        if key == "space":
+            event.stop()
+            self.completed = not self.completed
+            self.post_message(self.Toggle(self, self.completed))
+            self.refresh_task_display()
+        elif key == "e":
+            event.stop()
+            self.start_editing()
+        elif key == "d":
+            event.stop()
+            self.post_message(self.Delete(self))
+        elif key in ("enter", "f"):
+            event.stop()
+            self.post_message(self.Select(self))
+
+    def refresh_task_display(self) -> None:
+        try:
+            check_lbl = self.query_one(".task-check-lbl", Label)
+            check_lbl.update("[x]" if self.completed else "[ ]")
+            title_lbl = self.query_one(".task-title", Label)
+            if self.completed:
+                title_lbl.add_class("completed")
+            else:
+                title_lbl.remove_class("completed")
+        except Exception:
+            pass
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        if "task-edit-input" in event.input.classes:
+            event.stop()
+            self.save_edit()
+
+    def start_editing(self) -> None:
+        try:
+            self.query_one(".task-title", Label).add_class("hidden")
+            edit_input = self.query_one(".task-edit-input", Input)
+            edit_input.remove_class("hidden")
+            edit_input.focus()
+        except Exception:
+            pass
+
+    def save_edit(self) -> None:
+        try:
+            edit_input = self.query_one(".task-edit-input", Input)
+            new_title = edit_input.value.strip()
+            if new_title:
+                self.title = new_title
+                label = self.query_one(".task-title", Label)
+                label.update(self.title)
+                self.post_message(self.Rename(self, self.title))
+                
+            self.query_one(".task-title", Label).remove_class("hidden")
+            edit_input.add_class("hidden")
+            self.focus()
+        except Exception:
+            pass

pttm/widgets/task_list_widget.py

@@ -0,0 +1,104 @@
+import uuid
+from textual.widget import Widget
+from textual.app import ComposeResult
+from textual.widgets import Label, Input
+from textual.containers import Horizontal, VerticalScroll
+from pttm.widgets.task_item import TaskItem
+from pttm.config import save_config
+
+class TaskListWidget(Widget):
+    """Widget to display the todo list and manage tasks."""
+
+    def compose(self) -> ComposeResult:
+        yield Label("TASK LIST", id="todo-title")
+
+        with Horizontal(id="todo-input-row"):
+            yield Input(placeholder="Add a new task...", id="new-task-input")
+
+        yield VerticalScroll(id="tasks-container")
+        # yield Label("Space: check | Enter/f: focus | e: edit | d: delete", id="todo-help")
+
+    def on_mount(self) -> None:
+        self.refresh_tasks()
+
+    def refresh_tasks(self) -> None:
+        container = self.query_one("#tasks-container")
+
+        # Clear existing tasks
+        for child in list(container.children):
+            child.remove()
+
+        # Add tasks from app config
+        for task in self.app.config.get("tasks", []): #type: ignore
+            is_active = (task["id"] == self.app.active_task_id) #type: ignore
+            task_item = TaskItem(
+                task_id=task["id"],
+                title=task["title"],
+                completed=task["completed"],
+                pomodoros=task["pomodoros"],
+                is_active=is_active
+            )
+            container.mount(task_item)
+
+            if is_active:
+                task_item.add_class("active-task")
+
+    def on_task_item_toggle(self, event: TaskItem.Toggle) -> None:
+        for task in self.app.config["tasks"]: #type: ignore
+            if task["id"] == event.task_item.task_id:
+                task["completed"] = event.completed
+                break
+        save_config(self.app.config) #type: ignore
+
+    def on_task_item_select(self, event: TaskItem.Select) -> None:
+        if self.app.active_task_id == event.task_item.task_id: #type: ignore
+            self.app.active_task_id = None #type: ignore
+        else:
+            self.app.active_task_id = event.task_item.task_id #type: ignore
+
+        self.app.update_active_task_display() #type: ignore
+        self.refresh_tasks()
+
+    def on_task_item_delete(self, event: TaskItem.Delete) -> None:
+        if self.app.active_task_id == event.task_item.task_id: #type: ignore
+            self.app.active_task_id = None #type: ignore
+
+        self.app.config["tasks"] = [t for t in self.app.config["tasks"] if t["id"] != event.task_item.task_id] #type: ignore
+        save_config(self.app.config) #type: ignore
+
+        self.app.update_active_task_display() #type: ignore
+        self.refresh_tasks()
+
+    def on_task_item_rename(self, event: TaskItem.Rename) -> None:
+        for task in self.app.config["tasks"]: #type: ignore
+            if task["id"] == event.task_item.task_id:
+                task["title"] = event.new_title
+                break
+        save_config(self.app.config) #type: ignore
+
+        if self.app.active_task_id == event.task_item.task_id: #type: ignore
+            self.app.update_active_task_display() #type: ignore
+
+    def add_task(self) -> None:
+        input_widget = self.query_one("#new-task-input", Input)
+        title = input_widget.value.strip()
+        if not title:
+            return
+
+        new_task = {
+            "id": str(uuid.uuid4()),
+            "title": title,
+            "completed": False,
+            "pomodoros": 0
+        }
+
+        self.app.config.setdefault("tasks", []) #type: ignore
+        self.app.config["tasks"].append(new_task) #type: ignore
+        save_config(self.app.config) #type: ignore
+
+        input_widget.value = ""
+        self.refresh_tasks()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        if event.input.id == "new-task-input":
+            self.add_task()

pttm/widgets/timer_widget.py

@@ -0,0 +1,109 @@
+from textual.widget import Widget
+from textual.app import ComposeResult
+from textual.widgets import Label, Static
+from textual.reactive import reactive
+from pttm.clock import make_clock_ascii
+from pttm.config import save_config
+
+MODE_CONFIG_KEYS = {
+    "Focus": "focus_time",
+    "Short Break": "short_break_time",
+    "Long Break": "long_break_time"
+}
+
+class TimerWidget(Widget):
+    """Widget to display the large digital countdown timer and control panel."""
+
+    mode = reactive("Focus")
+    time_remaining = reactive(25 * 60)
+    is_running = reactive(False) #type: ignore
+
+    def compose(self) -> ComposeResult:
+        yield Label("FOCUS SESSION", id="timer-title")
+        yield Label("No task active", id="active-task-display")
+        yield Static(id="timer-clock")
+        yield Label("Completed: 0 sessions", id="session-count-display")
+
+    def on_mount(self) -> None:
+        self.set_interval(1.0, self.tick)
+
+        # Load values from config
+        focus_mins = self.app.config["settings"].get("focus_time", 25) #type: ignore
+        self.time_remaining = focus_mins * 60
+        self.completed_focus_sessions = self.app.config.get("completed_focus_sessions", 0) #type: ignore
+
+        # Force initial display updates
+        self.watch_mode(self.mode)
+        self.watch_time_remaining(self.time_remaining)
+        self.query_one("#session-count-display", Label).update(f"Completed: {self.completed_focus_sessions} sessions")
+
+    def watch_mode(self, mode: str) -> None:
+        try:
+            title = self.query_one("#timer-title", Label)
+            title.update(f"{mode.upper()} SESSION")
+
+            self.remove_class("mode-focus", "mode-short", "mode-long")
+            if mode == "Focus":
+                self.add_class("mode-focus")
+            elif mode == "Short Break":
+                self.add_class("mode-short")
+            elif mode == "Long Break":
+                self.add_class("mode-long")
+        except Exception:
+            pass
+
+    def watch_time_remaining(self, seconds: int) -> None:
+        try:
+            self.query_one("#timer-clock", Static).update(make_clock_ascii(seconds))
+        except Exception:
+            pass
+
+    def tick(self) -> None:
+        if self.is_running:
+            if self.time_remaining > 0:
+                self.time_remaining -= 1
+            else:
+                self.timer_finished()
+
+    def timer_finished(self) -> None:
+        self.is_running = False #type: ignore
+        self.update_controls()
+
+        # Terminal visual/audio beep
+        print("\a", end="", flush=True)
+
+        self.transition_to_next()
+
+    def transition_to_next(self) -> None:
+        if self.mode == "Focus":
+            self.completed_focus_sessions += 1
+            self.app.config["completed_focus_sessions"] = self.completed_focus_sessions #type: ignore
+            save_config(self.app.config) #type: ignore
+
+            self.query_one("#session-count-display", Label).update(f"Completed: {self.completed_focus_sessions} sessions")
+
+            if self.app.active_task_id: #type: ignore
+                self.app.increment_active_task_pomodoro() #type: ignore
+
+            interval = self.app.config["settings"].get("long_break_interval", 4) #type: ignore
+            if self.completed_focus_sessions % interval == 0:
+                self.mode = "Long Break"
+                self.app.notify("Focus session completed! Time for a long break.", title="Pomodoro Finished", severity="information")
+            else:
+                self.mode = "Short Break"
+                self.app.notify("Focus session completed! Time for a short break.", title="Pomodoro Finished", severity="information")
+        else:
+            self.mode = "Focus"
+            self.app.notify("Break finished! Time to start focusing.", title="Break Finished", severity="warning")
+
+        self.reset_timer_to_mode()
+
+    def reset_timer_to_mode(self) -> None:
+        key = MODE_CONFIG_KEYS[self.mode]
+        minutes = self.app.config["settings"].get(key, 25) #type: ignore
+        self.time_remaining = minutes * 60
+        self.is_running = False #type: ignore
+        self.update_controls()
+
+    def update_controls(self) -> None:
+        pass

pttm-0.1.0.dist-info/METADATA

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: pttm
+Version: 0.1.0
+Summary: Pomodoro Terminal Timer & Manager
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: linkify-it-py==2.1.0
+Requires-Dist: markdown-it-py==4.2.0
+Requires-Dist: mdit-py-plugins==0.6.1
+Requires-Dist: mdurl==0.1.2
+Requires-Dist: platformdirs==4.10.0
+Requires-Dist: Pygments==2.20.0
+Requires-Dist: rich==15.0.0
+Requires-Dist: textual==8.2.7
+Requires-Dist: typing_extensions==4.15.0
+Requires-Dist: uc-micro-py==2.0.0
+
+# PTTM - Pomodoro Terminal Timer & Manager
+
+PTTM is a terminal-based Pomodoro app built with [Textual](https://textual.textualize.io/). It provides a timer, task tracking, and configurable work/break settings in a compact TUI.
+
+## Features
+
+- Pomodoro timer with focus, short break, and long break modes
+- Task list with per-task Pomodoro counts
+- Persistent configuration stored as JSON
+- Keyboard shortcuts for common timer and task actions
+- In-app settings tab for adjusting timing values
+
+## Requirements
+
+- Python 3.10 or newer
+
+## Installation
+
+Install the dependencies from the project root:
+
+```bash
+pip install -r requirements.txt
+```
+
+## Run
+
+From the repository root, start the app with:
+
+```bash
+python pttm.py
+```
+
+You can also run the app module directly:
+
+```bash
+python -m pttm.app
+```
+
+## Keyboard Shortcuts
+
+- `q` quit
+- `s` start or pause the timer
+- `r` reset the current timer
+- `ctrl+r` reset the full session
+- `k` skip to the next timer mode
+- `f` switch to focus mode
+- `g` switch to short break mode
+- `b` switch to long break mode
+- `t` focus the new task input
+- `ctrl+p` show or hide the shortcuts screen
+
+## Configuration
+
+The app reads and writes a JSON config file. By default, the file is stored in your user config directory. You can override the location by setting `PMO_CONFIG_PATH` before launch.
+
+Example:
+
+```bash
+export PMO_CONFIG_PATH=./pmo_config.json
+python pttm.py
+```
+
+The config includes timer settings, completed focus session count, and task data.
+
+## Tests
+
+Run the test suite with:
+
+```bash
+python -m unittest test_pttm.py
+```
+
+## Project Layout
+
+- `pttm/app.py` application entry point
+- `pttm/config.py` config load/save helpers
+- `pttm/clock.py` ASCII clock rendering
+- `pttm/widgets/` UI components
+- `pttm/pttm.css` Textual stylesheet

pttm-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+pttm/__init__.py,sha256=miJeuMU_HF1HetIG4jMHFzFXDULyeKIly7CIBYChTZQ,136
+pttm/app.py,sha256=3W0zcP3EBE-lxU1p19TsBpdkHuYQTiZIhC_bzC-DeZ4,6330
+pttm/clock.py,sha256=qtIFY4omLzC2ZVs2sBreSwzb2UvNEusVtRcH1DaHekU,1170
+pttm/config.py,sha256=YZFiVQAyNlKZCtZCsDnpRXWaUOoRhelNyi-LjU-pUZU,1672
+pttm/pttm.css,sha256=XNwU8tqU42GHfrKmw1xZbcUOyKCeyPx7rDlqBy6GeEI,7433
+pttm/widgets/__init__.py,sha256=iyFvm2dMR8o5NE_viqH_dsu8P4E0aNrKmDUcKhUMbV4,18
+pttm/widgets/dashboard.py,sha256=Lh48aGrmGw-GPqUzRZ5ZX7kK8oHH_s_pXMLMEK_Dk9E,342
+pttm/widgets/settings_tab.py,sha256=vxSujN6p85_GfUzyur9cXCcoOwjoRWhFN72FEUwSsN8,3336
+pttm/widgets/shortcuts_screen.py,sha256=RMAbYh2y-9P4rpqnzphxrJIqH89A9pTLxbdO3IXSMwc,2289
+pttm/widgets/task_item.py,sha256=AOOwnUVgqznoW9DnrnPQ3ZqnsyaCvo_CLmvGcOjG7Jg,3841
+pttm/widgets/task_list_widget.py,sha256=c7xF9KzxFboIjyYXn75WhI0iLVlcm3izzbmxqSGhncM,3845
+pttm/widgets/timer_widget.py,sha256=zCT6o8Y0GFWMmCbe6bdzmgmZgML-Krmm17s03Itr5Rw,4187
+pttm-0.1.0.dist-info/METADATA,sha256=VK1p1XirvWQaTHPim0Dpn_g0GGI8t50v_7O184Q5bx0,2287
+pttm-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pttm-0.1.0.dist-info/entry_points.txt,sha256=51E83u5cM0XY0AxsNhrruuRMoH8iOj2DuB1UKVQy_2E,39
+pttm-0.1.0.dist-info/top_level.txt,sha256=Ylw7xNIsz5KtnrPxMqo0_TbZ1NKZEQAE_a6yv8dfv_Y,5
+pttm-0.1.0.dist-info/RECORD,,

pttm-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pttm-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pttm = pttm.app:main

pttm-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pttm