@pennyfarthing/core 11.1.1 → 11.2.0

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/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
 

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