@pennyfarthing/core 11.2.0 → 11.2.1

package/pennyfarthing_scripts/bikerack/story_detail_data.py

@@ -0,0 +1,244 @@
+"""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."""
+    try:
+        out = subprocess.run(
+            ["pf", "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

package/pennyfarthing_scripts/bikerack/story_detail_screen.py

@@ -0,0 +1,176 @@
+"""StoryDetailScreen — Mission dossier detail view for BikeRack TUI.
+
+Story 110-2: Story drill-through with dossier detail screen.
+Pushed via Screen.push() from SprintPanel when user presses Enter on a story.
+"""
+
+from __future__ import annotations
+
+import webbrowser
+from typing import Any
+
+from rich.text import Text
+from textual.binding import Binding
+from textual.screen import Screen
+from textual.widgets import Static
+
+
+class StoryDetailScreen(Screen):
+    """Detail screen showing story dossier layout.
+
+    Displays AC checklist, workflow phase dots, git branch, PR link,
+    and session notes in a mission-dossier layout.
+    """
+
+    BINDINGS = [
+        Binding("escape", "pop_screen", "Back"),
+        Binding("enter", "open_pr_link", "Open PR"),
+    ]
+
+    def __init__(self, story_data: dict[str, Any] | None = None, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        ws_data: dict[str, Any] = story_data or {}
+        self._story_data = self._enrich(ws_data)
+
+    @staticmethod
+    def _enrich(ws_data: dict[str, Any]) -> dict[str, Any]:
+        """Merge WS data with file-based enrichment. WS wins for non-null fields."""
+        story_id = ws_data.get("id", "")
+        if not story_id:
+            return ws_data
+
+        try:
+            from pennyfarthing_scripts.bikerack.story_detail_data import fetch_story_detail
+
+            enriched = fetch_story_detail(story_id)
+        except Exception:
+            return ws_data
+
+        if not enriched:
+            return ws_data
+
+        # Merge: enriched is base, WS data overwrites non-null values
+        merged = {**enriched}
+        for key, val in ws_data.items():
+            if val is not None and val != "" and val != []:
+                merged[key] = val
+        return merged
+
+    def compose(self):
+        """Compose the dossier layout with header, ACs, workflow, git info.
+
+        Absent sections are simply omitted (Tufte: absence is information).
+        """
+        data = self._story_data
+
+        # Header section
+        title = data.get("title", "Unknown Story")
+        points = data.get("points", "?")
+        status = data.get("status", "unknown")
+        jira_key = data.get("jiraKey", "")
+        assignee = data.get("assignee", "")
+        priority = data.get("priority", "")
+
+        header_text = Text()
+        if jira_key:
+            header_text.append(f"{jira_key}", style="bold cyan")
+            header_text.append("  ")
+        header_text.append(f"{title}", style="bold")
+        # Metadata line
+        meta_parts = [status]
+        if points and points != "?":
+            meta_parts.append(f"{points} pts")
+        if priority:
+            meta_parts.append(priority)
+        if assignee:
+            from pennyfarthing_scripts.bikerack.sprint_panel import _format_assignee
+
+            name = _format_assignee(assignee)
+            if name:
+                meta_parts.append(name)
+        header_text.append(f"\n{' \u00b7 '.join(meta_parts)}", style="dim")
+        yield Static(header_text, id="dossier-header")
+
+        # Context section (only if context files exist)
+        has_epic_ctx = data.get("has_epic_context", False)
+        has_story_ctx = data.get("has_story_context", False)
+        if has_epic_ctx or has_story_ctx:
+            ctx_text = Text()
+            ctx_text.append("Context\n", style="bold underline")
+            if has_epic_ctx:
+                ctx_text.append("  \u2713 Epic context\n", style="green")
+            else:
+                ctx_text.append("  \u25cb Epic context\n", style="dim")
+            if has_story_ctx:
+                ctx_text.append("  \u2713 Story context\n", style="green")
+            else:
+                ctx_text.append("  \u25cb Story context\n", style="dim")
+            yield Static(ctx_text, id="dossier-context")
+
+        # Acceptance Criteria section
+        acs = data.get("acceptance_criteria", [])
+        if acs:
+            ac_text = Text()
+            done_count = sum(1 for ac in acs if ac.get("done"))
+            ac_text.append("Acceptance Criteria", style="bold underline")
+            ac_text.append(f"  {done_count}/{len(acs)}\n", style="dim")
+            for ac in acs:
+                check = "\u2713" if ac.get("done") else "\u25cb"
+                style = "green" if ac.get("done") else ""
+                ac_text.append(f"  {check} {ac.get('text', '')}\n", style=style)
+            yield Static(ac_text, id="dossier-ac")
+
+        # Workflow section
+        workflow = data.get("workflow", "")
+        phase = data.get("workflow_phase", "")
+        if workflow:
+            wf_text = Text()
+            wf_text.append("Workflow\n", style="bold underline")
+            wf_text.append(f"  {workflow}", style="cyan")
+            if phase:
+                wf_text.append(f"  Phase: {phase}", style="yellow")
+            wf_text.append("\n")
+            yield Static(wf_text, id="dossier-workflow")
+
+        # Git info section
+        branch = data.get("git_branch", "")
+        pr_url = data.get("pr_url")
+        if branch or pr_url:
+            git_text = Text()
+            git_text.append("Git\n", style="bold underline")
+            if branch:
+                git_text.append(f"  Branch: {branch}\n")
+            if pr_url:
+                git_text.append(f"  PR: {pr_url}\n", style="cyan")
+            yield Static(git_text, id="dossier-git")
+
+        # Session notes section
+        notes = data.get("session_notes", "")
+        if notes:
+            notes_text = Text()
+            notes_text.append("Session Notes\n", style="bold underline")
+            notes_text.append(f"  {notes}\n")
+            yield Static(notes_text, id="dossier-notes")
+
+        # Keybinding hint
+        hint = Text.from_markup(
+            "\n[dim][Escape] Back  [Enter] Open PR[/dim]"
+        )
+        yield Static(hint, id="dossier-hint")
+
+    def action_pop_screen(self) -> None:
+        """Pop this screen off the stack."""
+        self.dismiss()
+
+    def get_pr_url(self) -> str | None:
+        """Get the PR URL from story data."""
+        url = self._story_data.get("pr_url")
+        return url if url else None
+
+    def action_open_pr_link(self) -> bool:
+        """Open PR link in browser via webbrowser.open()."""
+        url = self.get_pr_url()
+        if not url:
+            return False
+        webbrowser.open(url)
+        return True