@pennyfarthing/core 11.1.0 → 11.2.0

package/pennyfarthing_scripts/bc/cli.py

@@ -34,8 +34,8 @@ from pennyfarthing_scripts.bc.focus import (
 def _get_current_layout() -> dict | None:
     """Fetch the current layout from a running Cyclist or BikeRack server.
 
-    Checks .bikerack-port first, then .cyclist-port, and fetches the
-    appropriate layout endpoint.
+    Reads .wheelhub-port (shared by both Cyclist and BikeRack) and fetches
+    the layout endpoint.
 
     Returns:
         Layout dict, or None if no server is running or fetch fails.
@@ -44,10 +44,8 @@ def _get_current_layout() -> dict | None:
 
     root = _get_root()
 
-    # Try BikeRack first (bikerack-layout), then Cyclist (layout)
     candidates = [
-        (root / ".bikerack-port", "/api/settings/bikerack-layout"),
-        (root / ".cyclist-port", "/api/settings/bikerack-layout"),
+        (root / ".wheelhub-port", "/api/settings/bikerack-layout"),
     ]
 
     for port_file, endpoint in candidates:

package/pennyfarthing_scripts/bikerack/background_panel.py

@@ -6,12 +6,13 @@ list with status indicators (running, completed, failed).
 
 from __future__ import annotations
 
+import time
 from typing import Any
 
 from rich.console import Group
 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, format_duration
 
 
 class BackgroundPanel(BasePanel):
@@ -25,12 +26,62 @@ class BackgroundPanel(BasePanel):
     panel_name: str = "Background"
     icon: str = PANEL_ICONS["background"][0]
 
+    def __init__(self, client=None, **kwargs):
+        super().__init__(client=client, **kwargs)
+        self._timer = None
+
+    def on_mount(self) -> None:
+        """Subscribe to channel and start elapsed timer."""
+        super().on_mount()
+        self._timer = self.set_interval(1, self._tick)
+
+    def on_unmount(self) -> None:
+        """Stop timer and cleanup."""
+        if self._timer is not None:
+            self._timer.stop()
+        super().on_unmount()
+
+    def _tick(self) -> None:
+        """Re-render every second to update elapsed times."""
+        if self._last_payload is not None:
+            rendered = self.render_panel(self._last_payload)
+            try:
+                self.update(rendered)
+            except Exception:
+                pass
+
     def render_panel(self, payload: dict[str, Any]) -> Any:
         """Render background task data from WebSocket payload."""
         tasks = payload.get("tasks", [])
         if not isinstance(tasks, list) or not tasks:
             return Text("No background tasks", style="dim italic")
 
+        running = 0
+        done = 0
+        failed = 0
+        for task in tasks:
+            if not isinstance(task, dict):
+                continue
+            if task.get("completedAt") is not None:
+                if task.get("success"):
+                    done += 1
+                else:
+                    failed += 1
+            else:
+                running += 1
+
+        # Summary header
+        summary = Text()
+        summary.append(f"{running} running", style="yellow")
+        summary.append("  ")
+        summary.append(f"{done} done", style="green")
+        if failed > 0:
+            summary.append("  ")
+            summary.append(f"{failed} failed", style="red")
+
+        separator = Text("─" * 30, style="dim")
+
+        # Task list
         parts: list[Any] = []
         for task in tasks:
             if not isinstance(task, dict):
@@ -40,7 +91,7 @@ class BackgroundPanel(BasePanel):
         if not parts:
             return Text("No background tasks", style="dim italic")
 
-        return Group(*parts)
+        return Group(summary, separator, *parts)
 
 
 def _render_task(task: dict[str, Any]) -> Text:
@@ -48,6 +99,7 @@ def _render_task(task: dict[str, Any]) -> Text:
     description = task.get("description", "Unknown task")
     subagent_type = task.get("subagentType", "")
     completed_at = task.get("completedAt")
+    started_at = task.get("startedAt")
     success = task.get("success")
     result = task.get("result", "")
     error = task.get("error", "")
@@ -60,7 +112,12 @@ def _render_task(task: dict[str, Any]) -> Text:
             line.append(description)
             if subagent_type:
                 line.append(f" [{subagent_type}]", style="dim")
-            line.append(" — done", style="green")
+            # Show duration if timestamps available
+            duration = _calc_duration(started_at, completed_at)
+            if duration:
+                line.append(f" — {duration}", style="green")
+            else:
+                line.append(" — done", style="green")
             if result:
                 line.append(f" ({result})", style="dim green")
         else:
@@ -68,7 +125,11 @@ def _render_task(task: dict[str, Any]) -> Text:
             line.append(description)
             if subagent_type:
                 line.append(f" [{subagent_type}]", style="dim")
-            line.append(" — failed", style="red")
+            duration = _calc_duration(started_at, completed_at)
+            if duration:
+                line.append(f" — {duration}", style="red")
+            else:
+                line.append(" — failed", style="red")
             if error:
                 line.append(f"\n  {error}", style="red")
     else:
@@ -76,6 +137,26 @@ def _render_task(task: dict[str, Any]) -> Text:
         line.append(description)
         if subagent_type:
             line.append(f" [{subagent_type}]", style="dim")
-        line.append(" — running", style="yellow")
+        # Live elapsed time for running tasks
+        if started_at:
+            try:
+                elapsed = time.time() - float(started_at) / 1000  # startedAt is typically ms
+                line.append(f" — {format_duration(elapsed)}", style="yellow")
+            except (ValueError, TypeError):
+                line.append(" — running", style="yellow")
+        else:
+            line.append(" — running", style="yellow")
 
     return line
+
+
+def _calc_duration(started_at, completed_at) -> str:
+    """Calculate duration string from timestamps."""
+    if started_at is None or completed_at is None:
+        return ""
+    try:
+        start = float(started_at) / 1000  # ms to seconds
+        end = float(completed_at) / 1000
+        return format_duration(end - start)
+    except (ValueError, TypeError):
+        return ""

package/pennyfarthing_scripts/bikerack/base_panel.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 
 from typing import Any
 
+from rich.text import Text
 from textual.widgets import Static
 
 # Nerd Font icon registry: panel_name → (nerd_font_icon, ascii_fallback)
@@ -25,6 +26,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 +46,66 @@ 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) -> 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).
+
+    Returns:
+        Rich Text like ``[████████░░░░░░░░░░░░] 22%``
+    """
+    percent = max(0, min(100, int(percent)))
+    filled = round(width * percent / 100)
+    empty = width - filled
+
+    if 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.
 

package/pennyfarthing_scripts/bikerack/changed_panel.py

@@ -8,7 +8,6 @@ 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
@@ -64,42 +63,47 @@ class ChangedPanel(BasePanel):
     icon: str = PANEL_ICONS["changed"][0]
 
     def render_panel(self, payload: dict[str, Any]) -> Any:
-        """Render changed file data from WebSocket payload."""
+        """Render changed files grouped by repository."""
         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] = []
+        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)
+                line = Text()
+                line.append("  ")
+                line.append(icon, style=f"bold {style}")
+                line.append(f" {path}", style="cyan")
+                line.append(f"  {label_text}", style=style)
+                parts.append(line)
+
+            parts.append(Text(""))  # spacer between repos
+
+        return RichGroup(*parts)

package/pennyfarthing_scripts/bikerack/cli.py

@@ -64,12 +64,12 @@ def start(project_dir, dry_run):
 
     running, pid, port = is_already_running(project_dir)
     if running:
-        click.echo(
-            f"Error: BikeRack is already running (PID {pid}, port {port})",
-            err=True,
-        )
-        click.echo("Use 'pf bikerack stop' to stop it.", err=True)
-        sys.exit(2)
+        # Idempotent: WheelHub already up, just exec Claude with OTEL env
+        click.echo(f"BikeRack already running (PID {pid}, port {port})")
+        otel_env = build_otel_env(port)
+        click.echo(f"Dashboard: http://localhost:{port}/bikerack")
+        click.echo("Starting Claude CLI...")
+        exec_claude(otel_env, project_dir)
 
     click.echo("Starting BikeRack mode...")
     try:
@@ -116,11 +116,10 @@ def stop(project_dir, dry_run):
 
     result = stop_bikerack(project_dir)
 
-    if result["success"]:
-        click.echo(result["message"])
-    else:
-        click.echo(result["message"], err=True)
-        sys.exit(1)
+    click.echo(result["message"])
+    if not result["success"]:
+        # "Not running" is not an error for stop — idempotent
+        sys.exit(0)
 
 
 @bikerack.command()

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()
@@ -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

@@ -52,6 +52,8 @@ class DiffsPanel(BasePanel):
         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 +65,34 @@ 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 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 +103,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