@pennyfarthing/core 11.1.0 → 11.2.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
 

package/pennyfarthing_scripts/bikerack/progress_panel.py

@@ -0,0 +1,315 @@
+"""ProgressPanel — Unified story progress view for BikeRack TUI.
+
+Combines story context, workflow phase, acceptance criteria, todos, and
+git status into a single at-a-glance panel. Subscribes to 4 WS channels:
+/ws/story, /ws/todos, /ws/git, /ws/sprint.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from rich.console import Group
+from rich.text import Text
+
+from pennyfarthing_scripts.bikerack.base_panel import (
+    PANEL_ICONS,
+    BasePanel,
+    render_progress_bar,
+)
+
+
+class ProgressPanel(BasePanel):
+    """Unified story progress panel.
+
+    Subscribes to ``story``, ``todos``, ``git``, and ``sprint`` channels.
+    Renders a compact overview combining story header, workflow phase,
+    AC progress, todo progress, and git summary.
+    """
+
+    channel: str = "story"  # primary channel
+    panel_name: str = "Progress"
+    icon: str = PANEL_ICONS.get("progress", ("\uf200", "P"))[0]
+
+    def __init__(self, client: Any = None, **kwargs: Any) -> None:
+        super().__init__(client=client, **kwargs)
+        self._story_data: dict[str, Any] | None = None
+        self._todos_data: dict[str, Any] | None = None
+        self._git_data: dict[str, Any] | None = None
+        self._sprint_data: dict[str, Any] | None = None
+
+    def on_mount(self) -> None:
+        """Subscribe to all 4 channels."""
+        self._mounted = True
+        if self._client is not None:
+            self._client.subscribe("story", self._handle_story)
+            self._client.subscribe("todos", self._handle_todos)
+            self._client.subscribe("git", self._handle_git)
+            self._client.subscribe("sprint", self._handle_sprint)
+
+    def _handle_story(self, message: dict[str, Any] | None) -> None:
+        if message is None:
+            return
+        self._story_data = message
+        self._rerender()
+
+    def _handle_todos(self, message: dict[str, Any] | None) -> None:
+        if message is None:
+            return
+        self._todos_data = message
+        self._rerender()
+
+    def _handle_git(self, message: dict[str, Any] | None) -> None:
+        if message is None:
+            return
+        self._git_data = message
+        self._rerender()
+
+    def _handle_sprint(self, message: dict[str, Any] | None) -> None:
+        if message is None:
+            return
+        self._sprint_data = message
+        self._rerender()
+
+    def _rerender(self) -> None:
+        """Re-render with latest data from all channels."""
+        rendered = self.render_panel({})
+        try:
+            self.update(rendered)
+        except Exception:
+            pass
+
+    def render_panel(self, payload: dict[str, Any]) -> Any:
+        """Render unified progress view."""
+        parts: list[Any] = []
+
+        # --- Story Header ---
+        story_header = self._render_story_header()
+        if story_header is None:
+            return Text(
+                "No active story \u2014 start with /sprint work",
+                style="dim italic",
+            )
+        parts.append(story_header)
+        parts.append(Text("\u2500" * 35, style="dim"))
+
+        # --- Workflow Phase ---
+        workflow = self._render_workflow()
+        if workflow is not None:
+            parts.append(workflow)
+            parts.append(Text("\u2500" * 35, style="dim"))
+
+        # --- Acceptance Criteria ---
+        ac = self._render_ac()
+        if ac is not None:
+            parts.append(ac)
+            parts.append(Text("\u2500" * 35, style="dim"))
+
+        # --- Todos ---
+        todos = self._render_todos()
+        if todos is not None:
+            parts.append(todos)
+            parts.append(Text("\u2500" * 35, style="dim"))
+
+        # --- Git Summary ---
+        git = self._render_git()
+        if git is not None:
+            parts.append(git)
+
+        return Group(*parts)
+
+    def _render_story_header(self) -> Text | None:
+        """Render story ID, title, points, epic, assignee."""
+        story = self._story_data or {}
+        sprint = self._sprint_data or {}
+
+        # Try sprint data for current story context
+        current = sprint.get("sprint", {}).get("currentStory")
+        if isinstance(current, str) and current:
+            story_id = current
+        else:
+            story_id = story.get("id", "")
+
+        title = story.get("title", "")
+        points = story.get("points", "")
+        epic = story.get("epic", "")
+        assignee = story.get("assignee", "")
+
+        # Also try to extract from sprint epics
+        if not title and sprint:
+            for ep in sprint.get("epics", []):
+                for s in ep.get("stories", []):
+                    if s.get("id") == story_id:
+                        title = s.get("title", "")
+                        points = s.get("points", "")
+                        epic = ep.get("id", "")
+                        break
+
+        if not story_id and not title:
+            return None
+
+        header = Text()
+        if story_id:
+            header.append(story_id, style="bold cyan")
+            header.append("  ")
+        if title:
+            header.append(title, style="bold")
+        if points:
+            header.append(f"  {points}pt", style="dim")
+
+        # Second line: epic + assignee
+        meta_parts: list[str] = []
+        if epic:
+            meta_parts.append(f"Epic {epic}")
+        if assignee:
+            meta_parts.append(assignee)
+        if meta_parts:
+            header.append("\n")
+            header.append(" \u00b7 ".join(meta_parts), style="dim")
+
+        return header
+
+    def _render_workflow(self) -> Text | None:
+        """Render workflow type badge and phase dots."""
+        story = self._story_data or {}
+        workflow = story.get("workflow", "")
+        phases = story.get("workflowPhases", [])
+        current_phase = story.get("phase", "")
+
+        if not phases:
+            return None
+
+        line = Text()
+
+        # Workflow type badge
+        if workflow:
+            line.append(f"[{workflow}]", style="bold")
+            line.append("  ")
+
+        # Phase dots
+        for i, phase in enumerate(phases):
+            phase_name = phase if isinstance(phase, str) else phase.get("name", "")
+            phase_status = ""
+            if isinstance(phase, dict):
+                phase_status = phase.get("status", "")
+
+            # Determine phase state
+            if phase_status == "done" or (current_phase and phase_name != current_phase and _phase_before(phase_name, current_phase, phases)):
+                line.append("\u2713", style="green")
+            elif phase_name == current_phase:
+                line.append("\u25cf", style="bold yellow")
+            else:
+                line.append("\u25cb", style="dim")
+
+            line.append(f" {phase_name}", style="bold" if phase_name == current_phase else "dim")
+
+            if i < len(phases) - 1:
+                line.append(" \u2192 ", style="dim")
+
+        return line
+
+    def _render_ac(self) -> Text | None:
+        """Render acceptance criteria progress bar."""
+        story = self._story_data or {}
+        criteria = story.get("criteria", [])
+        if not criteria:
+            return None
+
+        total = len(criteria)
+        done = sum(1 for c in criteria if isinstance(c, dict) and c.get("met"))
+
+        if total == 0:
+            return None
+
+        pct = int(done / total * 100)
+        line = Text()
+        line.append("AC   ", style="bold")
+        line.append_text(render_progress_bar(pct, width=10))
+        line.append(f"  {done}/{total}")
+        return line
+
+    def _render_todos(self) -> Text | None:
+        """Render todo progress bar with active task."""
+        data = self._todos_data or {}
+        todos = data.get("todos", [])
+        if not todos:
+            return None
+
+        total = len(todos)
+        done = sum(1 for t in todos if isinstance(t, dict) and t.get("status") == "done")
+        active = None
+        for t in todos:
+            if isinstance(t, dict) and t.get("status") in ("in-progress", "active", "running"):
+                active = t.get("description", t.get("title", ""))
+                break
+
+        if total == 0:
+            return None
+
+        pct = int(done / total * 100)
+        line = Text()
+        line.append("Todo ", style="bold")
+        line.append_text(render_progress_bar(pct, width=10))
+        line.append(f"  {done}/{total}")
+        if active:
+            line.append(f"  \u25cf {active}", style="yellow")
+        return line
+
+    def _render_git(self) -> Text | None:
+        """Render git summary: branch, dirty counts, ahead/behind."""
+        data = self._git_data or {}
+        repos = data.get("repos", [])
+        if not repos:
+            return None
+
+        line = Text()
+        line.append("Git  ", style="bold")
+
+        repo_parts: list[str] = []
+        for repo in repos:
+            if not isinstance(repo, dict):
+                continue
+            branch = repo.get("branch", "")
+            dirty_files = repo.get("dirtyFiles", [])
+            ahead = repo.get("ahead", 0)
+            behind = repo.get("behind", 0)
+
+            # Count file types
+            modified = 0
+            untracked = 0
+            for f in dirty_files:
+                if not isinstance(f, dict):
+                    continue
+                status = f.get("status", "  ")
+                if status.startswith("?"):
+                    untracked += 1
+                else:
+                    modified += 1
+
+            part = Text()
+            if branch:
+                part.append(branch, style="cyan")
+            part.append(f"  {modified}M", style="yellow" if modified else "dim")
+            part.append(f" {untracked}U", style="dim")
+            part.append(f"  \u2191{ahead}", style="green" if ahead else "dim")
+            part.append(f" \u2193{behind}", style="red" if behind else "dim")
+
+            line.append_text(part)
+
+            # Only show first repo on main line, rest on separate lines
+            break
+
+        return line
+
+
+def _phase_before(phase: str, current: str, phases: list) -> bool:
+    """Check if phase comes before current in the phases list."""
+    phase_idx = -1
+    current_idx = -1
+    for i, p in enumerate(phases):
+        name = p if isinstance(p, str) else p.get("name", "")
+        if name == phase:
+            phase_idx = i
+        if name == current:
+            current_idx = i
+    return phase_idx >= 0 and current_idx >= 0 and phase_idx < current_idx