rook-cli 0.2.0__py3-none-any.whl

rook/widgets/archive_screen.py

@@ -0,0 +1,162 @@
+import sqlite3
+from datetime import date, timedelta
+
+from rich.markup import escape
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import VerticalScroll
+from textual.screen import Screen
+from textual.widgets import Static
+
+from rook import branding
+from rook.domain.tasks import TaskState
+from rook.persistence.archive import ArchiveRepository, week_start_for
+
+
+def _format_week_range(week_start: date) -> str:
+    week_end = week_start + timedelta(days=6)
+    if week_start.year == week_end.year:
+        if week_start.month == week_end.month:
+            return f"{week_start:%B} {week_start.day}–{week_end.day}, {week_start:%Y}"
+        return f"{week_start:%B} {week_start.day}–{week_end:%B} {week_end.day}, {week_start:%Y}"
+    return (
+        f"{week_start:%B} {week_start.day}, {week_start:%Y}"
+        f"–{week_end:%B} {week_end.day}, {week_end:%Y}"
+    )
+
+
+class ArchiveScreen(Screen[None]):
+    """Read-only weekly archive view (Section 21.14)."""
+
+    BINDINGS = [
+        Binding("escape", "go_today", "Today", show=False),
+        Binding("q", "go_today", "Today", show=False),
+        Binding("left", "prev_week", "Older", show=False),
+        Binding("right", "next_week", "Newer", show=False),
+    ]
+
+    CSS = """
+    ArchiveScreen {
+        layout: vertical;
+    }
+
+    ArchiveScreen #archive-header {
+        height: 1;
+        text-style: bold;
+    }
+
+    ArchiveScreen #archive-spacer {
+        height: 1;
+    }
+
+    ArchiveScreen #archive-scroll {
+        height: 1fr;
+    }
+
+    ArchiveScreen #archive-footer {
+        height: 1;
+        dock: bottom;
+    }
+    """
+
+    def __init__(self, *, connection: sqlite3.Connection, first_weekday: int) -> None:
+        super().__init__()
+        self._repo = ArchiveRepository(connection)
+        self._first_weekday = first_weekday
+        self._all_dates: list[date] = []
+        self._current_week_start: date | None = None
+
+    def compose(self) -> ComposeResult:
+        yield Static("", id="archive-header", markup=False)
+        yield Static("", id="archive-spacer")
+        yield VerticalScroll(
+            Static("", id="archive-content"),
+            id="archive-scroll",
+        )
+        yield Static("", id="archive-footer", markup=False)
+
+    def on_mount(self) -> None:
+        self._all_dates = self._repo.list_archive_dates()
+        if self._all_dates:
+            self._current_week_start = week_start_for(
+                self._all_dates[0], first_weekday=self._first_weekday
+            )
+        self._refresh_view()
+
+    def _refresh_view(self) -> None:
+        self._update_header()
+        self._update_content()
+        self._update_footer()
+
+    def _update_header(self) -> None:
+        header = self.query_one("#archive-header", Static)
+        if self._current_week_start is None:
+            header.update(f"{branding.DISPLAY_NAME.lower()} {branding.ICON}  Archive")
+        else:
+            week_range = _format_week_range(self._current_week_start)
+            header.update(
+                f"{branding.DISPLAY_NAME.lower()} {branding.ICON}  Archive — {week_range}"
+            )
+
+    def _update_content(self) -> None:
+        content = self.query_one("#archive-content", Static)
+        if self._current_week_start is None:
+            content.update("No archived tasks yet.")
+            return
+
+        week_end = self._current_week_start + timedelta(days=7)
+        days = self._repo.list_week_items(self._current_week_start, week_end)
+        if not days:
+            content.update("No tasks archived this week.")
+            return
+
+        lines: list[str] = []
+        for i, (day, tasks) in enumerate(days):
+            if i > 0:
+                lines.append("")
+            lines.append(f"{day:%A, %B} {day.day}")
+            for task in tasks:
+                safe_text = escape(task.text)
+                if task.state == TaskState.COMPLETED:
+                    lines.append(f"  × {safe_text}")
+                else:
+                    lines.append(f"  [strike]• {safe_text}[/strike]")
+        content.update("\n".join(lines))
+
+    def _update_footer(self) -> None:
+        footer = self.query_one("#archive-footer", Static)
+        parts: list[str] = []
+        if self._has_older_week():
+            parts.append("[←] older")
+        if self._has_newer_week():
+            parts.append("[→] newer")
+        parts.append("[Esc] today")
+        footer.update("   ".join(parts))
+
+    def _has_older_week(self) -> bool:
+        if not self._all_dates or self._current_week_start is None:
+            return False
+        return self._all_dates[-1] < self._current_week_start
+
+    def _has_newer_week(self) -> bool:
+        if not self._all_dates or self._current_week_start is None:
+            return False
+        return self._all_dates[0] >= self._current_week_start + timedelta(days=7)
+
+    def action_go_today(self) -> None:
+        self.app.pop_screen()
+
+    def action_prev_week(self) -> None:
+        if not self._has_older_week():
+            return
+        target = next(d for d in self._all_dates if d < self._current_week_start)
+        self._current_week_start = week_start_for(target, first_weekday=self._first_weekday)
+        self._refresh_view()
+
+    def action_next_week(self) -> None:
+        if not self._has_newer_week():
+            return
+        next_start = self._current_week_start + timedelta(days=7)
+        target = next(d for d in reversed(self._all_dates) if d >= next_start)
+        self._current_week_start = week_start_for(target, first_weekday=self._first_weekday)
+        self._refresh_view()

rook/widgets/shortcut_footer.py

@@ -0,0 +1,79 @@
+from dataclasses import dataclass
+
+from textual import events
+from textual.widgets import Static
+
+
+@dataclass(frozen=True, slots=True)
+class FooterVariant:
+    wide: str
+    medium: str
+    compact: str
+
+
+# Section 9.14: the full Today footer, and its progressively shortened forms.
+# Help overlay removed from the app (Section 10.14); [?] is not bound.
+TODAY_FOOTER = FooterVariant(
+    wide=(
+        "[n] new   [e/Ent] edit   [x] complete   [>] migrate   [d] delete   "
+        "[u] undo   [a] archive   [q] quit"
+    ),
+    medium=(
+        "n new  e/Ent edit  x done  > migrate  d delete  u undo  a archive  q quit"
+    ),
+    compact="n  e  x  >  d  u  a  q",
+)
+
+# Section 10.15: Today's empty state omits keys that act on a Task, since
+# none exists yet. The wide/medium/compact tiers follow the same shortening
+# pattern as the populated footer.
+TODAY_EMPTY_FOOTER = FooterVariant(
+    wide="[n] new   [a] archive   [q] quit",
+    medium="n new  a archive  q quit",
+    compact="n  a  q",
+)
+
+# Section 10.7: while creating or editing a Task inline, the footer shows
+# only the controls that apply to text entry.
+EDITING_FOOTER_TEXT = "[Ent] save   [Esc] cancel"
+
+
+def select_footer_text(variant: FooterVariant, width: int) -> str:
+    """The widest footer tier that fits without wrapping."""
+    for candidate in (variant.wide, variant.medium, variant.compact):
+        if len(candidate) <= width:
+            return candidate
+    return variant.compact
+
+
+class ShortcutFooter(Static):
+    """The one-row shortcut footer, responsive to available width."""
+
+    def __init__(self, *, has_tasks: bool, id: str | None = None) -> None:
+        # markup=False: the "[key]" hints are literal text, not Rich console
+        # markup tags, so brackets like "[n]" must not be parsed as styling.
+        super().__init__(id=id, markup=False)
+        self._has_tasks = has_tasks
+        self._editing = False
+
+    def on_mount(self) -> None:
+        self._refresh_content()
+
+    def on_resize(self, event: events.Resize) -> None:
+        self._refresh_content()
+
+    def set_editing(self, editing: bool) -> None:
+        self._editing = editing
+        self._refresh_content()
+
+    def set_has_tasks(self, has_tasks: bool) -> None:
+        self._has_tasks = has_tasks
+        self._refresh_content()
+
+    def _refresh_content(self) -> None:
+        if self._editing:
+            self.update(EDITING_FOOTER_TEXT)
+            return
+        variant = TODAY_FOOTER if self._has_tasks else TODAY_EMPTY_FOOTER
+        width = self.size.width or 80
+        self.update(select_footer_text(variant, width))

rook/widgets/task_line_input.py

@@ -0,0 +1,44 @@
+from textual import events
+from textual.message import Message
+from textual.widgets import Input
+
+
+class TaskLineInput(Input):
+    """A single-line text editor for inline Task creation and editing.
+
+    Extends Textual's ``Input`` with two Rook-specific behaviors:
+    pasted newlines normalize to spaces instead of truncating to the
+    first line (Section 18.6), and Backspace on already-empty content
+    is reported rather than silently doing nothing, so the owning
+    ``TaskListView`` can cancel an in-progress new Task (Section 9.11).
+    """
+
+    class EmptyBackspace(Message):
+        """Posted when Backspace is pressed while the value is already empty."""
+
+    def _on_paste(self, event: events.Paste) -> None:
+        if not event.text:
+            return
+
+        # prevent_default() (not just stop()) is required: Textual calls
+        # every class's own _on_paste up the MRO in turn, so without it
+        # Input's own _on_paste would also run and insert its unnormalized
+        # first-line-only text right after ours.
+        event.stop()
+        event.prevent_default()
+
+        normalized = " ".join(event.text.split())
+        if not normalized:
+            return
+
+        selection = self.selection
+        if selection.is_empty:
+            self.insert_text_at_cursor(normalized)
+        else:
+            self.replace(normalized, *selection)
+
+    def action_delete_left(self) -> None:
+        if not self.value:
+            self.post_message(self.EmptyBackspace())
+            return
+        super().action_delete_left()

rook/widgets/task_list.py

@@ -0,0 +1,415 @@
+from collections.abc import Callable, Sequence
+from typing import ClassVar
+
+from textual.app import ComposeResult
+from textual.binding import Binding, BindingType
+from textual.containers import VerticalScroll
+from textual.message import Message
+from textual.widgets import Input, Static
+
+from rook.domain.tasks import Task, TaskState, initial_selection
+from rook.domain.tasks import toggle_completed as compute_toggled_completed
+from rook.domain.tasks import toggle_migrated as compute_toggled_migrated
+from rook.services.tasks import PersistenceError, TaskService
+from rook.services.undo import (
+    DeleteCreatedTask,
+    RestoreTaskSnapshot,
+    RestoreTaskState,
+    RestoreTaskText,
+    UndoManager,
+)
+from rook.widgets.task_line_input import TaskLineInput
+from rook.widgets.task_row import TaskRow
+
+EMPTY_TODAY_MESSAGE = "No tasks yet. Press n to write the first one."
+
+# A brand new, not-yet-saved Task has no database id yet. SQLite's
+# AUTOINCREMENT never assigns 0 or a negative id, so this sentinel can't
+# collide with a real Task while the blank row is still being typed.
+_NEW_TASK_SENTINEL_ID = -1
+
+_SAVE_FAILED_MESSAGE = "Could not save. Your change was not applied."
+
+
+class TaskListView(VerticalScroll):
+    """Today's scrollable task list with a single bounded selection cursor.
+
+    Selection is tracked by Task id rather than row index (Section 21.8),
+    so it stays meaningful if the underlying task order ever changes.
+    """
+
+    # This container itself never takes focus (see can_focus=False below),
+    # but a binding declared here still applies while a descendant (the
+    # TaskLineInput being edited) has focus, because Textual's binding
+    # resolution walks up the full ancestor chain from the focused widget.
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("escape", "cancel_edit", "Cancel", show=False),
+    ]
+
+    class StatusMessage(Message):
+        """A one-line status hint for the App to display (Section 10.16)."""
+
+        def __init__(self, text: str) -> None:
+            self.text = text
+            super().__init__()
+
+    class EditingChanged(Message):
+        """Whether a Task row is currently being created or edited."""
+
+        def __init__(self, editing: bool) -> None:
+            self.editing = editing
+            super().__init__()
+
+    class TasksEmptyChanged(Message):
+        """Whether the list has transitioned to/from having no Tasks."""
+
+        def __init__(self, has_tasks: bool) -> None:
+            self.has_tasks = has_tasks
+            super().__init__()
+
+    def __init__(
+        self,
+        tasks: Sequence[Task],
+        *,
+        task_service: TaskService,
+        undo_manager: UndoManager,
+        safe_symbols: bool = False,
+        id: str | None = None,
+    ) -> None:
+        # can_focus=False: ScrollableContainer is focusable and binds
+        # up/down to its own scroll_up/scroll_down actions (inherited
+        # bindings can't be cleared by overriding BINDINGS in a subclass -
+        # Textual's binding resolution merges the whole class hierarchy).
+        # Once this container is scrollable, that would swallow the key
+        # before it ever reaches RookApp's selection bindings. Scrolling
+        # here must be a side effect of moving the selection (Section
+        # 6.4), not an independent action, so this widget never takes
+        # focus and arrow keys go straight to the App.
+        super().__init__(id=id, can_focus=False)
+        self._tasks = list(tasks)
+        self._task_service = task_service
+        self._undo_manager = undo_manager
+        self._safe_symbols = safe_symbols
+        self.selected_task_id: int | None = initial_selection(self._tasks)
+        self._editing_task_id: int | None = None
+        self._creating = False
+        self._pending_edit_value = ""
+        self._pre_edit_selected_task_id: int | None = None
+        self._has_tasks = bool(self._tasks)
+
+    def compose(self) -> ComposeResult:
+        if not self._tasks:
+            yield Static(f"  {EMPTY_TODAY_MESSAGE}", markup=False)
+            return
+
+        for task in self._tasks:
+            is_editing_this = task.id == self._editing_task_id
+            yield TaskRow(
+                task,
+                selected=(task.id == self.selected_task_id),
+                safe_symbols=self._safe_symbols,
+                editing=is_editing_this,
+                edit_value=self._pending_edit_value if is_editing_this else "",
+                id=f"task-row-{task.id}",
+            )
+
+    @property
+    def is_editing(self) -> bool:
+        """Whether a Task row is currently being created or edited
+        (Section 18.12: a live Day Rollover must defer while this is true).
+        """
+        return self._editing_task_id is not None
+
+    async def reload(self, tasks: Sequence[Task]) -> None:
+        """Replace the active Task list after a live Day Rollover
+        (Section 6.15), preserving selection by Task id where possible."""
+        self._tasks = list(tasks)
+        if self._index_of_selected() is None:
+            self.selected_task_id = initial_selection(self._tasks)
+        self._sync_has_tasks()
+        await self.recompose()
+        self._apply_selection()
+
+    # --- Navigation (Phase 3) -------------------------------------------
+
+    def select_previous(self) -> None:
+        if self._editing_task_id is not None:
+            return
+        self._move_selection(-1)
+
+    def select_next(self) -> None:
+        if self._editing_task_id is not None:
+            return
+        self._move_selection(1)
+
+    def _move_selection(self, delta: int) -> None:
+        index = self._index_of_selected()
+        if index is None:
+            return
+
+        new_index = max(0, min(len(self._tasks) - 1, index + delta))
+        if new_index == index:
+            return
+
+        self.selected_task_id = self._tasks[new_index].id
+        self._apply_selection()
+
+    def _index_of_selected(self) -> int | None:
+        for index, task in enumerate(self._tasks):
+            if task.id == self.selected_task_id:
+                return index
+        return None
+
+    def _apply_selection(self) -> None:
+        for row in self.query(TaskRow):
+            row.set_selected(row.item.id == self.selected_task_id)
+            if row.selected:
+                row.scroll_visible(animate=False)
+
+    def _scroll_to_editing_row(self) -> None:
+        try:
+            row = self.query_one(f"#task-row-{_NEW_TASK_SENTINEL_ID}", TaskRow)
+            row.scroll_visible(animate=False)
+        except Exception:
+            pass
+
+    # --- Creation and editing (Phase 4/5) --------------------------------
+
+    async def begin_create(self) -> None:
+        if self._editing_task_id is not None:
+            return
+
+        self._pre_edit_selected_task_id = self.selected_task_id
+        self._open_blank_row()
+        self._creating = True
+        self.post_message(self.EditingChanged(True))
+        await self.recompose()
+        self._scroll_to_editing_row()
+
+    async def begin_edit(self) -> None:
+        if self._editing_task_id is not None:
+            return
+
+        index = self._index_of_selected()
+        if index is None:
+            return
+
+        task = self._tasks[index]
+        self._editing_task_id = task.id
+        self._creating = False
+        self._pending_edit_value = task.text
+        self.post_message(self.EditingChanged(True))
+        await self.recompose()
+
+    async def action_cancel_edit(self) -> None:
+        if self._editing_task_id is None:
+            return
+        if self._creating:
+            await self._cancel_creation()
+        else:
+            await self._exit_editing()
+
+    async def on_input_submitted(self, message: Input.Submitted) -> None:
+        message.stop()
+        editing_task_id = self._editing_task_id
+        if editing_task_id is None:
+            return
+
+        is_blank = message.value.strip() == ""
+
+        if self._creating:
+            if is_blank:
+                # Section 6.5: Enter on a blank bullet ends the chain.
+                await self._cancel_creation()
+            else:
+                await self._save_new_task(message.value)
+        elif is_blank:
+            self.post_message(self.StatusMessage("Task cannot be blank."))
+        else:
+            await self._save_edited_task(editing_task_id, message.value)
+
+    async def on_task_line_input_empty_backspace(
+        self, message: TaskLineInput.EmptyBackspace
+    ) -> None:
+        message.stop()
+        # Section 9.5: Backspace on an already-empty *existing* Task edit
+        # must not delete or exit. Only a brand new, unsaved Task cancels.
+        if self._creating:
+            await self._cancel_creation()
+
+    async def _save_new_task(self, text: str) -> None:
+        try:
+            created = self._task_service.create_task(text)
+        except PersistenceError:
+            self.post_message(self.StatusMessage(_SAVE_FAILED_MESSAGE))
+            return
+
+        index = self._index_of_selected()
+        if index is not None:
+            self._tasks[index] = created
+        self._undo_manager.record(DeleteCreatedTask(created.id))
+
+        # Section 6.5: stay in creation mode and open another blank bullet,
+        # so several Tasks can be written in a row with a single `n` (the
+        # paper-bullet-journal behavior of Section 1.5/2.2). Cancelling
+        # this next blank restores selection to the Task just saved, not
+        # all the way back to the pre-chain selection.
+        self._pre_edit_selected_task_id = created.id
+        self._open_blank_row()
+        await self.recompose()
+        self._scroll_to_editing_row()
+
+    async def _save_edited_task(self, task_id: int, text: str) -> None:
+        previous_text = next((task.text for task in self._tasks if task.id == task_id), None)
+
+        try:
+            updated = self._task_service.update_task_text(task_id, text)
+        except PersistenceError:
+            self.post_message(self.StatusMessage(_SAVE_FAILED_MESSAGE))
+            return
+
+        for index, task in enumerate(self._tasks):
+            if task.id == updated.id:
+                self._tasks[index] = updated
+                break
+
+        if previous_text is not None:
+            self._undo_manager.record(RestoreTaskText(task_id, previous_text))
+        await self._exit_editing()
+
+    def _open_blank_row(self) -> None:
+        self._tasks.append(Task(id=_NEW_TASK_SENTINEL_ID, text="", state=TaskState.OPEN))
+        self.selected_task_id = _NEW_TASK_SENTINEL_ID
+        self._editing_task_id = _NEW_TASK_SENTINEL_ID
+        self._pending_edit_value = ""
+        self._sync_has_tasks()
+
+    async def _cancel_creation(self) -> None:
+        self._tasks = [task for task in self._tasks if task.id != _NEW_TASK_SENTINEL_ID]
+        self.selected_task_id = self._pre_edit_selected_task_id
+        self._sync_has_tasks()
+        await self._exit_editing()
+
+    async def _exit_editing(self) -> None:
+        self._editing_task_id = None
+        self._creating = False
+        self._pending_edit_value = ""
+        self.post_message(self.EditingChanged(False))
+        await self.recompose()
+
+    def _sync_has_tasks(self) -> None:
+        has_tasks = bool(self._tasks)
+        if has_tasks != self._has_tasks:
+            self._has_tasks = has_tasks
+            self.post_message(self.TasksEmptyChanged(has_tasks))
+
+    # --- Task state changes (Phase 6) ------------------------------------
+
+    async def toggle_completed(self) -> None:
+        await self._change_state(compute_toggled_completed)
+
+    async def toggle_migrated(self) -> None:
+        await self._change_state(compute_toggled_migrated)
+
+    async def delete_or_remove(self) -> None:
+        if self._editing_task_id is not None:
+            return
+        index = self._index_of_selected()
+        if index is None:
+            return
+        task = self._tasks[index]
+
+        if task.state is not TaskState.DELETED:
+            await self._change_state(lambda _state: TaskState.DELETED)
+            return
+
+        try:
+            snapshot = self._task_service.delete_task(task.id)
+        except PersistenceError:
+            self.post_message(self.StatusMessage(_SAVE_FAILED_MESSAGE))
+            return
+
+        del self._tasks[index]
+        self.selected_task_id = self._select_after_removal(index)
+        self._undo_manager.record(RestoreTaskSnapshot(index=index, snapshot=snapshot))
+        self._sync_has_tasks()
+        await self.recompose()
+
+    async def _change_state(self, transform: Callable[[TaskState], TaskState]) -> None:
+        if self._editing_task_id is not None:
+            return
+        index = self._index_of_selected()
+        if index is None:
+            return
+        task = self._tasks[index]
+        previous_state = task.state
+        new_state = transform(previous_state)
+
+        try:
+            updated = self._task_service.set_task_state(task.id, new_state)
+        except PersistenceError:
+            self.post_message(self.StatusMessage(_SAVE_FAILED_MESSAGE))
+            return
+
+        self._undo_manager.record(RestoreTaskState(task.id, previous_state))
+        self._replace_task_in_place(updated)
+
+    def _select_after_removal(self, removed_index: int) -> int | None:
+        if removed_index < len(self._tasks):
+            return self._tasks[removed_index].id
+        if removed_index > 0:
+            return self._tasks[removed_index - 1].id
+        return None
+
+    # --- Undo (Phase 7) ---------------------------------------------------
+
+    async def undo(self) -> None:
+        if self._editing_task_id is not None:
+            return
+
+        command = self._undo_manager.take()
+        if command is None:
+            self.post_message(self.StatusMessage("Nothing to undo."))
+            return
+
+        try:
+            if isinstance(command, DeleteCreatedTask):
+                self._task_service.discard_created_task(command.task_id)
+                index = next(
+                    (i for i, task in enumerate(self._tasks) if task.id == command.task_id),
+                    None,
+                )
+                if index is not None:
+                    del self._tasks[index]
+                    self.selected_task_id = self._select_after_removal(index)
+                    self._sync_has_tasks()
+                await self.recompose()
+
+            elif isinstance(command, RestoreTaskText):
+                updated = self._task_service.update_task_text(command.task_id, command.text)
+                self._replace_task_in_place(updated)
+
+            elif isinstance(command, RestoreTaskState):
+                updated = self._task_service.set_task_state(command.task_id, command.state)
+                self._replace_task_in_place(updated)
+
+            elif isinstance(command, RestoreTaskSnapshot):
+                restored = self._task_service.restore_task(command.snapshot)
+                self._tasks.insert(command.index, restored)
+                self.selected_task_id = restored.id
+                self._sync_has_tasks()
+                await self.recompose()
+
+        except PersistenceError:
+            self.post_message(self.StatusMessage(_SAVE_FAILED_MESSAGE))
+            # Leave the database/UI exactly as they were, and re-arm the
+            # same command so the user can retry once persistence recovers.
+            self._undo_manager.record(command)
+
+    def _replace_task_in_place(self, updated: Task) -> None:
+        for index, task in enumerate(self._tasks):
+            if task.id == updated.id:
+                self._tasks[index] = updated
+                break
+        row = self.query_one(f"#task-row-{updated.id}", TaskRow)
+        row.set_item(updated)