@pennyfarthing/core 11.2.0 → 11.2.2

package/pennyfarthing_scripts/bikerack/sprint_panel.py

@@ -1,204 +1,435 @@
 """SprintPanel — Sprint status panel for BikeRack TUI.
 
 Story 103-6: First panel implementation proving the BasePanel vertical slice.
-Subscribes to /ws/sprint, renders sprint status as Rich table.
+Story 110-2: Added per-story cursor navigation and drill-through.
+Migrated to Textual Tree widget for native hierarchy navigation.
+Subscribes to /ws/sprint, renders sprint status with epic/story tree.
 """
 
 from __future__ import annotations
 
 from typing import Any
 
-from rich.console import Group
-from rich.padding import Padding
 from rich.text import Text
+from textual.app import ComposeResult
+from textual.message import Message
+from textual.widget import Widget
+from textual.widgets import Static, Tree
 
-from pennyfarthing_scripts.bikerack.base_panel import PANEL_ICONS, BasePanel, render_progress_bar
+from pennyfarthing_scripts.bikerack.base_panel import PANEL_ICONS, render_progress_bar
+
+
+def _normalize_status(status: str) -> str:
+    """Normalize status string: lowercase, strip, hyphens for separators."""
+    s = status.lower().strip().replace("_", "-") if status else ""
+    # Normalize both British and American spelling
+    if s == "cancelled":
+        s = "canceled"
+    return s
+
+
+def _is_terminal(status: str) -> bool:
+    """Return True if the normalized status is done or canceled."""
+    return _normalize_status(status) in {"done", "canceled"}
 
 
 def _status_badge(status: str) -> Text:
-    """Convert status string to styled Rich Text badge."""
-    s = status.lower().strip() if status else ""
+    """Convert status string to styled Rich Text badge (symbol only, no text)."""
+    s = _normalize_status(status)
     if s == "done":
-        return Text("\u2713 done", style="green")
+        return Text("\u2713", style="dim green")
+    if s == "canceled":
+        return Text("\u2715", style="dim")
     if s == "in-progress":
-        return Text("\u27f3 in-progress", style="yellow")
+        return Text("\u27f3", style="bold yellow")
     if s == "backlog":
-        return Text("\u25ef backlog", style="dim")
+        return Text("\u25ef", style="dim")
     if s == "blocked":
-        return Text("! blocked", style="bold red")
+        return Text("!", style="bold red")
     if s == "review":
-        return Text("\u25ce review", style="cyan")
-    return Text(status or "\u2014", style="dim")
+        return Text("\u25ce", style="cyan")
+    return Text("\u2014", style="dim")
+
+
+def _format_assignee(email: str | None) -> str:
+    """Format an email address into a short display name.
+
+    ``"keith.avery@1898andco.io"`` → ``"K. Avery"``
+    ``None`` → ``""``
+    """
+    if not email:
+        return ""
+    local = email.split("@")[0]
+    parts = local.replace("_", ".").split(".")
+    if len(parts) < 2:
+        return parts[0].capitalize()
+    first_initial = parts[0][0].upper() if parts[0] else ""
+    last = parts[-1].capitalize()
+    return f"{first_initial}. {last}"
+
+
+def _should_expand(epic: dict[str, Any]) -> bool:
+    """Check if an epic should be expanded by default (has incomplete work).
+
+    Epics that are canceled, or whose stories are all done/canceled, collapse.
+    """
+    if _is_terminal(epic.get("status", "")):
+        return False
+    stories = epic.get("stories", [])
+    total_pts = 0
+    done_pts = 0
+    has_in_progress = False
+    for story in stories:
+        pts = story.get("points", 0)
+        if isinstance(pts, (int, float)):
+            total_pts += pts
+            if _is_terminal(story.get("status", "")):
+                done_pts += pts
+            if _normalize_status(story.get("status", "")) == "in-progress":
+                has_in_progress = True
+    return has_in_progress or done_pts < total_pts
+
+
+_EPIC_ID_WIDTH = 11  # "MSSCI-NNNNN" = 11 chars
+
+
+def _build_epic_label(
+    epic_id: str, title: str, done_pts: int, total_pts: int, jira_key: str = ""
+) -> Text:
+    """Build Rich Text label for an epic tree node."""
+    label = Text(no_wrap=True, overflow="ellipsis")
+    display_id = jira_key if jira_key else epic_id
+    if len(display_id) > _EPIC_ID_WIDTH:
+        display_id = display_id[: _EPIC_ID_WIDTH - 1] + "\u2026"
+    display_id = f"{display_id:<{_EPIC_ID_WIDTH}}"
+    label.append(display_id, style="bold cyan")
+    label.append("  ")
+    if total_pts > 0:
+        pct = int(done_pts / total_pts * 100)
+        label.append_text(render_progress_bar(pct, width=10, fill_style="dim green"))
+        label.append(f" {done_pts}/{total_pts} pts", style="dim")
+    else:
+        label.append("0 pts", style="dim")
+    label.append(f"  {title}", style="bold")
+    return label
+
+
+def _build_story_label(story: dict[str, Any], current_story_id: str) -> Text:
+    """Build Rich Text label for a story tree leaf.
+
+    Layout: ``✓  MSSCI-14952   2  Story title``
+    In-progress adds owner: ``⟳  MSSCI-15186   5  Story title  [K. Avery]``
+    Done stories are rendered entirely dim.
+    """
+    story_id = story.get("id", "")
+    title = story.get("title", "")
+    pts = story.get("points", "")
+    jira = story.get("jiraKey") or "\u2014"
+    status = _normalize_status(story.get("status", ""))
+    badge = _status_badge(story.get("status", ""))
+
+    is_done = _is_terminal(story.get("status", ""))
+    is_in_progress = status == "in-progress"
+    is_current = story_id == current_story_id
+
+    label = Text(no_wrap=True, overflow="ellipsis")
+    label.append_text(badge)
+
+    # MSSCI key flush left, fixed-width (14 chars — fits "MSSCI-NNNNN" + padding)
+    jira_padded = f"{jira:<14}"
+    label.append(f"  {jira_padded}", style="dim" if is_done else ("bold cyan" if is_current else "cyan"))
 
+    # Points right-aligned (2 chars)
+    pts_str = f"{pts:>2}" if isinstance(pts, int) else f"{pts!s:>2}"
+    label.append(f"  {pts_str}", style="dim")
 
-class SprintPanel(BasePanel):
-    """Sprint status panel.
+    # Title
+    label.append(f"  {title}", style="dim" if is_done else "")
+
+    # Owner for in-progress stories
+    if is_in_progress:
+        owner = _format_assignee(story.get("assignee"))
+        if owner:
+            label.append(f"  [{owner}]", style="dim yellow")
+
+    if is_current:
+        label.stylize("bold")
+
+    if is_done:
+        label.stylize("dim")
+
+    return label
+
+
+class SprintPanel(Widget):
+    """Sprint panel using native Textual Tree widget.
 
     Subscribes to the ``sprint`` WebSocket channel and renders
-    sprint status as a Rich table with story list, points, and velocity.
+    sprint status as a Tree with epic/story hierarchy.
+    """
+
+    DEFAULT_CSS = """
+    SprintPanel {
+        height: 1fr;
+        layout: vertical;
+    }
+    #sprint-header {
+        height: auto;
+        max-height: 3;
+        padding: 0 1;
+    }
+    #sprint-hints {
+        height: 1;
+        padding: 0 1;
+    }
+    #sprint-tree {
+        height: 1fr;
+    }
     """
 
     channel: str = "sprint"
     panel_name: str = "Sprint"
     icon: str = PANEL_ICONS["sprint"][0]
+    can_focus = True
 
-    def __init__(self, client: Any = None, **kwargs: Any) -> None:
-        super().__init__(client=client, **kwargs)
-        self._selected_epic: int = 0
-        self._toggled: dict[str, bool] = {}  # epic_id -> user override
+    class DataReceived(Message, bubble=False):
+        """WebSocket data received — triggers tree rebuild."""
 
-    def next_epic(self) -> None:
-        """Move selection to the next epic."""
-        epic_count = self._epic_count()
-        if epic_count == 0:
-            return
-        self._selected_epic = (self._selected_epic + 1) % epic_count
-        self._rerender()
+        def __init__(self, payload: dict[str, Any]) -> None:
+            super().__init__()
+            self.payload = payload
 
-    def prev_epic(self) -> None:
-        """Move selection to the previous epic."""
-        epic_count = self._epic_count()
-        if epic_count == 0:
-            return
-        self._selected_epic = (self._selected_epic - 1) % epic_count
-        self._rerender()
-
-    def toggle_epic(self) -> None:
-        """Toggle expand/collapse on the selected epic."""
-        if self._last_payload is None:
+    def __init__(self, client: Any = None, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self._client = client
+        self._last_payload: dict[str, Any] | None = None
+        self._mounted = False
+
+    def compose(self) -> ComposeResult:
+        yield Static(
+            "[dim]Waiting for sprint data...[/dim]", id="sprint-header"
+        )
+        yield Static(
+            "[dim]\u2191/\u2193:navigate  space:expand/collapse  Enter:open  j/k/e:vim nav[/dim]",
+            id="sprint-hints",
+        )
+        tree: Tree[dict[str, Any]] = Tree("Sprint", id="sprint-tree")
+        tree.show_root = False
+        tree.guide_depth = 3
+        yield tree
+
+    def on_mount(self) -> None:
+        """Subscribe to sprint channel via WS client."""
+        self._mounted = True
+        if self._client is not None and self.channel:
+            self._client.subscribe(self.channel, self._handle_ws_message)
+
+    def on_unmount(self) -> None:
+        """Mark unmounted so WS callbacks are ignored."""
+        self._mounted = False
+
+    def focus(self, scroll_visible: bool = True) -> SprintPanel:
+        """Delegate focus to the tree widget."""
+        try:
+            tree = self.query_one("#sprint-tree", Tree)
+            tree.focus(scroll_visible)
+        except Exception:
+            super().focus(scroll_visible)
+        return self
+
+    # --- WebSocket message handling ---
+
+    def _handle_ws_message(self, message: dict[str, Any] | None) -> None:
+        """Handle incoming WebSocket message (called from async WS task)."""
+        if not self._mounted or message is None:
             return
-        epics = self._last_payload.get("epics", [])
-        if not epics or self._selected_epic >= len(epics):
+        self._last_payload = message
+        try:
+            self.post_message(self.DataReceived(message))
+        except Exception:
+            pass
+
+    def on_sprint_panel_data_received(self, event: DataReceived) -> None:
+        """Process data in Textual message context — rebuilds tree."""
+        self._rebuild_tree(event.payload)
+
+    # --- Tree rebuild ---
+
+    def _rebuild_tree(self, payload: dict[str, Any]) -> None:
+        """Rebuild tree nodes from sprint payload, preserving expand/cursor state."""
+        try:
+            tree = self.query_one("#sprint-tree", Tree)
+        except Exception:
             return
-        epic_id = epics[self._selected_epic].get("id", "")
-        if epic_id:
-            self._toggled[epic_id] = not self._is_expanded(epics[self._selected_epic])
-        self._rerender()
-
-    def _rerender(self) -> None:
-        if self._last_payload is not None:
-            rendered = self.render_panel(self._last_payload)
-            try:
-                self.update(rendered)
-            except Exception:
-                pass
 
-    def _epic_count(self) -> int:
-        if self._last_payload is None:
-            return 0
-        return len(self._last_payload.get("epics", []))
-
-    def _is_expanded(self, epic: dict[str, Any]) -> bool:
-        """Check if an epic should be expanded."""
-        epic_id = epic.get("id", "")
-        if epic_id in self._toggled:
-            return self._toggled[epic_id]
-        # Default: expand if has incomplete work
-        stories = epic.get("stories", [])
-        total_pts = 0
-        done_pts = 0
-        has_in_progress = False
-        for story in stories:
-            pts = story.get("points", 0)
-            if isinstance(pts, (int, float)):
-                total_pts += pts
-                status = (story.get("status") or "").lower().strip()
-                if status == "done":
-                    done_pts += pts
-                if status == "in-progress":
-                    has_in_progress = True
-        return has_in_progress or done_pts < total_pts
-
-    def render_panel(self, payload: dict[str, Any]) -> Any:
-        """Render sprint data with epic grouping and progress bars."""
         sprint = payload.get("sprint", {})
         metrics = payload.get("metrics", {})
         epics = payload.get("epics", [])
         current_story_id = sprint.get("currentStory", "")
 
-        # Clamp selection
-        if epics and self._selected_epic >= len(epics):
-            self._selected_epic = len(epics) - 1
-
-        # Sprint metrics header
+        # Update header
         sprint_num = sprint.get("number", "")
         done = sprint.get("done", 0)
         remaining = sprint.get("remaining", 0)
         in_progress = sprint.get("inProgress", 0)
         velocity = metrics.get("velocity", 0)
-
-        header = Text.from_markup(
+        header_text = Text.from_markup(
             f"Sprint {sprint_num}  "
             f"[green]Done: {done}[/green] | "
             f"Remaining: {remaining} | "
             f"In Progress: {in_progress} | "
             f"Velocity: {velocity}"
         )
-
-        hint = Text.from_markup("[dim]j/k:navigate  e:expand/collapse[/dim]")
-        parts: list[Any] = [header, hint, Text("")]
-
-        for i, epic in enumerate(epics):
+        try:
+            self.query_one("#sprint-header", Static).update(header_text)
+        except Exception:
+            pass
+
+        # Save expand state from current tree nodes
+        saved_expanded: dict[str, bool] = {}
+        for node in tree.root.children:
+            data = node.data
+            if data and data.get("type") == "epic":
+                saved_expanded[data["id"]] = node.is_expanded
+
+        # Save cursor position by node identity
+        cursor_node_key: str | None = None
+        try:
+            highlighted = tree.get_node_at_line(tree.cursor_line)
+            if highlighted and highlighted.data:
+                data = highlighted.data
+                if data.get("type") == "epic":
+                    cursor_node_key = f"epic:{data['id']}"
+                elif data.get("type") == "story":
+                    cursor_node_key = f"story:{data['story'].get('id', '')}"
+        except Exception:
+            pass
+
+        # Rebuild tree
+        tree.clear()
+        cursor_target = None
+
+        for epic in epics:
             epic_id = epic.get("id", "")
             epic_title = epic.get("title", "")
             stories = epic.get("stories", [])
 
-            # Calculate epic progress
+            # Calculate epic progress (canceled counts as done)
             total_pts = 0
             done_pts = 0
             for story in stories:
                 pts = story.get("points", 0)
                 if isinstance(pts, (int, float)):
                     total_pts += pts
-                    status = (story.get("status") or "").lower().strip()
-                    if status == "done":
+                    if _is_terminal(story.get("status", "")):
                         done_pts += pts
 
-            expanded = self._is_expanded(epic)
-            selected = i == self._selected_epic
-
-            # Epic header: selector arrow epic-id progress-bar pts title
-            arrow = "▼" if expanded else "▶"
-            epic_line = Text(no_wrap=True, overflow="ellipsis")
-            if selected:
-                epic_line.append("› ", style="bold yellow")
-            epic_line.append(f"{arrow} ", style="bold")
-            epic_line.append(f"{epic_id}", style="bold cyan")
-            epic_line.append("  ")
-
-            if total_pts > 0:
-                pct = int(done_pts / total_pts * 100)
-                epic_line.append_text(render_progress_bar(pct, width=10))
-                epic_line.append(f" {done_pts}/{total_pts} pts", style="dim")
-            else:
-                epic_line.append("0 pts", style="dim")
-
-            epic_line.append(f"  {epic_title}", style="bold")
-
-            parts.append(epic_line)
-
-            # Show stories if expanded
-            if expanded:
-                for story in stories:
-                    story_id = story.get("id", "")
-                    title = story.get("title", "")
-                    pts = story.get("points", "")
-                    jira = story.get("jiraKey") or "—"
-                    badge = _status_badge(story.get("status", ""))
-
-                    # Fixed-width fields first, title last (truncates)
-                    story_line = Text(no_wrap=True, overflow="ellipsis")
-                    story_line.append_text(badge)
-                    story_line.append(f" {story_id}", style="cyan" if story_id != current_story_id else "bold cyan")
-                    story_line.append(f"  {jira}", style="dim")
-                    story_line.append(f"  {pts}", style="dim")
-                    story_line.append(f"  {title}")
-
-                    if story_id == current_story_id:
-                        story_line.stylize("bold")
-
-                    parts.append(Padding(story_line, (0, 0, 0, 4)))
-
-            parts.append(Text(""))  # spacer between epics
-
-        return Group(*parts)
+            label = _build_epic_label(
+                epic_id, epic_title, done_pts, total_pts,
+                jira_key=epic.get("jiraKey", ""),
+            )
+            epic_data: dict[str, Any] = {
+                "type": "epic",
+                "id": epic_id,
+                "title": epic_title,
+            }
+            epic_node = tree.root.add(label, data=epic_data)
+
+            # Add story leaves
+            for story in stories:
+                story_label = _build_story_label(story, current_story_id)
+                story_data: dict[str, Any] = {"type": "story", "story": story}
+                story_node = epic_node.add_leaf(story_label, data=story_data)
+
+                if cursor_node_key == f"story:{story.get('id', '')}":
+                    cursor_target = story_node
+
+            # Restore expand state or apply default
+            if epic_id in saved_expanded:
+                if saved_expanded[epic_id]:
+                    epic_node.expand()
+                else:
+                    epic_node.collapse()
+            elif _should_expand(epic):
+                epic_node.expand()
+
+            if cursor_node_key == f"epic:{epic_id}":
+                cursor_target = epic_node
+
+        # Restore cursor position
+        if cursor_target is not None:
+            try:
+                tree.move_cursor(cursor_target)
+            except Exception:
+                pass
+
+    # --- Tree event handling ---
+
+    def on_tree_node_selected(self, event: Tree.NodeSelected) -> None:
+        """Handle enter on a tree node: drill into story or toggle epic."""
+        data = event.node.data
+        if not data:
+            return
+        if data.get("type") == "story":
+            story = data["story"]
+            from pennyfarthing_scripts.bikerack.story_detail_screen import (
+                StoryDetailScreen,
+            )
+
+            try:
+                self.app.push_screen(StoryDetailScreen(story_data=story))
+            except Exception:
+                pass
+        elif data.get("type") == "epic":
+            event.node.toggle()
+
+    # --- Compatibility methods for app-level bindings ---
+
+    def next_epic(self) -> None:
+        """Move cursor down — compat wrapper for app j binding."""
+        try:
+            tree = self.query_one("#sprint-tree", Tree)
+            tree.action_cursor_down()
+        except Exception:
+            pass
+
+    def prev_epic(self) -> None:
+        """Move cursor up — compat wrapper for app k binding."""
+        try:
+            tree = self.query_one("#sprint-tree", Tree)
+            tree.action_cursor_up()
+        except Exception:
+            pass
+
+    def toggle_epic(self) -> None:
+        """Toggle current node — compat wrapper for app e binding."""
+        try:
+            tree = self.query_one("#sprint-tree", Tree)
+            tree.action_toggle_node()
+        except Exception:
+            pass
+
+    def get_selected_story(self) -> dict[str, Any] | None:
+        """Return the currently highlighted story data, or None."""
+        try:
+            tree = self.query_one("#sprint-tree", Tree)
+            node = tree.get_node_at_line(tree.cursor_line)
+            if node and node.data and node.data.get("type") == "story":
+                return node.data["story"]
+        except Exception:
+            pass
+        return None
+
+    def drill_into_story(self) -> None:
+        """Push StoryDetailScreen for the highlighted story."""
+        story = self.get_selected_story()
+        if story is None:
+            return
+        from pennyfarthing_scripts.bikerack.story_detail_screen import (
+            StoryDetailScreen,
+        )
+
+        try:
+            self.app.push_screen(StoryDetailScreen(story_data=story))
+        except Exception:
+            pass