@pennyfarthing/core 11.3.2 → 11.3.4

package/pennyfarthing-dist/pf/bikerack/sprint_panel.py

@@ -0,0 +1,435 @@
+"""SprintPanel — Sprint status panel for BikeRack TUI.
+
+Story 103-6: First panel implementation proving the BasePanel vertical slice.
+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.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 pf.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 (symbol only, no text)."""
+    s = _normalize_status(status)
+    if s == "done":
+        return Text("\u2713", style="dim green")
+    if s == "canceled":
+        return Text("\u2715", style="dim")
+    if s == "in-progress":
+        return Text("\u27f3", style="bold yellow")
+    if s == "backlog":
+        return Text("\u25ef", style="dim")
+    if s == "blocked":
+        return Text("!", style="bold red")
+    if s == "review":
+        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")
+
+    # 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 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
+
+    class DataReceived(Message, bubble=False):
+        """WebSocket data received — triggers tree rebuild."""
+
+        def __init__(self, payload: dict[str, Any]) -> None:
+            super().__init__()
+            self.payload = payload
+
+    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
+        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
+
+        sprint = payload.get("sprint", {})
+        metrics = payload.get("metrics", {})
+        epics = payload.get("epics", [])
+        current_story_id = sprint.get("currentStory", "")
+
+        # 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 = Text.from_markup(
+            f"Sprint {sprint_num}  "
+            f"[green]Done: {done}[/green] | "
+            f"Remaining: {remaining} | "
+            f"In Progress: {in_progress} | "
+            f"Velocity: {velocity}"
+        )
+        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 (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
+                    if _is_terminal(story.get("status", "")):
+                        done_pts += pts
+
+            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 pf.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 pf.bikerack.story_detail_screen import (
+            StoryDetailScreen,
+        )
+
+        try:
+            self.app.push_screen(StoryDetailScreen(story_data=story))
+        except Exception:
+            pass

package/pennyfarthing-dist/pf/bikerack/story_detail_data.py

@@ -0,0 +1,247 @@
+"""Story detail data fetching for BikeRack TUI.
+
+Story 110-2: Fetch story detail data (AC, session, workflow) via file read or API.
+Returns enriched story data for StoryDetailScreen dossier layout.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+from typing import Any
+
+
+def _find_project_root() -> str | None:
+    """Walk up from CWD looking for .pennyfarthing/ directory."""
+    path = os.getcwd()
+    while True:
+        if os.path.isdir(os.path.join(path, ".pennyfarthing")):
+            return path
+        parent = os.path.dirname(path)
+        if parent == path:
+            return None
+        path = parent
+
+
+def _find_session_file(story_id: str, project_root: str | None) -> str | None:
+    """Locate the session file for a story, trying given root then walking up."""
+    filename = f"{story_id}-session.md"
+    if project_root:
+        candidate = os.path.join(project_root, ".session", filename)
+        if os.path.isfile(candidate):
+            return candidate
+    # Walk up from CWD looking for .session/{story_id}-session.md
+    path = os.getcwd()
+    while True:
+        candidate = os.path.join(path, ".session", filename)
+        if os.path.isfile(candidate):
+            return candidate
+        parent = os.path.dirname(path)
+        if parent == path:
+            return None
+        path = parent
+
+
+def _parse_session_file(session_path: str) -> dict[str, Any]:
+    """Parse a session markdown file for metadata fields."""
+    result: dict[str, Any] = {}
+    with open(session_path) as f:
+        content = f.read()
+
+    # Parse title from first heading: # Story X-Y: Title
+    title_match = re.search(r"^# Story [\w-]+:\s*(.+)", content, re.MULTILINE)
+    if title_match:
+        result["title"] = title_match.group(1).strip()
+
+    # Parse bold metadata lines: **Key:** value
+    for match in re.finditer(r"\*\*(\w[\w\s]*?):\*\*\s*(.*)", content):
+        key = match.group(1).strip().lower()
+        value = match.group(2).strip()
+        if key == "phase":
+            result["workflow_phase"] = value
+        elif key == "workflow":
+            result["workflow"] = value
+        elif key == "branch":
+            result["git_branch"] = value
+        elif key == "jira":
+            result["jiraKey"] = value
+        elif key == "points":
+            try:
+                result["points"] = int(value)
+            except ValueError:
+                result["points"] = value
+        elif key == "review verdict":
+            result["review_verdict"] = value
+        elif key == "review findings":
+            result["review_findings"] = value
+
+    # Parse ACs from ## Acceptance Criteria section
+    ac_match = re.search(
+        r"## Acceptance Criteria\n(.*?)(?=\n##|\Z)", content, re.DOTALL
+    )
+    if ac_match:
+        ac_text = ac_match.group(1)
+        acs: list[dict[str, Any]] = []
+        for line in ac_text.strip().split("\n"):
+            line = line.strip()
+            if not line:
+                continue
+            # Strip leading number. or - or *
+            text = re.sub(r"^[\d]+\.\s*", "", line).strip()
+            text = re.sub(r"^[-*]\s*", "", text).strip()
+            if text:
+                acs.append({"text": text, "done": False})
+        if acs:
+            result["acceptance_criteria"] = acs
+
+    # Parse session notes from ## Session Log section
+    log_match = re.search(
+        r"## Session Log\n(.*?)(?=\n##|\Z)", content, re.DOTALL
+    )
+    if log_match:
+        result["session_notes"] = log_match.group(1).strip()
+
+    return result
+
+
+def _get_sprint_story_status(story_id: str) -> str | None:
+    """Try to get story status from pf sprint CLI."""
+    import sys
+
+    try:
+        out = subprocess.run(
+            [sys.executable, "-m", "pf.cli",
+             "sprint", "story", "field", story_id, "status"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        if out.returncode == 0 and out.stdout.strip():
+            return out.stdout.strip()
+    except Exception:
+        pass
+    return None
+
+
+def _get_pr_url(branch: str) -> str | None:
+    """Try to get PR URL for a branch via gh CLI."""
+    if not branch:
+        return None
+    try:
+        out = subprocess.run(
+            [
+                "gh",
+                "pr",
+                "list",
+                "--head",
+                branch,
+                "--json",
+                "url",
+                "--jq",
+                ".[0].url",
+            ],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+        if out.returncode == 0 and out.stdout.strip():
+            return out.stdout.strip()
+    except Exception:
+        pass
+    return None
+
+
+def _check_context_files(story_id: str, project_root: str | None) -> dict[str, Any]:
+    """Check for epic and story context files.
+
+    Args:
+        story_id: Story identifier (e.g. "110-2").
+        project_root: Path to project root.
+
+    Returns:
+        Dict with has_epic_context, has_story_context, and their paths.
+    """
+    result: dict[str, Any] = {
+        "has_epic_context": False,
+        "has_story_context": False,
+        "epic_context_path": "",
+        "story_context_path": "",
+    }
+    if not project_root:
+        return result
+
+    # Extract epic number from story ID (e.g. "110-2" → "110")
+    parts = story_id.split("-")
+    if parts:
+        epic_num = parts[0]
+        epic_path = os.path.join(project_root, "sprint", "context", f"context-epic-{epic_num}.md")
+        if os.path.isfile(epic_path):
+            result["has_epic_context"] = True
+            result["epic_context_path"] = epic_path
+
+    story_path = os.path.join(project_root, "sprint", "context", f"context-story-{story_id}.md")
+    if os.path.isfile(story_path):
+        result["has_story_context"] = True
+        result["story_context_path"] = story_path
+
+    return result
+
+
+def fetch_story_detail(
+    story_id: str,
+    project_root: str | None = None,
+) -> dict[str, Any]:
+    """Fetch detailed story data including ACs, session, workflow, and git info.
+
+    Args:
+        story_id: Story identifier (e.g. "110-2").
+        project_root: Path to project root (for file reads). Auto-detected if None.
+
+    Returns:
+        Dict with keys: id, title, points, status, jiraKey,
+        acceptance_criteria, workflow, workflow_phase,
+        git_branch, pr_url, session_notes.
+        Empty dict if story not found.
+    """
+    session_path = _find_session_file(story_id, project_root)
+    if not session_path:
+        return {}
+
+    result: dict[str, Any] = {"id": story_id}
+
+    # Parse session file (primary data source)
+    session_data = _parse_session_file(session_path)
+    result.update(session_data)
+
+    # Get status from sprint YAML if not in session
+    if "status" not in result:
+        status = _get_sprint_story_status(story_id)
+        if status:
+            result["status"] = status
+
+    # Get PR URL if we have a branch
+    if "pr_url" not in result:
+        pr_url = _get_pr_url(result.get("git_branch", ""))
+        result["pr_url"] = pr_url
+
+    # Check for context files
+    root = project_root or _find_project_root()
+    context_info = _check_context_files(story_id, root)
+    result.update(context_info)
+
+    # Ensure all required keys exist with defaults
+    result.setdefault("title", "")
+    result.setdefault("points", 0)
+    result.setdefault("status", "unknown")
+    result.setdefault("jiraKey", "")
+    result.setdefault("acceptance_criteria", [])
+    result.setdefault("workflow", "")
+    result.setdefault("workflow_phase", "")
+    result.setdefault("git_branch", "")
+    result.setdefault("pr_url", None)
+    result.setdefault("session_notes", "")
+    result.setdefault("review_findings", "")
+    result.setdefault("review_verdict", "")
+
+    return result