@pennyfarthing/core 11.1.1 → 11.2.1

package/pennyfarthing_scripts/bikerack/base_panel.py

@@ -9,6 +9,8 @@ from __future__ import annotations
 
 from typing import Any
 
+from rich.text import Text
+from textual.message import Message
 from textual.widgets import Static
 
 # Nerd Font icon registry: panel_name → (nerd_font_icon, ascii_fallback)
@@ -25,6 +27,7 @@ PANEL_ICONS: dict[str, tuple[str, str]] = {
     "debug": ("\uf188", "d"),        # nf-fa-bug
     "settings": ("\uf013", "S"),     # nf-fa-gear
     "tty": ("\uf120", ">"),          # nf-fa-terminal
+    "progress": ("\uf200", "P"),     # nf-fa-pie_chart
 }
 
 
@@ -44,6 +47,74 @@ def get_panel_icon(panel_name: str, use_nerd_font: bool = True) -> str:
     return entry[0] if use_nerd_font else entry[1]
 
 
+def render_progress_bar(
+    percent: int | float,
+    width: int = 20,
+    warn_high: bool = False,
+    fill_style: str | None = None,
+) -> Text:
+    """Render a Unicode progress bar with color based on percentage.
+
+    Args:
+        percent: Value 0-100.
+        width: Number of bar characters (default 20).
+        warn_high: If True, use red at high values (for resource usage).
+                   If False (default), use blue at 100% (for completion).
+        fill_style: Override the computed fill color (e.g. ``"dim green"``).
+
+    Returns:
+        Rich Text like ``[████████░░░░░░░░░░░░] 22%``
+    """
+    percent = max(0, min(100, int(percent)))
+    filled = round(width * percent / 100)
+    empty = width - filled
+
+    if fill_style is not None:
+        style = fill_style
+    elif warn_high:
+        if percent < 50:
+            style = "green"
+        elif percent <= 80:
+            style = "yellow"
+        else:
+            style = "red"
+    else:
+        style = "blue"
+
+    bar = Text()
+    bar.append("[")
+    bar.append("█" * filled, style=style)
+    bar.append("░" * empty, style="dim")
+    bar.append(f"] {percent}%")
+    return bar
+
+
+def format_duration(seconds: int | float) -> str:
+    """Format seconds into human-friendly duration string.
+
+    Returns:
+        ``47s``, ``2m 14s``, ``1h 5m``.
+    """
+    seconds = max(0, int(seconds))
+    if seconds < 60:
+        return f"{seconds}s"
+    minutes, secs = divmod(seconds, 60)
+    if minutes < 60:
+        return f"{minutes}m {secs}s"
+    hours, mins = divmod(minutes, 60)
+    return f"{hours}h {mins}m"
+
+
+def humanize_theme(slug: str) -> str:
+    """Convert a theme slug to a display name.
+
+    ``princess-bride`` → ``Princess Bride``
+    """
+    if not slug:
+        return ""
+    return slug.replace("-", " ").replace("_", " ").title()
+
+
 class BasePanel(Static):
     """Base class for BikeRack TUI panels.
 
@@ -51,6 +122,13 @@ class BasePanel(Static):
     ``render_panel(payload)`` to return a Rich renderable.
     """
 
+    class DataReceived(Message, bubble=False):
+        """WebSocket data received — routed through Textual message system."""
+
+        def __init__(self, content: Any) -> None:
+            super().__init__()
+            self.content = content
+
     #: WebSocket channel this panel subscribes to (override in subclass)
     channel: str = ""
 
@@ -76,10 +154,17 @@ class BasePanel(Static):
         """Mark panel as unmounted — messages ignored after this."""
         self._mounted = False
 
+    def on_base_panel_data_received(self, event: DataReceived) -> None:
+        """Process DataReceived in Textual message context — triggers repaint."""
+        self.update(event.content)
+
     def handle_message(self, message: dict[str, Any] | None) -> None:
         """Handle incoming WebSocket message.
 
-        Stores payload, calls render_panel, updates widget display.
+        Stores payload, calls render_panel, posts DataReceived message.
+        Uses post_message to route through Textual's message system,
+        ensuring proper repaint cycle (call_from_thread / direct update
+        from async WS tasks does not reliably trigger redraws).
         No-op after unmount or if message is None.
         """
         if not self._mounted or message is None:
@@ -87,7 +172,7 @@ class BasePanel(Static):
         self._last_payload = message
         rendered = self.render_panel(message)
         try:
-            self.update(rendered)
+            self.post_message(self.DataReceived(rendered))
         except Exception:
             pass
 

package/pennyfarthing_scripts/bikerack/changed_panel.py

@@ -2,14 +2,16 @@
 
 Story 103-14: Subscribes to /ws/git, extracts dirtyFiles from all repos,
 renders Rich table with file path, change type icon, and status.
+
+Story 110-1: Selectable file list with arrow navigation and Enter to navigate.
 """
 
 from __future__ import annotations
 
 from typing import Any
 
-from rich.table import Table
 from rich.text import Text
+from textual.binding import Binding
 
 from pennyfarthing_scripts.bikerack.base_panel import PANEL_ICONS, BasePanel
 
@@ -56,50 +58,144 @@ class ChangedPanel(BasePanel):
 
     Subscribes to the ``git`` WebSocket channel and renders
     dirty files from all repos as a Rich table with file path,
-    change type icon, and status.
+    change type icon, and status. Supports arrow-key selection
+    and Enter to navigate to diffs.
     """
 
     channel: str = "git"
     panel_name: str = "Changed"
     icon: str = PANEL_ICONS["changed"][0]
+    can_focus = True
+
+    BINDINGS = [
+        Binding("up", "select_prev_key", "Up"),
+        Binding("down", "select_next_key", "Down"),
+        Binding("enter", "select_file", "Select file"),
+    ]
+
+    def __init__(self, client=None, **kwargs):
+        super().__init__(client=client, **kwargs)
+        self._selected_index: int = 0
+        self._file_paths: list[str] = []
+
+    def handle_message(self, message: dict[str, Any] | None) -> None:
+        """Handle incoming message — build file path index then render."""
+        if message is not None:
+            self._build_file_paths(message)
+        super().handle_message(message)
+
+    def _build_file_paths(self, payload: dict[str, Any]) -> None:
+        """Extract flat list of file paths from repos payload."""
+        paths: list[str] = []
+        repos = payload.get("repos", [])
+        if isinstance(repos, list):
+            for repo in repos:
+                if not isinstance(repo, dict):
+                    continue
+                dirty_files = repo.get("dirtyFiles", [])
+                if not isinstance(dirty_files, list):
+                    continue
+                for f in dirty_files:
+                    if isinstance(f, dict):
+                        path = f.get("path", "")
+                        if path:
+                            paths.append(path)
+        self._file_paths = paths
+        if self._selected_index >= len(paths):
+            self._selected_index = max(0, len(paths) - 1)
+
+    def select_next(self) -> None:
+        """Move selection to the next file."""
+        if self._file_paths and self._selected_index < len(self._file_paths) - 1:
+            self._selected_index += 1
+            self._rerender()
+
+    def select_prev(self) -> None:
+        """Move selection to the previous file."""
+        if self._selected_index > 0:
+            self._selected_index -= 1
+            self._rerender()
+
+    def action_select_next_key(self) -> None:
+        """Binding action: move selection down."""
+        self.select_next()
+
+    def action_select_prev_key(self) -> None:
+        """Binding action: move selection up."""
+        self.select_prev()
+
+    def _rerender(self) -> None:
+        """Re-render panel with current payload after selection change."""
+        if self._last_payload:
+            try:
+                self.update(self.render_panel(self._last_payload))
+            except Exception:
+                pass
+
+    def get_selected_path(self) -> str | None:
+        """Return the currently selected file path, or None if empty."""
+        if not self._file_paths:
+            return None
+        if self._selected_index >= len(self._file_paths):
+            return None
+        return self._file_paths[self._selected_index]
+
+    def action_select_file(self) -> None:
+        """Post NavigateToFile event for the selected file."""
+        path = self.get_selected_path()
+        if path is not None:
+            from pennyfarthing_scripts.bikerack.events import NavigateToFile
+
+            self.post_message(NavigateToFile(path=path))
 
     def render_panel(self, payload: dict[str, Any]) -> Any:
-        """Render changed file data from WebSocket payload."""
+        """Render changed files grouped by repository with selection highlight."""
         repos = payload.get("repos", [])
         if not isinstance(repos, list):
             return Text("No changed files", style="dim italic")
 
-        files: list[tuple[str, dict[str, Any]]] = []
+        # Group files by repo
+        repo_files: dict[str, list[dict[str, Any]]] = {}
         for repo in repos:
             if not isinstance(repo, dict):
                 continue
-            repo_name = repo.get("name", "")
+            repo_name = repo.get("name", "unknown")
             dirty_files = repo.get("dirtyFiles", [])
-            if not isinstance(dirty_files, list):
+            if not isinstance(dirty_files, list) or not dirty_files:
                 continue
-            for f in dirty_files:
-                if not isinstance(f, dict):
-                    continue
-                files.append((repo_name, f))
+            repo_files[repo_name] = [f for f in dirty_files if isinstance(f, dict)]
 
-        if not files:
+        if not repo_files:
             return Text("No changed files", style="dim italic")
 
-        table = Table()
-        table.add_column("", width=2)
-        table.add_column("File", style="cyan")
-        table.add_column("Status")
-        table.add_column("Repo", style="dim")
-
-        for repo_name, f in files:
-            status_code = f.get("status", "  ")
-            path = f.get("path", "")
-            icon, label, style = _parse_status(status_code)
-            table.add_row(
-                Text(icon, style=f"bold {style}"),
-                path,
-                Text(label, style=style),
-                repo_name,
-            )
-
-        return table
+        from rich.console import Group as RichGroup
+
+        parts: list[Any] = []
+        flat_idx = 0
+        for repo_name, files in repo_files.items():
+            count = len(files)
+            label = "file" if count == 1 else "files"
+            header = Text()
+            header.append(repo_name, style="bold cyan")
+            header.append(f" ({count} {label})", style="dim")
+            parts.append(header)
+
+            for f in files:
+                status_code = f.get("status", "  ")
+                path = f.get("path", "")
+                icon, label_text, style = _parse_status(status_code)
+                is_selected = flat_idx == self._selected_index
+                line = Text()
+                if is_selected:
+                    line.append("› ", style="bold reverse")
+                else:
+                    line.append("  ")
+                line.append(icon, style=f"bold {style}")
+                line.append(f" {path}", style="bold cyan reverse" if is_selected else "cyan")
+                line.append(f"  {label_text}", style=style)
+                parts.append(line)
+                flat_idx += 1
+
+            parts.append(Text(""))  # spacer between repos
+
+        return RichGroup(*parts)

package/pennyfarthing_scripts/bikerack/context_meter_footer.py

@@ -0,0 +1,88 @@
+"""ContextMeterFooter — Persistent context usage footer bar for BikeRack TUI.
+
+Story 110-5: Context meter footer bar. Displays context window usage
+percentage with color-coded tier thresholds, always visible at the
+bottom of the layout.
+
+Subscribes to /ws/context WebSocket channel.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from rich.text import Text
+from textual.message import Message
+from textual.widgets import Static
+
+from pennyfarthing_scripts.bikerack.base_panel import render_progress_bar
+
+
+class ContextMeterFooter(Static):
+    """Persistent footer bar showing context window usage.
+
+    Not a Footer subclass — this is a Static widget mounted between
+    #main-content and BindingFooter in the app layout.
+    """
+
+    class MeterUpdate(Message, bubble=False):
+        """Context meter data received — routed through Textual message system."""
+
+        def __init__(self, content: Any) -> None:
+            super().__init__()
+            self.content = content
+
+    #: WebSocket channel this footer subscribes to
+    channel: str = "context"
+
+    def __init__(self, client: Any = None, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self._client = client
+        self._context_data: dict[str, Any] | None = None
+        self._mounted = False
+
+    def on_mount(self) -> None:
+        """Subscribe to context channel on mount."""
+        self._mounted = True
+        if self._client is not None:
+            self._client.subscribe("context", self.handle_context_message)
+
+    def on_unmount(self) -> None:
+        """Mark as unmounted so further messages are ignored."""
+        self._mounted = False
+
+    def on_context_meter_footer_meter_update(self, event: MeterUpdate) -> None:
+        """Process MeterUpdate in Textual message context — triggers repaint."""
+        self.update(event.content)
+
+    def handle_context_message(self, msg: dict[str, Any] | None) -> None:
+        """Process incoming /ws/context message."""
+        if not self._mounted or msg is None:
+            return
+        ctx = msg.get("context")
+        if ctx is None:
+            return
+        self._context_data = ctx
+        try:
+            rendered = self.render_meter(ctx)
+            self.post_message(self.MeterUpdate(rendered))
+        except Exception:
+            pass
+
+    def render_meter(self, ctx: dict[str, Any]) -> Text:
+        """Render a compact context usage bar with percentage and tier badge."""
+        percent = ctx.get("percent", 0)
+        tier = ctx.get("tier", "")
+
+        bar = render_progress_bar(percent, warn_high=True)
+
+        if tier:
+            if percent < 50:
+                tier_style = "green"
+            elif percent <= 80:
+                tier_style = "yellow"
+            else:
+                tier_style = "red"
+            bar.append(f" {tier}", style=f"bold {tier_style}")
+
+        return bar

package/pennyfarthing_scripts/bikerack/debug_panel.py

@@ -7,13 +7,14 @@ token consumption stats (input, output, cache, cost).
 
 from __future__ import annotations
 
+from collections import deque
 from typing import Any
 
 from rich.console import Group
 from rich.table import Table
 from rich.text import Text
 
-from pennyfarthing_scripts.bikerack.base_panel import PANEL_ICONS, BasePanel
+from pennyfarthing_scripts.bikerack.base_panel import PANEL_ICONS, BasePanel, render_progress_bar
 
 # Tier → Rich style mapping
 _TIER_STYLES: dict[str, str] = {
@@ -68,6 +69,7 @@ class DebugPanel(BasePanel):
         super().__init__(client=client, **kwargs)
         self._context_data: dict[str, Any] | None = None
         self._token_stats: dict[str, Any] | None = None
+        self._sparkline_history: deque[int] = deque(maxlen=20)
 
     def on_mount(self) -> None:
         """Subscribe to both context and token-stats channels."""
@@ -83,6 +85,9 @@ class DebugPanel(BasePanel):
         ctx = message.get("context")
         if isinstance(ctx, dict):
             self._context_data = ctx
+            pct = _safe_int(ctx.get("percent"))
+            if pct is not None:
+                self._sparkline_history.append(pct)
         else:
             self._context_data = {}
         self._rerender()
@@ -98,7 +103,7 @@ class DebugPanel(BasePanel):
         """Re-render with the latest data from both channels."""
         rendered = self.render_panel(self._context_data or {})
         try:
-            self.update(rendered)
+            self._thread_safe_update(rendered)
         except Exception:
             pass
 
@@ -110,6 +115,8 @@ class DebugPanel(BasePanel):
         ctx = self._context_data
         if ctx:
             parts.append(_render_context(ctx))
+            if len(self._sparkline_history) >= 2:
+                parts.append(_render_sparkline(self._sparkline_history))
         elif not self._token_stats:
             return Text("No context data", style="dim italic")
 
@@ -157,6 +164,10 @@ def _render_context(ctx: dict[str, Any]) -> Any:
             usage_text.append(f" ({percent}%)")
         parts.append(usage_text)
 
+    # Context usage progress bar
+    if percent is not None:
+        parts.append(render_progress_bar(percent, warn_high=True))
+
     # Breakdown: baseline / conversation / available
     if baseline is not None:
         breakdown = Table(show_header=False, show_edge=False, pad_edge=False, box=None)
@@ -176,6 +187,25 @@ def _render_context(ctx: dict[str, Any]) -> Any:
     return Group(*parts)
 
 
+_SPARKLINE_CHARS = "▁▂▃▄▅▆▇█"
+
+
+def _render_sparkline(history: deque[int]) -> Text:
+    """Render a Unicode sparkline from context usage history."""
+    text = Text()
+    text.append("Context trend: ", style="dim")
+    for pct in history:
+        level = min(7, max(0, int(pct / 100 * 7.99)))
+        if pct < 50:
+            style = "green"
+        elif pct <= 80:
+            style = "yellow"
+        else:
+            style = "red"
+        text.append(_SPARKLINE_CHARS[level], style=style)
+    return text
+
+
 def _render_token_stats(stats: dict[str, Any]) -> Any:
     """Render token stats section."""
     table = Table(show_header=False, show_edge=False, pad_edge=False, box=None)

package/pennyfarthing_scripts/bikerack/diffs_panel.py

@@ -17,6 +17,7 @@ from typing import Any
 from rich.console import Group
 from rich.syntax import Syntax
 from rich.text import Text
+from textual.binding import Binding
 
 from pennyfarthing_scripts.bikerack.base_panel import PANEL_ICONS, BasePanel
 
@@ -46,12 +47,20 @@ class DiffsPanel(BasePanel):
     channel: str = "diffs"
     panel_name: str = "Diffs"
     icon: str = PANEL_ICONS["diffs"][0]
+    can_focus = True
+
+    BINDINGS = [
+        Binding("n", "next_file_key", "Next file"),
+        Binding("p", "prev_file_key", "Prev file"),
+    ]
 
     def __init__(self, client=None, **kwargs):
         super().__init__(client=client, **kwargs)
         self._current_page: int = 0
         self._max_page: int = 0
         self._temp_files: list[str] = []
+        self._current_file_index: int = 0
+        self._total_files: int = 0
 
     def next_page(self) -> None:
         """Advance to the next page of truncated diff content."""
@@ -63,11 +72,57 @@ class DiffsPanel(BasePanel):
         if self._current_page > 0:
             self._current_page -= 1
 
+    def next_file(self) -> None:
+        """Advance to the next file."""
+        if self._current_file_index < self._total_files - 1:
+            self._current_file_index += 1
+            if self._last_payload:
+                rendered = self.render_panel(self._last_payload)
+                try:
+                    self.update(rendered)
+                except Exception:
+                    pass
+
+    def prev_file(self) -> None:
+        """Go back to the previous file."""
+        if self._current_file_index > 0:
+            self._current_file_index -= 1
+            if self._last_payload:
+                rendered = self.render_panel(self._last_payload)
+                try:
+                    self.update(rendered)
+                except Exception:
+                    pass
+
+    def navigate_to_file(self, path: str) -> None:
+        """Jump to a specific file by path. No-op if not found."""
+        if self._last_payload is None:
+            return
+        diffs = self._last_payload.get("diffs", [])
+        for i, d in enumerate(diffs):
+            if d.get("path") == path:
+                self._current_file_index = i
+                rendered = self.render_panel(self._last_payload)
+                try:
+                    self.update(rendered)
+                except Exception:
+                    pass
+                return
+
+    def action_next_file_key(self) -> None:
+        """Binding action: advance to next file."""
+        self.next_file()
+
+    def action_prev_file_key(self) -> None:
+        """Binding action: go to previous file."""
+        self.prev_file()
+
     def handle_message(self, message: dict[str, Any] | None) -> None:
         """Handle incoming WebSocket message with pagination reset and temp management."""
         if not self._mounted or message is None:
             return
         self._current_page = 0
+        self._current_file_index = 0
         self._cleanup_temp_files()
         self._store_large_diffs(message)
         super().handle_message(message)
@@ -78,31 +133,63 @@ class DiffsPanel(BasePanel):
         super().on_unmount()
 
     def render_panel(self, payload: dict[str, Any]) -> Any:
-        """Render diff data from WebSocket payload with truncation/pagination."""
+        """Render diff data showing one file at a time with file selector header."""
         diffs = payload.get("diffs", [])
         if not diffs:
             return Text("No diffs yet", style="dim italic")
 
+        self._total_files = len(diffs)
+
+        # Clamp file index
+        if self._current_file_index >= len(diffs):
+            self._current_file_index = len(diffs) - 1
+
         parts: list[Any] = []
-        max_total = 0
-        for diff_entry in diffs:
-            # Skip syntax highlighting for very large diffs (>2000 lines) for performance
-            raw_diff = diff_entry.get("diff", "")
-            skip_highlight = raw_diff.count("\n") > HIGHLIGHT_THRESHOLD
 
-            file_parts, total_lines = _render_file_diff(
-                diff_entry,
-                page=self._current_page,
-                page_size=DEFAULT_LINE_LIMIT,
-                skip_highlight=skip_highlight,
-            )
-            parts.extend(file_parts)
-            parts.append(Text(""))  # separator between files
-            max_total = max(max_total, total_lines)
+        # File selector header
+        selector = Text()
+        selector.append("Files: ", style="dim")
+        for i, d in enumerate(diffs):
+            path = d.get("path", "unknown")
+            additions = d.get("additions")
+            deletions = d.get("deletions")
+            stats = ""
+            if additions is not None and deletions is not None:
+                stats = f" +{additions} -{deletions}"
+
+            if i == self._current_file_index:
+                selector.append(f"[{i+1}/{len(diffs)}] ", style="bold")
+                selector.append(path, style="bold cyan")
+                if stats:
+                    selector.append(stats, style="bold dim")
+            else:
+                selector.append(path, style="dim")
+                if stats:
+                    selector.append(stats, style="dim")
+
+            if i < len(diffs) - 1:
+                selector.append("  |  ", style="dim")
+
+        parts.append(selector)
+        parts.append(Text("n:next  p:prev", style="dim"))
+        parts.append(Text(""))
+
+        # Render only current file's diff
+        diff_entry = diffs[self._current_file_index]
+        raw_diff = diff_entry.get("diff", "")
+        skip_highlight = raw_diff.count("\n") > HIGHLIGHT_THRESHOLD
+
+        file_parts, total_lines = _render_file_diff(
+            diff_entry,
+            page=self._current_page,
+            page_size=DEFAULT_LINE_LIMIT,
+            skip_highlight=skip_highlight,
+        )
+        parts.extend(file_parts)
 
         # Track max page for pagination bounds
-        if max_total > DEFAULT_LINE_LIMIT:
-            self._max_page = -(-max_total // DEFAULT_LINE_LIMIT) - 1
+        if total_lines > DEFAULT_LINE_LIMIT:
+            self._max_page = -(-total_lines // DEFAULT_LINE_LIMIT) - 1
         else:
             self._max_page = 0