rook-cli 0.2.0__py3-none-any.whl

rook/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

rook/__main__.py

@@ -0,0 +1,48 @@
+import sys
+
+from rook.app import RookApp
+from rook.paths import default_database_path
+from rook.persistence.database import connect
+from rook.persistence.metadata import MetadataRepository
+from rook.persistence.migrations import UnsupportedSchemaVersionError, migrate
+from rook.persistence.tasks import TaskRepository
+from rook.services.rollover import RolloverService
+from rook.services.tasks import TaskService
+
+
+def main() -> int:
+    if len(sys.argv) > 1 and sys.argv[1] == "--data-path":
+        print(default_database_path())
+        return 0
+
+    db_path = default_database_path()
+    connection = connect(db_path)
+
+    try:
+        migrate(connection)
+    except UnsupportedSchemaVersionError as error:
+        connection.close()
+        print(error)
+        print(f"Database file: {db_path}")
+        return 1
+
+    task_service = TaskService(TaskRepository(connection))
+    rollover_service = RolloverService(connection, MetadataRepository(connection))
+
+    # Section 16.8: rollover runs once at startup, before Today ever renders.
+    rollover_service.roll_forward_if_needed()
+
+    try:
+        RookApp(
+            task_service=task_service,
+            rollover_service=rollover_service,
+            connection=connection,
+        ).run()
+    finally:
+        connection.close()
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

rook/app.py

@@ -0,0 +1,222 @@
+import sqlite3
+from collections.abc import Callable
+from datetime import date
+
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.widgets import Static
+
+from rook import branding
+from rook.formatting import format_header_date
+from rook.persistence.metadata import MetadataRepository
+from rook.services.rollover import RolloverService
+from rook.services.tasks import TaskService
+from rook.services.undo import UndoManager
+from rook.widgets.archive_screen import ArchiveScreen
+from rook.widgets.shortcut_footer import ShortcutFooter
+from rook.widgets.task_list import TaskListView
+
+TodayProvider = Callable[[], date]
+
+# Section 21.13 explicitly excludes anything more frequent than needed; a
+# once-a-minute check is enough to notice a live midnight crossing without
+# being a tight polling loop.
+ROLLOVER_CHECK_INTERVAL_SECONDS = 60
+
+
+class RookApp(App[None]):
+    """The Rook terminal shell.
+
+    Phase 5 replaces the in-memory Task list with SQLite as the source of
+    truth, via an injected TaskService. Task state changes, Archive, and
+    Routines are still not implemented.
+    """
+
+    CSS = """
+    Screen {
+        layout: vertical;
+    }
+
+    #header, #mascot-quote, #spacer, #status {
+        height: 1;
+    }
+
+    #header {
+        text-style: bold;
+    }
+
+    #task-list {
+        height: 1fr;
+        /* The "ansi-dark" theme doesn't define scrollbar variables (only
+         * "ansi-light" happens to), so these fall back to Textual's fixed
+         * truecolor defaults - the mismatched, chunky bar reported after
+         * scrolling a long list. Set them directly to ANSI colors instead,
+         * and use a slimmer single-column bar (Section 11.1 "compact"). */
+        scrollbar-size-vertical: 1;
+        scrollbar-color: ansi_default;
+        scrollbar-color-hover: ansi_default;
+        scrollbar-color-active: ansi_default;
+        scrollbar-background: ansi_default;
+        scrollbar-background-hover: ansi_default;
+        scrollbar-background-active: ansi_default;
+        scrollbar-corner-color: ansi_default;
+    }
+
+    /* "ansi-dark" hardcodes the text-entry cursor to a solid reverse-video
+     * block in ansi_black on ansi_bright_white, which many customized
+     * terminal palettes remap to something unrelated to the terminal's
+     * actual foreground/background (reported as an unrelated light gray).
+     * Reversing the terminal's own default foreground instead keeps the
+     * filled-block look but in the user's own theme color. This is Rook's
+     * own simulated text cursor, not the terminal's hardware cursor - a
+     * full-screen app owning the whole display can't repurpose the
+     * terminal's native caret for a styled, multi-character-wide input. */
+    TaskLineInput > .input--cursor {
+        color: ansi_default;
+        text-style: reverse;
+    }
+
+    #footer {
+        height: 1;
+        dock: bottom;
+    }
+    """
+
+    BINDINGS = [
+        Binding("q", "quit", "Quit"),
+        Binding("up", "cursor_up", "Up", show=False),
+        Binding("down", "cursor_down", "Down", show=False),
+        Binding("n", "new_task", "New", show=False),
+        Binding("e", "edit_task", "Edit", show=False),
+        Binding("enter", "edit_task", "Edit", show=False),
+        Binding("x", "toggle_completed", "Complete", show=False),
+        Binding(">", "toggle_migrated", "Migrate", show=False),
+        Binding("d", "delete_or_remove", "Delete", show=False),
+        Binding("u", "undo", "Undo", show=False),
+        Binding("a", "archive", "Archive", show=False),
+    ]
+
+    def __init__(
+        self,
+        today_provider: TodayProvider = date.today,
+        *,
+        task_service: TaskService,
+        rollover_service: RolloverService,
+        connection: sqlite3.Connection | None = None,
+        safe_symbols: bool = False,
+    ) -> None:
+        super().__init__()
+        self._today_provider = today_provider
+        self._task_service = task_service
+        self._rollover_service = rollover_service
+        self._connection = connection
+        self._rollover_pending = False
+        # Session-scoped: owned here (not per-widget) so a later Routine
+        # phase can share the same single undo slot (Section 6.10).
+        self._undo_manager = UndoManager()
+        self._safe_symbols = safe_symbols
+        # Map foreground/background to the terminal's own ANSI defaults
+        # instead of Textual's fixed truecolor theme, so the app respects
+        # the user's existing terminal background (Section 11.9-11.10).
+        self.theme = "ansi-dark"
+
+    def _mascot_quote_text(self) -> str:
+        mascot, quote = branding.pick_for_date(self._today_provider())
+        return f'{mascot}  "{quote}"'
+
+    def compose(self) -> ComposeResult:
+        mascot_quote_text = self._mascot_quote_text()
+        tasks = self._task_service.list_active_tasks()
+
+        yield Static(self._header_text(), id="header", markup=False)
+        yield Static(mascot_quote_text, id="mascot-quote", markup=False)
+        yield Static("", id="spacer")
+        yield TaskListView(
+            tasks,
+            task_service=self._task_service,
+            undo_manager=self._undo_manager,
+            safe_symbols=self._safe_symbols,
+            id="task-list",
+        )
+        yield Static("", id="status", markup=False)
+        yield ShortcutFooter(has_tasks=bool(tasks), id="footer")
+
+    def _header_text(self) -> str:
+        today = self._today_provider()
+        return f"{branding.DISPLAY_NAME.lower()} {branding.ICON}  Today — {format_header_date(today)}"
+
+    def on_mount(self) -> None:
+        self.set_interval(ROLLOVER_CHECK_INTERVAL_SECONDS, self._check_for_new_day)
+
+    async def _check_for_new_day(self) -> None:
+        if self.query_one(TaskListView).is_editing:
+            # Section 18.12: defer while the user is actively typing;
+            # on_task_list_view_editing_changed runs it once they finish.
+            self._rollover_pending = True
+            return
+        await self._apply_rollover_if_needed()
+
+    async def _apply_rollover_if_needed(self) -> None:
+        try:
+            result = self._rollover_service.roll_forward_if_needed()
+        except Exception:
+            # A transient failure here must not crash a running session -
+            # Section 16.24's fatal-error handling is for startup, not a
+            # live background reconciliation. The next check retries.
+            return
+
+        if not result.changed:
+            return
+
+        self.query_one("#header", Static).update(self._header_text())
+        self.query_one("#mascot-quote", Static).update(self._mascot_quote_text())
+        tasks = self._task_service.list_active_tasks()
+        await self.query_one(TaskListView).reload(tasks)
+        self.query_one(ShortcutFooter).set_has_tasks(bool(tasks))
+        # Section 6.10: Day Rollover clears session undo after completing.
+        self._undo_manager.clear()
+
+    def action_cursor_up(self) -> None:
+        self.query_one(TaskListView).select_previous()
+
+    def action_cursor_down(self) -> None:
+        self.query_one(TaskListView).select_next()
+
+    async def action_new_task(self) -> None:
+        await self.query_one(TaskListView).begin_create()
+
+    async def action_edit_task(self) -> None:
+        await self.query_one(TaskListView).begin_edit()
+
+    async def action_toggle_completed(self) -> None:
+        await self.query_one(TaskListView).toggle_completed()
+
+    async def action_toggle_migrated(self) -> None:
+        await self.query_one(TaskListView).toggle_migrated()
+
+    async def action_delete_or_remove(self) -> None:
+        await self.query_one(TaskListView).delete_or_remove()
+
+    async def action_undo(self) -> None:
+        await self.query_one(TaskListView).undo()
+
+    def on_task_list_view_status_message(self, message: TaskListView.StatusMessage) -> None:
+        self.query_one("#status", Static).update(message.text)
+
+    async def on_task_list_view_editing_changed(self, message: TaskListView.EditingChanged) -> None:
+        self.query_one(ShortcutFooter).set_editing(message.editing)
+        self.query_one("#status", Static).update("")
+        if not message.editing and self._rollover_pending:
+            self._rollover_pending = False
+            await self._apply_rollover_if_needed()
+
+    def on_task_list_view_tasks_empty_changed(
+        self, message: TaskListView.TasksEmptyChanged
+    ) -> None:
+        self.query_one(ShortcutFooter).set_has_tasks(message.has_tasks)
+
+    def action_archive(self) -> None:
+        if self._connection is None:
+            return
+        first_weekday = MetadataRepository(self._connection).get_week_start_day()
+        self.push_screen(ArchiveScreen(connection=self._connection, first_weekday=first_weekday))

rook/branding.py

@@ -0,0 +1,69 @@
+"""Centralized presentation identity for Rook.
+
+Domain and persistence code must not import this module (see
+DEVELOPMENT_GUIDE.md Section 16.22) so branding can change without
+touching task-state logic, schema, or tests unrelated to display copy.
+"""
+
+import random
+from datetime import date
+
+DISPLAY_NAME = "Rook"
+ICON = "♖"
+FALLBACK_ICON = "R"
+CONSOLE_COMMAND = "rook"
+
+# Fallbacks used when the libraries below are empty (Section 18.33).
+MASCOT = "‧₊˚ 🖇️✩ ₊˚⊹"
+QUOTE = "Let's begin."
+
+_MASCOTS: list[str] = [
+    # Face-forward, decorative-framed
+    "｡・::・ﾟ★ (｡•̀ᴗ-) ✧.。",
+    "˚₊‧꒰ (˶ˆ ᗜ ˆ˵) ꒱‧₊˚",
+    "⋆｡°✩ ( ˙▿˙ ) ✩°｡⋆",
+    "‧₊˚ ( ◡̈ ) ₊˚‧ ☾",
+    "✧・゜: *.(๑˃ᴗ˂)ﾟ・✧",
+    "⊹ ˚｡ (づ￣ ³￣)づ ｡˚ ⊹",
+    "˖° ┈┈ ( ﾉ^ω^)ﾉ ┈┈ °˖",
+    "⋆⁺₊ (｡'▽'｡)♡ ₊⁺⋆",
+    "｡:゜(´∀`)゜:｡",
+    "⌒°｡(ˊᵕˋ) 。°⌒",
+    # Faceless, purely decorative
+    "‧₊˚ 🖇️✩ ₊˚⊹",
+    "˚₊‧꒰ ☕✨ ꒱‧₊˚",
+    "⋆｡°✩ 📖 ⁺˚*•̩̩͙✩.",
+    "˚₊‧꒰ა ☕️ ໒꒱‧₊˚",
+    "⋆｡°✩ ⁺˚•̩̩͙✩•̩̩͙˚",
+    "‧₊˚ 🕯️ ⋆｡˚ ☾",
+    "✧˖°⋆ 🧵📌⋆⁺₊",
+    "˚ · . 🩶 . · ˚ ⊹",
+    "₊˚⊹♡ 🪞 ⊹˚₊",
+    "⋆⁺˚｡⋆ 🎀 ⋆｡˚⁺⋆",
+    "・゜・.。 🧸 。.・゜・",
+    "˖⁺‧₊˚ 📖✨ ˚₊‧⁺˖",
+    "⊹˚₊ ‧ 🪄 ‧ ₊˚⊹.",
+]
+
+_QUOTES: list[str] = [
+    "You are art. You will never be again.",
+    "Do the thing, and you shall have the power.",
+    "You already survived every day before this one.",
+    "Discipline is a mountain of evidence.",
+    "You are the proof of your own effort.",
+    "Your genius is how everything meets in you.",
+    "Showing up is the whole trick.",
+]
+
+
+def pick_for_date(today: date) -> tuple[str, str]:
+    """Return (mascot, quote) for the given date, stable within the day.
+
+    Uses the date ordinal as a seed so the pair changes each calendar day
+    but never flickers during a session. Mascot and quote are drawn
+    independently so every combination is reachable over time.
+    """
+    rng = random.Random(today.toordinal())
+    mascot = rng.choice(_MASCOTS) if _MASCOTS else MASCOT
+    quote = rng.choice(_QUOTES) if _QUOTES else QUOTE
+    return mascot, quote

rook/domain/tasks.py

@@ -0,0 +1,55 @@
+from collections.abc import Sequence
+from dataclasses import dataclass
+from enum import Enum
+
+
+class TaskState(str, Enum):
+    OPEN = "open"
+    MIGRATED = "migrated"
+    COMPLETED = "completed"
+    DELETED = "deleted"
+
+
+@dataclass(frozen=True, slots=True)
+class Task:
+    """A one-line Task and its current persistent state.
+
+    This is intentionally minimal for Phase 2 (id, text, state only).
+    Ordering and timestamps are added when a phase first needs them.
+    """
+
+    id: int
+    text: str
+    state: TaskState
+
+
+# Section 6.2: initial selection prefers the first Open Task, then the
+# first Migrated, then the first Completed, then the first Soft-Deleted.
+_INITIAL_SELECTION_PRIORITY = (
+    TaskState.OPEN,
+    TaskState.MIGRATED,
+    TaskState.COMPLETED,
+    TaskState.DELETED,
+)
+
+
+def initial_selection(tasks: Sequence[Task]) -> int | None:
+    """The id of the Task that should be selected when Today first opens.
+
+    Returns None when there are no Tasks to select.
+    """
+    for state in _INITIAL_SELECTION_PRIORITY:
+        for task in tasks:
+            if task.state is state:
+                return task.id
+    return None
+
+
+def toggle_completed(state: TaskState) -> TaskState:
+    """Section 8.5: `x` returns a Completed Task to Open, otherwise completes it."""
+    return TaskState.OPEN if state is TaskState.COMPLETED else TaskState.COMPLETED
+
+
+def toggle_migrated(state: TaskState) -> TaskState:
+    """Section 8.5: `>` returns a Migrated Task to Open, otherwise migrates it."""
+    return TaskState.OPEN if state is TaskState.MIGRATED else TaskState.MIGRATED

rook/formatting.py

@@ -0,0 +1,10 @@
+from datetime import date
+
+
+def format_header_date(today: date) -> str:
+    """Render a date as "Weekday, Month D, Year" without a leading zero.
+
+    ``strftime("%-d")`` is a glibc extension not available on Windows'
+    CRT, so the day number is formatted separately instead.
+    """
+    return f"{today:%A, %B} {today.day}, {today:%Y}"

rook/paths.py

@@ -0,0 +1,31 @@
+import os
+import sys
+from pathlib import Path
+
+from rook import branding
+
+DATABASE_FILENAME = "data.sqlite3"
+
+
+def default_data_directory() -> Path:
+    """The per-user directory Rook's database lives in (Section 15.3, 20.10).
+
+    Never the source repository, the current working directory, or the
+    installed package directory.
+    """
+    if sys.platform == "win32":
+        base = os.environ.get("LOCALAPPDATA")
+        if not base:
+            base = str(Path.home() / "AppData" / "Local")
+        return Path(base) / branding.DISPLAY_NAME
+
+    if sys.platform == "darwin":
+        return Path.home() / "Library" / "Application Support" / branding.DISPLAY_NAME
+
+    xdg_data_home = os.environ.get("XDG_DATA_HOME")
+    base_dir = Path(xdg_data_home) if xdg_data_home else Path.home() / ".local" / "share"
+    return base_dir / branding.CONSOLE_COMMAND
+
+
+def default_database_path() -> Path:
+    return default_data_directory() / DATABASE_FILENAME

rook/persistence/archive.py

@@ -0,0 +1,72 @@
+import sqlite3
+from dataclasses import dataclass
+from datetime import date, timedelta
+
+from rook.domain.tasks import TaskState
+
+
+@dataclass(frozen=True, slots=True)
+class ArchivedTask:
+    text: str
+    state: TaskState  # completed or deleted
+
+
+class ArchiveRepository:
+    """Read-only SQL access for the Archive (Section 21.14)."""
+
+    def __init__(self, connection: sqlite3.Connection) -> None:
+        self._connection = connection
+
+    def list_archive_dates(self) -> list[date]:
+        """All distinct dates with archived tasks, newest first.
+
+        Routine activity never sets archived_date on the tasks table, so
+        the query naturally excludes it (FR-068).
+        """
+        rows = self._connection.execute(
+            """
+            SELECT DISTINCT archived_date
+            FROM tasks
+            WHERE archived_date IS NOT NULL
+            ORDER BY archived_date DESC
+            """
+        ).fetchall()
+        return [date.fromisoformat(row["archived_date"]) for row in rows]
+
+    def list_week_items(
+        self, week_start: date, week_end_exclusive: date
+    ) -> list[tuple[date, list[ArchivedTask]]]:
+        """Archived tasks in [week_start, week_end_exclusive), grouped by day.
+
+        Days are returned oldest-first. Tasks within each day follow their
+        original archive_order. Only completed and deleted tasks appear
+        (the schema constraint ensures no open/migrated tasks are archived).
+        """
+        rows = self._connection.execute(
+            """
+            SELECT text, state, archived_date
+            FROM tasks
+            WHERE archived_date IS NOT NULL
+              AND archived_date >= ?
+              AND archived_date < ?
+            ORDER BY archived_date ASC, archive_order ASC
+            """,
+            (week_start.isoformat(), week_end_exclusive.isoformat()),
+        ).fetchall()
+
+        grouped: dict[date, list[ArchivedTask]] = {}
+        for row in rows:
+            d = date.fromisoformat(row["archived_date"])
+            grouped.setdefault(d, []).append(
+                ArchivedTask(text=row["text"], state=TaskState(row["state"]))
+            )
+        return [(d, tasks) for d, tasks in grouped.items()]
+
+
+def week_start_for(d: date, *, first_weekday: int) -> date:
+    """Return the start of the calendar week containing d.
+
+    first_weekday uses Python's weekday() convention: 0=Monday, 6=Sunday.
+    """
+    days_back = (d.weekday() - first_weekday) % 7
+    return d - timedelta(days=days_back)

rook/persistence/database.py

@@ -0,0 +1,18 @@
+import sqlite3
+from pathlib import Path
+
+
+def connect(path: Path) -> sqlite3.Connection:
+    """Open a Rook database connection with the required pragmas (Section 15.4).
+
+    Creates the parent directory if needed - the database must never be
+    expected to already exist at a fresh install.
+    """
+    path.parent.mkdir(parents=True, exist_ok=True)
+    connection = sqlite3.connect(path)
+    connection.row_factory = sqlite3.Row
+    connection.execute("PRAGMA foreign_keys = ON;")
+    connection.execute("PRAGMA busy_timeout = 3000;")
+    connection.execute("PRAGMA journal_mode = DELETE;")
+    connection.execute("PRAGMA synchronous = FULL;")
+    return connection

rook/persistence/metadata.py

@@ -0,0 +1,56 @@
+import sqlite3
+from datetime import date
+
+_LAST_PROCESSED_DATE_KEY = "last_processed_date"
+_WEEK_START_DAY_KEY = "week_start_day"
+
+# Python weekday() values: 0 = Monday, 6 = Sunday.
+_WEEK_START_VALUES = {"sunday": 6, "monday": 0}
+_WEEK_START_DEFAULT = 6  # Sunday
+
+
+class MetadataRepository:
+    """SQL access for the small `app_meta` key/value table (Section 15.7)."""
+
+    def __init__(self, connection: sqlite3.Connection) -> None:
+        self._connection = connection
+
+    def get_last_processed_date(self) -> date | None:
+        row = self._connection.execute(
+            "SELECT value FROM app_meta WHERE key = ?", (_LAST_PROCESSED_DATE_KEY,)
+        ).fetchone()
+        return date.fromisoformat(row["value"]) if row is not None else None
+
+    def set_last_processed_date(self, value: date) -> None:
+        with self._connection:
+            self._connection.execute(
+                """
+                INSERT INTO app_meta (key, value) VALUES (?, ?)
+                ON CONFLICT(key) DO UPDATE SET value = excluded.value
+                """,
+                (_LAST_PROCESSED_DATE_KEY, value.isoformat()),
+            )
+
+    def get_week_start_day(self) -> int:
+        """Return the first weekday as a Python weekday() int (0=Mon, 6=Sun).
+
+        Defaults to 6 (Sunday) when the key is absent or unrecognised.
+        """
+        row = self._connection.execute(
+            "SELECT value FROM app_meta WHERE key = ?", (_WEEK_START_DAY_KEY,)
+        ).fetchone()
+        if row is None:
+            return _WEEK_START_DEFAULT
+        return _WEEK_START_VALUES.get(row["value"], _WEEK_START_DEFAULT)
+
+    def set_week_start_day(self, first_weekday: int) -> None:
+        """Persist week_start_day. first_weekday must be 0 (Mon) or 6 (Sun)."""
+        label = next(k for k, v in _WEEK_START_VALUES.items() if v == first_weekday)
+        with self._connection:
+            self._connection.execute(
+                """
+                INSERT INTO app_meta (key, value) VALUES (?, ?)
+                ON CONFLICT(key) DO UPDATE SET value = excluded.value
+                """,
+                (_WEEK_START_DAY_KEY, label),
+            )