@pennyfarthing/core 11.1.1 → 11.2.1

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/git_panel.py

@@ -8,11 +8,61 @@ from __future__ import annotations
 
 from typing import Any
 
-from rich.table import Table
+from rich.text import Text
 
 from pennyfarthing_scripts.bikerack.base_panel import PANEL_ICONS, BasePanel
 
 
+def _file_breakdown(dirty_files: list[dict]) -> Text:
+    """Break down dirty files into +staged ~modified ?untracked counts."""
+    staged = 0
+    modified = 0
+    untracked = 0
+    for f in dirty_files:
+        if not isinstance(f, dict):
+            continue
+        status = f.get("status", "  ")
+        idx = status[0] if len(status) >= 1 else " "
+        wt = status[1] if len(status) >= 2 else " "
+        if idx == "?" and wt == "?":
+            untracked += 1
+        elif idx not in (" ", "?"):
+            staged += 1
+        elif wt not in (" ", "?"):
+            modified += 1
+
+    parts = Text()
+    parts.append(f"+{staged}", style="green")
+    parts.append(" ")
+    parts.append(f"~{modified}", style="yellow")
+    parts.append(" ")
+    parts.append(f"?{untracked}", style="dim")
+    return parts
+
+
+_FILE_STATUS_MAP: dict[str, tuple[str, str, str]] = {
+    "M": ("~", "Modified", "yellow"),
+    "A": ("+", "Added", "green"),
+    "D": ("-", "Deleted", "red"),
+    "?": ("?", "Untracked", "dim"),
+    "R": ("→", "Renamed", "cyan"),
+}
+
+
+def _parse_file_status(status: str) -> tuple[str, str, str]:
+    """Parse git status code into (icon, label, style)."""
+    if len(status) < 2:
+        return _FILE_STATUS_MAP.get(status[:1], ("·", "Changed", "yellow"))
+    idx, wt = status[0], status[1]
+    if idx == "?" and wt == "?":
+        return _FILE_STATUS_MAP["?"]
+    if idx not in (" ", "?"):
+        return _FILE_STATUS_MAP.get(idx, ("·", "Changed", "yellow"))
+    if wt not in (" ", "?"):
+        return _FILE_STATUS_MAP.get(wt, ("·", "Changed", "yellow"))
+    return ("·", "Changed", "yellow")
+
+
 class GitPanel(BasePanel):
     """Multi-repo git status panel.
 
@@ -26,44 +76,64 @@ class GitPanel(BasePanel):
     icon: str = PANEL_ICONS["git"][0]
 
     def render_panel(self, payload: dict[str, Any]) -> Any:
-        """Render git status as Rich table with Nerd Font glyphs."""
-        table = Table()
-        table.add_column("Repository", style="cyan")
-        table.add_column("Branch")
-        table.add_column("Commits")
-        table.add_column("Changes", justify="right")
-        table.add_column("Status")
-
-        for repo in payload.get("repos", []):
+        """Render git status as Rich Tree with expandable file lists."""
+        from rich.console import Group as RichGroup
+
+        repos = payload.get("repos", [])
+        if not repos:
+            return Text("No repository data", style="dim italic")
+
+        parts: list[Any] = []
+        for repo in repos:
             branch = repo.get("branch", "")
             ahead = repo.get("ahead", 0)
             behind = repo.get("behind", 0)
             clean = repo.get("clean", True)
             dirty_files = repo.get("dirtyFiles", [])
+            name = repo.get("name", "")
 
-            # Branch with Nerd Font glyph
-            branch_col = f"\ue0a0 {branch}"
+            # Build repo header line
+            header = Text()
+            arrow = "▼" if not clean and dirty_files else "▶"
+            header.append(f"{arrow} ", style="bold")
+            header.append(name, style="bold cyan")
+            header.append(f"  \ue0a0 {branch}", style="dim")
 
-            # Commits: ahead/behind with arrow glyphs
-            parts = []
+            # Commits
+            commit_parts = []
             if ahead:
-                parts.append(f"\u2b06{ahead}")
+                commit_parts.append(f"↑{ahead}")
             if behind:
-                parts.append(f"\u2b07{behind}")
-            commits_col = " ".join(parts) if parts else "—"
-
-            # Changes: count of dirty files
-            changes_col = str(len(dirty_files))
-
-            # Status: checkmark or cross
-            status_col = "\u2713" if clean else "\u2717"
-
-            table.add_row(
-                repo.get("name", ""),
-                branch_col,
-                commits_col,
-                changes_col,
-                status_col,
-            )
-
-        return table
+                commit_parts.append(f"↓{behind}")
+            header.append(f"  {' '.join(commit_parts) if commit_parts else '—'}", style="dim")
+
+            # File breakdown
+            header.append("  ")
+            header.append_text(_file_breakdown(dirty_files))
+
+            # Status
+            header.append("  ")
+            if clean:
+                header.append("✓ clean", style="green")
+            else:
+                header.append("✗ dirty", style="red")
+
+            parts.append(header)
+
+            # Expanded file list for dirty repos
+            if not clean and dirty_files:
+                for f in dirty_files:
+                    if not isinstance(f, dict):
+                        continue
+                    status_code = f.get("status", "  ")
+                    path = f.get("path", "")
+                    icon, label, style = _parse_file_status(status_code)
+                    file_line = Text()
+                    file_line.append("    ")
+                    file_line.append(icon, style=f"bold {style}")
+                    file_line.append(f" {path}", style=style)
+                    parts.append(file_line)
+
+            parts.append(Text(""))  # spacer
+
+        return RichGroup(*parts)

package/pennyfarthing_scripts/bikerack/launcher.py

@@ -24,8 +24,8 @@ def is_process_alive(pid: int) -> bool:
 
 
 def cleanup_files(project_dir: Path) -> None:
-    """Clean up .bikerack-port, .bikerack-pid, and .bikerack-tui-pid files."""
-    for name in (".bikerack-port", ".bikerack-pid", ".bikerack-tui-pid"):
+    """Clean up .wheelhub-port, .wheelhub-pid, and .wheelhub-gui-pid files."""
+    for name in (".wheelhub-port", ".wheelhub-pid", ".wheelhub-gui-pid"):
         try:
             (project_dir / name).unlink()
         except FileNotFoundError:
@@ -33,24 +33,24 @@ def cleanup_files(project_dir: Path) -> None:
 
 
 def read_port_file(project_dir: Path) -> int | None:
-    """Read port from .bikerack-port file. Returns None if not found."""
+    """Read port from .wheelhub-port file. Returns None if not found."""
     try:
-        return int((project_dir / ".bikerack-port").read_text().strip())
+        return int((project_dir / ".wheelhub-port").read_text().strip())
     except (FileNotFoundError, ValueError):
         return None
 
 
 def read_pid_file(project_dir: Path) -> int | None:
-    """Read PID from .bikerack-pid file. Returns None if not found."""
+    """Read PID from .wheelhub-pid file. Returns None if not found."""
     try:
-        return int((project_dir / ".bikerack-pid").read_text().strip())
+        return int((project_dir / ".wheelhub-pid").read_text().strip())
     except (FileNotFoundError, ValueError):
         return None
 
 
 def write_pid_file(project_dir: Path, pid: int) -> None:
-    """Write .bikerack-pid file."""
-    (project_dir / ".bikerack-pid").write_text(str(pid))
+    """Write .wheelhub-pid file."""
+    (project_dir / ".wheelhub-pid").write_text(str(pid))
 
 
 def build_otel_env(port: int) -> dict[str, str]:
@@ -104,8 +104,8 @@ def start_wheelhub(project_dir: Path) -> subprocess.Popen:
 def poll_for_port_file(
     project_dir: Path, timeout: float = 5.0, interval: float = 0.1
 ) -> int:
-    """Poll for .bikerack-port file, return port number."""
-    port_file = project_dir / ".bikerack-port"
+    """Poll for .wheelhub-port file, return port number."""
+    port_file = project_dir / ".wheelhub-port"
     deadline = time.monotonic() + timeout
 
     while True:
@@ -209,23 +209,23 @@ def get_status(project_dir: Path) -> dict:
 
 
 def read_tui_pid_file(project_dir: Path) -> int | None:
-    """Read TUI PID from .bikerack-tui-pid file. Returns None if not found."""
+    """Read TUI PID from .wheelhub-gui-pid file. Returns None if not found."""
     try:
-        return int((project_dir / ".bikerack-tui-pid").read_text().strip())
+        return int((project_dir / ".wheelhub-gui-pid").read_text().strip())
     except (FileNotFoundError, ValueError):
         return None
 
 
 def write_tui_pid_file(project_dir: Path, pid: int) -> None:
-    """Write .bikerack-tui-pid file."""
-    (project_dir / ".bikerack-tui-pid").write_text(str(pid))
+    """Write .wheelhub-gui-pid file."""
+    (project_dir / ".wheelhub-gui-pid").write_text(str(pid))
 
 
 def start_tui(project_dir: Path, port: int) -> subprocess.Popen:
     """Start TUI as independent subprocess.
 
     Uses start_new_session=True so TUI survives parent exit.
-    Writes .bikerack-tui-pid for lifecycle tracking.
+    Writes .wheelhub-gui-pid for lifecycle tracking.
     """
     import sys
 

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