@pennyfarthing/core 11.3.3 → 11.3.4

package/pennyfarthing_scripts/bikerack/sprint_panel.py

@@ -1,435 +0,0 @@
-"""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 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 (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 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

package/pennyfarthing_scripts/bikerack/story_detail_data.py

@@ -1,247 +0,0 @@
-"""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", "pennyfarthing_scripts.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