@pennyfarthing/core 11.2.0 → 11.2.1

package/pennyfarthing_scripts/bikerack/changed_panel.py

@@ -2,6 +2,8 @@
 
 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
@@ -9,6 +11,7 @@ from __future__ import annotations
 from typing import Any
 
 from rich.text import Text
+from textual.binding import Binding
 
 from pennyfarthing_scripts.bikerack.base_panel import PANEL_ICONS, BasePanel
 
@@ -55,15 +58,98 @@ 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 files grouped by repository."""
+        """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")
@@ -85,6 +171,7 @@ class ChangedPanel(BasePanel):
         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"
@@ -97,12 +184,17 @@ class ChangedPanel(BasePanel):
                 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()
-                line.append("  ")
+                if is_selected:
+                    line.append("› ", style="bold reverse")
+                else:
+                    line.append("  ")
                 line.append(icon, style=f"bold {style}")
-                line.append(f" {path}", style="cyan")
+                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
 

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

@@ -103,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
 

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,6 +47,12 @@ 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)
@@ -87,6 +94,29 @@ class DiffsPanel(BasePanel):
                 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:

package/pennyfarthing_scripts/bikerack/events.py

@@ -0,0 +1,28 @@
+"""Cross-panel event bus for BikeRack TUI (Story 110-1).
+
+Defines Textual Message subclasses for inter-panel communication.
+First use case: NavigateToFile posted by ChangedPanel, handled by App
+to switch to DiffsPanel filtered to that file.
+"""
+
+from __future__ import annotations
+
+from textual.message import Message
+
+
+class PanelEvent(Message):
+    """Base message class for cross-panel communication."""
+
+    pass
+
+
+class NavigateToFile(PanelEvent):
+    """Navigate to a specific file in the diffs panel.
+
+    Posted by ChangedPanel when user presses Enter on a selected file.
+    Handled by BikeRackApp to switch to DiffsPanel and navigate to that file.
+    """
+
+    def __init__(self, path: str) -> None:
+        super().__init__()
+        self.path = path

package/pennyfarthing_scripts/bikerack/portrait_resolver.py

@@ -0,0 +1,139 @@
+"""Portrait path resolution for BikeRack TUI.
+
+Resolves persona portrait image paths using the canonical theme discovery
+from ``pennyfarthing_scripts.common.themes``.  Each theme directory that
+contains ``themes/{name}.yaml`` has a sibling ``portraits/{name}/`` with
+size-bucketed portrait images.
+
+Story 110-3: Portrait image header with textual-image.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import yaml
+
+
+def _to_slug(name: str) -> str:
+    """Convert a name to URL-safe slug (lowercase kebab-case)."""
+    return re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")
+
+
+def _extract_agent_slug(theme_yaml: Path, agent: str) -> str | None:
+    """Extract portrait slug (shortName-OCEAN) from a theme YAML file."""
+    if not theme_yaml.exists():
+        return None
+    try:
+        data = yaml.safe_load(theme_yaml.read_text())
+        agent_data = (data or {}).get("agents", {}).get(agent)
+        if not agent_data:
+            return None
+        short_name = agent_data.get("shortName") or (
+            agent_data.get("character", "").split()[0] if agent_data.get("character") else None
+        )
+        ocean = agent_data.get("ocean", {})
+        if short_name and all(k in ocean for k in "OCEAN"):
+            return f"{_to_slug(short_name)}-{ocean['O']}{ocean['C']}{ocean['E']}{ocean['A']}{ocean['N']}"
+    except Exception:
+        pass
+    return None
+
+
+def _find_portrait(portraits_theme_dir: Path, slug: str) -> Path | None:
+    """Find a portrait file matching the slug in a theme's portrait directory."""
+    if not portraits_theme_dir.is_dir():
+        return None
+    for size in ["medium", "large", "small", "original"]:
+        size_dir = portraits_theme_dir / size
+        if size_dir.is_dir():
+            for f in size_dir.iterdir():
+                if f.name.lower().startswith(slug.lower()) and f.suffix in (".png", ".jpg"):
+                    return f
+    # Fallback to root of theme dir
+    for f in portraits_theme_dir.iterdir():
+        if f.is_file() and f.name.lower().startswith(slug.lower()) and f.suffix in (".png", ".jpg"):
+            return f
+    return None
+
+
+def resolve_portrait_path(
+    theme: str, agent: str, project_root: Path | None = None
+) -> Path | None:
+    """Resolve the full path to a portrait image.
+
+    Uses ``discover_all_theme_dirs`` from ``common.themes`` to search core
+    themes, installed theme packages, monorepo workspace packages, and
+    custom themes — in canonical priority order.
+
+    For each theme directory the portrait sibling is derived:
+    - ``.pennyfarthing/personas/themes/`` → ``.pennyfarthing/personas/portraits/``
+    - ``themes-*/themes/`` → ``themes-*/portraits/``
+
+    Args:
+        theme: Theme name (e.g., 'hogans-heroes', 'monty-python')
+        agent: Agent role (e.g., 'sm', 'tea', 'dev')
+        project_root: Project root for path resolution. Defaults to cwd.
+
+    Returns:
+        Path to portrait file, or None if not found.
+    """
+    from pennyfarthing_scripts.common.themes import discover_all_theme_dirs
+
+    theme_dirs = discover_all_theme_dirs(project_root)
+
+    # Resolve slug from the first theme dir that has this theme's YAML
+    slug: str | None = None
+    for themes_dir in theme_dirs:
+        theme_yaml = themes_dir / f"{theme}.yaml"
+        slug = _extract_agent_slug(theme_yaml, agent)
+        if slug:
+            break
+
+    if not slug:
+        return None
+
+    # Search portrait directories (sibling of each themes dir)
+    for themes_dir in theme_dirs:
+        portraits_dir = themes_dir.parent / "portraits" / theme
+        result = _find_portrait(portraits_dir, slug)
+        if result:
+            return result
+
+    return None
+
+
+def detect_image_protocol() -> str | None:
+    """Detect the best available terminal image protocol.
+
+    Uses environment variables for reliable detection since subprocess
+    stdout may not be a TTY (e.g., when launched via Claude Code).
+
+    Returns:
+        Protocol name ('kitty', 'sixel', 'halfcell', None for unsupported).
+    """
+    import os
+
+    # Kitty: TERM=xterm-kitty or KITTY_WINDOW_ID present
+    term = os.environ.get("TERM", "")
+    if "kitty" in term or os.environ.get("KITTY_WINDOW_ID"):
+        return "kitty"
+
+    # Sixel: some terminals advertise via TERM or COLORTERM
+    # WezTerm, foot, mlterm support sixel
+    term_program = os.environ.get("TERM_PROGRAM", "")
+    if term_program.lower() in ("wezterm", "foot", "mlterm"):
+        return "sixel"
+
+    # Fallback: try textual-image's cell size probe for halfcell baseline
+    try:
+        from textual_image._terminal import get_cell_size
+
+        cell_size = get_cell_size()
+        if cell_size and cell_size.width > 0:
+            return "halfcell"
+    except Exception:
+        pass
+
+    return None