typefaster-cli 0.1.0__py3-none-any.whl

typefaster/ui/screens/leaderboard.py

@@ -0,0 +1,52 @@
+"""Leaderboard screen — local top runs (online tiers arrive in Phase 2)."""
+
+from __future__ import annotations
+
+from rich.console import Group, RenderableType
+from rich.table import Table
+from rich.text import Text
+
+from ._base import PanelScreen
+
+
+class LeaderboardScreen(PanelScreen):
+    title_text = "LEADERBOARD (local)"
+
+    def body(self) -> RenderableType:
+        stats = self.app.services.stats  # type: ignore[attr-defined]
+        blocks: list[RenderableType] = []
+
+        for seconds in (30, 60, 120):
+            runs = stats.top_time_runs(seconds, limit=5)
+            table = Table(title=f"Time Attack · {seconds}s", title_style="bold", expand=True)
+            table.add_column("#", justify="right")
+            table.add_column("WPM", justify="right")
+            table.add_column("Acc", justify="right")
+            table.add_column("Date")
+            if not runs:
+                table.add_row("—", "—", "—", "no runs yet")
+            for i, r in enumerate(runs, 1):
+                table.add_row(str(i), f"{r.wpm:.0f}", f"{r.accuracy * 100:.0f}%", r.started_at[:10])
+            blocks.append(table)
+
+        quote_runs = stats.top_quote_runs(limit=5)
+        qt = Table(title="Quote · top WPM", title_style="bold", expand=True)
+        qt.add_column("#", justify="right")
+        qt.add_column("WPM", justify="right")
+        qt.add_column("Acc", justify="right")
+        qt.add_column("Time", justify="right")
+        if not quote_runs:
+            qt.add_row("—", "—", "—", "no runs yet")
+        for i, r in enumerate(quote_runs, 1):
+            qt.add_row(
+                str(i), f"{r.wpm:.0f}", f"{r.accuracy * 100:.0f}%", f"{r.duration_ms / 1000:.1f}s"
+            )
+        blocks.append(qt)
+
+        blocks.append(
+            Text(
+                "\n🌐 Global / Daily / Weekly leaderboards arrive with online mode (Phase 2).",
+                style="grey58",
+            )
+        )
+        return Group(*blocks)

typefaster/ui/screens/main_menu.py

@@ -0,0 +1,96 @@
+"""Main menu — keyboard-driven entry point."""
+
+from __future__ import annotations
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.screen import Screen
+from textual.widgets import OptionList, Static
+from textual.widgets.option_list import Option
+
+from ...domain.models import RaceKind, RaceMode
+from ...services.race_service import RaceConfig
+
+_TIMES = [30, 60, 120]
+
+
+class MainMenu(Screen[None]):
+    BINDINGS = [
+        ("q", "quit_app", "Quit"),
+        ("question_mark", "help", "Help"),
+        ("left", "time_change(-1)", "−time"),
+        ("right", "time_change(1)", "+time"),
+    ]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._time_seconds = 60
+
+    def _time_label(self) -> str:
+        return f"Time Attack  ‹ {self._time_seconds}s ›   (←/→ to change)"
+
+    def _items(self) -> list[tuple[str, str]]:
+        return [
+            ("quick", "▸ Quick Race  (new quote each time)"),
+            ("time", self._time_label()),
+            ("practice", "Practice"),
+            ("daily", "Daily Challenge"),
+            ("stats", "Stats"),
+            ("history", "History"),
+            ("profile", "Profile"),
+            ("leaderboard", "Leaderboard"),
+            ("settings", "Settings"),
+            ("quit", "Quit"),
+        ]
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="menu-wrap"):
+            yield Static(Text("⌨  T Y P E F A S T E R", justify="center"), id="title")
+            yield Static(self._tagline(), id="subtitle")
+            yield OptionList(*[Option(label, id=key) for key, label in self._items()])
+
+    def _tagline(self) -> Text:
+        p = self.app.services.profile.get()  # type: ignore[attr-defined]
+        return Text(
+            f"best {p.best_wpm:.0f} wpm  ·  races {p.races_played}  ·  offline mode",
+            justify="center",
+        )
+
+    def on_mount(self) -> None:
+        self.query_one(OptionList).focus()
+
+    # ── inline duration selector on the Time Attack row ────────────────
+    def action_time_change(self, delta: int) -> None:
+        ol = self.query_one(OptionList)
+        highlighted = ol.highlighted
+        # Only adjust when the Time Attack row is the highlighted one.
+        if highlighted is None or ol.get_option_at_index(highlighted).id != "time":
+            return
+        i = (_TIMES.index(self._time_seconds) + delta) % len(_TIMES)
+        self._time_seconds = _TIMES[i]
+        ol.replace_option_prompt("time", self._time_label())
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        app = self.app
+        match event.option.id:
+            case "quick":
+                app.start_race(  # type: ignore[attr-defined]
+                    RaceConfig(kind=RaceKind.QUOTE, ghost_kind=None)
+                )
+            case "time":
+                app.start_race(  # type: ignore[attr-defined]
+                    RaceConfig(kind=RaceKind.TIME, mode=RaceMode(self._time_seconds))
+                )
+            case "quit":
+                app.exit()
+            case None:
+                return
+            case name:
+                app.open(name)  # type: ignore[attr-defined]
+
+    def action_quit_app(self) -> None:
+        self.app.exit()
+
+    def action_help(self) -> None:
+        self.app.open("help")  # type: ignore[attr-defined]

typefaster/ui/screens/online_race.py

@@ -0,0 +1,241 @@
+"""Online multiplayer race screen.
+
+Connects to the server over WebSocket, auto-readies, and lets the **server**
+drive countdown/start/finish. The client only renders state, reports progress,
+and submits a final result for server-side validation.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import time
+from typing import Any
+
+import websockets
+from rich.console import Group
+from rich.table import Table
+from rich.text import Text
+from textual import events
+from textual.app import ComposeResult
+from textual.containers import Vertical, VerticalScroll
+from textual.screen import Screen
+from textual.widgets import Static
+
+from ...domain.typing_engine import TypingEngine
+from ..widgets.live_stats import LiveStats
+from ..widgets.typing_field import TypingField
+
+
+def _bar(pct: float, width: int = 24) -> str:
+    filled = max(0, min(width, round(pct / 100.0 * width)))
+    return "#" * filled + "-" * (width - filled)
+
+
+class OnlineRaceScreen(Screen[None]):
+    BINDINGS = [("escape", "leave", "Leave")]
+
+    def __init__(self, ws_url: str, username: str, mode_seconds: int) -> None:
+        super().__init__()
+        self.ws_url = ws_url
+        self.username = username
+        self.mode_seconds = mode_seconds
+        self.engine: TypingEngine | None = None
+        self._ws: Any = None
+        self._start_ms: int | None = None
+        self._typing = False
+        self._finished = False
+        self._opponents: dict[str, dict[str, float]] = {}
+        self._status = "Connecting…"
+        self._standings: list[dict[str, Any]] | None = None
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="race-wrap"):
+            yield Static("", id="net-status", classes="dim")
+            yield LiveStats()
+            yield TypingField()
+            with VerticalScroll():
+                yield Static("", id="bars")
+            yield Static("esc to leave", classes="dim")
+
+    def on_mount(self) -> None:
+        self.query_one(LiveStats).display = False
+        self.query_one(TypingField).display = False
+        self._render_status()
+        self.run_worker(self._net_loop(), exclusive=True, name="ws")
+        self.set_interval(0.2, self._tick)
+
+    # ── network ────────────────────────────────────────────────────────
+    async def _net_loop(self) -> None:
+        try:
+            async with websockets.connect(self.ws_url) as ws:
+                self._ws = ws
+                self._status = "Connected. Waiting for players to ready up…"
+                self._render_status()
+                await ws.send(json.dumps({"type": "SET_READY", "data": {"ready": True}}))
+                async for raw in ws:
+                    self._handle(json.loads(raw))
+        except Exception as exc:
+            self._status = f"Disconnected: {exc}"
+            self._render_status()
+
+    async def _send(self, type_: str, **data: Any) -> None:
+        if self._ws is not None:
+            with contextlib.suppress(Exception):
+                await self._ws.send(json.dumps({"type": type_, "data": data}))
+
+    def _handle(self, msg: dict[str, Any]) -> None:
+        etype = msg.get("type")
+        data = msg.get("data", {})
+        if etype == "RACE_COUNTDOWN":
+            self._status = f"Race starts in {data.get('count')}…"
+            self._render_status()
+        elif etype == "RACE_START":
+            self._begin(data["text"])
+        elif etype == "RACE_PROGRESS":
+            user = data.get("username")
+            if user and user != self.username:
+                self._opponents[user] = {
+                    "progress": float(data.get("progress", 0)),
+                    "wpm": float(data.get("wpm", 0)),
+                }
+                self._render_bars()
+        elif etype == "RACE_FINISHED":
+            if data.get("final"):
+                self._standings = data.get("standings", [])
+                self._show_standings()
+            else:
+                user = data.get("username")
+                if user and user != self.username:
+                    self._opponents.setdefault(user, {})["progress"] = 100.0
+                    self._render_bars()
+        elif etype == "CHAT_MESSAGE":
+            pass  # chat panel could render here
+
+    # ── race lifecycle ─────────────────────────────────────────────────
+    def _begin(self, text: str) -> None:
+        self.engine = TypingEngine(text)
+        self._start_ms = int(time.time() * 1000)
+        self._typing = True
+        self._status = "GO!"
+        self.query_one("#net-status", Static).display = False
+        self.query_one(LiveStats).display = True
+        self.query_one(TypingField).display = True
+        self._render_field()
+
+    def _elapsed(self) -> int:
+        return 0 if self._start_ms is None else int(time.time() * 1000) - self._start_ms
+
+    def _tick(self) -> None:
+        if not self._typing or self.engine is None:
+            return
+        elapsed = self._elapsed()
+        seconds_left = (self.mode_seconds * 1000 - elapsed) / 1000.0
+        self.query_one(LiveStats).show(
+            wpm=self.engine.live_wpm(max(elapsed, 1)),
+            accuracy=self.engine.live_accuracy(),
+            progress=self.engine.progress,
+            seconds_left=seconds_left,
+        )
+        self._render_bars()
+        # Report progress to the server.
+        self.run_worker(
+            self._send(
+                "PROGRESS",
+                progress=self.engine.progress * 100.0,
+                wpm=round(self.engine.live_wpm(max(elapsed, 1)), 1),
+            ),
+            name="progress",
+        )
+        if (elapsed >= self.mode_seconds * 1000 or self.engine.finished) and not self._finished:
+            self._submit_finish()
+
+    def on_key(self, event: events.Key) -> None:
+        if not self._typing or self._finished or self.engine is None:
+            return
+        t = self._elapsed()
+        if event.key == "backspace":
+            self.engine.backspace(t)
+            event.stop()
+        elif event.character is not None and event.character.isprintable():
+            self.engine.type_char(event.character, t)
+            event.stop()
+        else:
+            return
+        self._render_field()
+        if self.engine.finished:
+            self._submit_finish()
+
+    def _submit_finish(self) -> None:
+        if self._finished or self.engine is None:
+            return
+        self._finished = True
+        self._typing = False
+        eng = self.engine
+        self.run_worker(
+            self._send(
+                "FINISH",
+                duration_ms=self._elapsed(),
+                correct_chars=eng.correct_chars,
+                incorrect_chars=eng.incorrect_chars,
+                total_keystrokes=eng.total_keystrokes,
+                correct_keystrokes=eng.correct_keystrokes,
+                pasted=False,
+            ),
+            name="finish",
+        )
+        self._status = "Finished — waiting for other racers…"
+        self.query_one("#net-status", Static).display = True
+        self._render_status()
+
+    # ── rendering ──────────────────────────────────────────────────────
+    def _render_status(self) -> None:
+        self.query_one("#net-status", Static).update(Text(self._status, justify="center"))
+
+    def _render_field(self) -> None:
+        if self.engine is not None:
+            self.query_one(TypingField).show(
+                self.engine.target, self.engine.states, self.engine.cursor
+            )
+
+    def _render_bars(self) -> None:
+        text = Text()
+        me_pct = self.engine.progress * 100.0 if self.engine else 0.0
+        text.append("You    ", style="bold")
+        text.append(f"[{_bar(me_pct)}] {me_pct:3.0f}%\n", style="cyan")
+        for name, st in sorted(self._opponents.items()):
+            pct = st.get("progress", 0.0)
+            text.append(f"{name[:7]:<7}", style="bold")
+            text.append(f"[{_bar(pct)}] {pct:3.0f}%\n", style="magenta")
+        self.query_one("#bars", Static).update(text)
+
+    def _show_standings(self) -> None:
+        self._typing = False
+        table = Table(title="Final Standings", title_style="bold")
+        table.add_column("#", justify="right")
+        table.add_column("Player")
+        table.add_column("WPM", justify="right")
+        table.add_column("Acc", justify="right")
+        for i, row in enumerate(self._standings or [], 1):
+            flag = " ⚑" if row.get("suspicious") else ""
+            table.add_row(
+                str(i),
+                f"{row.get('username', '?')}{flag}",
+                f"{row.get('wpm', 0):.0f}",
+                f"{row.get('accuracy', 0) * 100:.0f}%",
+            )
+        self.query_one("#net-status", Static).display = True
+        self.query_one(TypingField).display = False
+        self.query_one(LiveStats).display = False
+        self.query_one("#bars", Static).update(Group(table, Text("\nesc to leave", style="grey58")))
+
+    # ── exit ───────────────────────────────────────────────────────────
+    def action_leave(self) -> None:
+        self.run_worker(self._send("LEAVE"), name="leave")
+        if self._ws is not None:
+            self.run_worker(self._close_ws(), name="close")
+        self.app.pop_screen()
+
+    async def _close_ws(self) -> None:
+        with contextlib.suppress(Exception):
+            await self._ws.close()

typefaster/ui/screens/practice.py

@@ -0,0 +1,57 @@
+"""Practice mode — pick a race configuration, then race."""
+
+from __future__ import annotations
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.screen import Screen
+from textual.widgets import OptionList, Static
+from textual.widgets.option_list import Option
+
+from ...domain.models import GhostKind, RaceKind, RaceMode
+from ...services.race_service import RaceConfig
+
+
+class PracticeScreen(Screen[None]):
+    BINDINGS = [("escape", "back", "Back")]
+
+    _ITEMS: list[tuple[str, str, RaceConfig]] = [
+        ("q_rand", "Quote · random", RaceConfig(kind=RaceKind.QUOTE)),
+        (
+            "q_pb",
+            "Quote · vs Personal Best ghost",
+            RaceConfig(kind=RaceKind.QUOTE, ghost_kind=GhostKind.PERSONAL_BEST),
+        ),
+        (
+            "q_last",
+            "Quote · vs Last race ghost",
+            RaceConfig(kind=RaceKind.QUOTE, ghost_kind=GhostKind.LAST),
+        ),
+        (
+            "q_rng",
+            "Quote · vs Random ghost",
+            RaceConfig(kind=RaceKind.QUOTE, ghost_kind=GhostKind.RANDOM),
+        ),
+        ("t30", "Time Attack · 30s", RaceConfig(kind=RaceKind.TIME, mode=RaceMode.SHORT)),
+        ("t60", "Time Attack · 60s", RaceConfig(kind=RaceKind.TIME, mode=RaceMode.NORMAL)),
+        ("t120", "Time Attack · 120s", RaceConfig(kind=RaceKind.TIME, mode=RaceMode.LONG)),
+    ]
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="menu-wrap"):
+            yield Static(Text("PRACTICE", justify="center"), id="title")
+            yield OptionList(*[Option(label, id=key) for key, label, _ in self._ITEMS])
+            yield Static("esc back", classes="dim")
+
+    def on_mount(self) -> None:
+        self.query_one(OptionList).focus()
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        for key, _, config in self._ITEMS:
+            if key == event.option.id:
+                self.app.start_race(config)  # type: ignore[attr-defined]
+                return
+
+    def action_back(self) -> None:
+        self.app.pop_screen()

typefaster/ui/screens/profile.py

@@ -0,0 +1,28 @@
+"""Profile screen."""
+
+from __future__ import annotations
+
+from rich.console import Group, RenderableType
+from rich.table import Table
+from rich.text import Text
+
+from ._base import PanelScreen
+from .stats import _fmt_ms
+
+
+class ProfileScreen(PanelScreen):
+    title_text = "PROFILE"
+
+    def body(self) -> RenderableType:
+        p = self.app.services.profile.get()  # type: ignore[attr-defined]
+        grid = Table.grid(padding=(0, 3))
+        grid.add_column(justify="right", style="grey58")
+        grid.add_column(justify="left")
+        grid.add_row("Name", p.display_name)
+        grid.add_row("Member since", (p.created_at or "—")[:10])
+        grid.add_row("Races", str(p.races_played))
+        grid.add_row("Best WPM", f"{p.best_wpm:.0f}")
+        grid.add_row("Total time", _fmt_ms(p.total_time_ms))
+        grid.add_row("Total chars", f"{p.total_chars:,}")
+        note = Text("\nAchievements & online profile arrive in Phase 2.", style="grey58")
+        return Group(grid, note)