@pennyfarthing/core 11.4.0 → 12.0.0

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

@@ -0,0 +1,329 @@
+"""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, jira_key: str = ""
+) -> tuple[str | None, bool]:
+    """Locate the session file for a story, trying active then archive.
+
+    Returns:
+        (path, is_archived) tuple. path is None when no session file found.
+    """
+    filename = f"{story_id}-session.md"
+    # 1. Active session in project root
+    if project_root:
+        candidate = os.path.join(project_root, ".session", filename)
+        if os.path.isfile(candidate):
+            return (candidate, False)
+    # 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, False)
+        parent = os.path.dirname(path)
+        if parent == path:
+            break
+        path = parent
+
+    # 2. Archive by local ID: sprint/archive/{story_id}-session.md
+    if project_root:
+        candidate = os.path.join(project_root, "sprint", "archive", filename)
+        if os.path.isfile(candidate):
+            return (candidate, True)
+
+    # 3. Archive by Jira key: sprint/archive/{jira_key}-session.md
+    if jira_key and project_root:
+        jira_filename = f"{jira_key}-session.md"
+        candidate = os.path.join(project_root, "sprint", "archive", jira_filename)
+        if os.path.isfile(candidate):
+            return (candidate, True)
+
+    return (None, False)
+
+
+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]
+        context_dir = os.path.join(project_root, "sprint", "context")
+        # Try numeric ID first (e.g. context-epic-110.md)
+        epic_path = os.path.join(context_dir, f"context-epic-{epic_num}.md")
+        if os.path.isfile(epic_path):
+            result["has_epic_context"] = True
+            result["epic_context_path"] = epic_path
+        else:
+            # Try MSSCI-keyed context file by reading epic Jira key from shard
+            import glob as _glob
+            sprint_dir = os.path.join(project_root, "sprint")
+            for shard in _glob.glob(os.path.join(sprint_dir, "epic-*.yaml")):
+                try:
+                    with open(shard) as f:
+                        for line in f:
+                            if line.startswith("id:"):
+                                shard_id = line.split(":", 1)[1].strip().strip("'\"")
+                                if shard_id == epic_num:
+                                    break
+                        else:
+                            continue
+                    with open(shard) as f:
+                        for line in f:
+                            if line.startswith("jira:"):
+                                jira_key = line.split(":", 1)[1].strip().strip("'\"")
+                                keyed_path = os.path.join(context_dir, f"context-epic-{jira_key}.md")
+                                if os.path.isfile(keyed_path):
+                                    result["has_epic_context"] = True
+                                    result["epic_context_path"] = keyed_path
+                                break
+                except Exception:
+                    continue
+                if result["has_epic_context"]:
+                    break
+
+    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,
+    jira_key: str = "",
+) -> 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.
+        jira_key: Jira key (e.g. "MSSCI-15397") for archive lookup.
+
+    Returns:
+        Dict with keys: id, title, points, status, jiraKey,
+        acceptance_criteria, workflow, workflow_phase,
+        git_branch, pr_url, session_notes, archived.
+        Always returns a populated dict with defaults; enriched with
+        session data when a session file exists.
+    """
+    root = project_root or _find_project_root()
+
+    result: dict[str, Any] = {"id": story_id, "archived": False}
+
+    # Parse session file if available
+    session_path, is_archived = _find_session_file(
+        story_id, root, jira_key=jira_key
+    )
+    if session_path:
+        result["archived"] = is_archived
+        session_data = _parse_session_file(session_path)
+        result.update(session_data)
+
+        # 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
+
+        # Load raw session file content
+        try:
+            with open(session_path) as f:
+                result["session_file_content"] = f.read()
+        except Exception:
+            result["session_file_content"] = ""
+
+    # 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
+
+    # Check for context files (independent of session)
+    context_info = _check_context_files(story_id, root)
+    result.update(context_info)
+
+    # Load context file contents
+    if context_info.get("epic_context_path"):
+        try:
+            with open(context_info["epic_context_path"]) as f:
+                result["epic_context_content"] = f.read()
+        except Exception:
+            result["epic_context_content"] = ""
+
+    if context_info.get("story_context_path"):
+        try:
+            with open(context_info["story_context_path"]) as f:
+                result["story_context_content"] = f.read()
+        except Exception:
+            result["story_context_content"] = ""
+
+    # 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", "")
+    result.setdefault("epic_context_content", "")
+    result.setdefault("story_context_content", "")
+    result.setdefault("session_file_content", "")
+    result.setdefault("archived", False)
+
+    return result

package/pennyfarthing-dist/src/pf/bikerack/story_detail_screen.py

@@ -0,0 +1,283 @@
+"""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.containers import VerticalScroll
+from textual.screen import Screen
+from textual.widgets import Markdown, Static
+
+from pf.bikerack.base_panel import render_progress_bar
+
+# Phase maps for known workflows
+_WORKFLOW_PHASES: dict[str, list[str]] = {
+    "tdd": ["setup", "red", "green", "verify", "review", "finish"],
+    "tdd-tandem": ["setup", "red", "green", "verify", "review", "finish"],
+    "bdd": ["setup", "design", "red", "green", "review", "finish"],
+    "bdd-tandem": ["setup", "design", "red", "green", "review", "finish"],
+    "trivial": ["setup", "implement", "review", "finish"],
+    "agent-docs": ["setup", "orchestrate", "write", "review", "finish"],
+}
+
+# Display labels for workflow phases
+_PHASE_LABELS: dict[str, str] = {
+    "setup": "SM",
+    "red": "TEA",
+    "green": "Dev",
+    "verify": "TEA",
+    "review": "Rev",
+    "finish": "SM",
+    "design": "UX",
+    "implement": "Dev",
+    "orchestrate": "Orch",
+    "write": "TW",
+}
+
+
+def _render_workflow_dots(workflow: str, current_phase: str) -> Text | None:
+    """Render workflow phase dots: [tdd] ✓ SM → ✓ TEA → ● Dev → ○ Rev → ○ SM"""
+    phases = _WORKFLOW_PHASES.get(workflow)
+    if not phases:
+        # Fallback for unknown workflows
+        if not workflow:
+            return None
+        line = Text()
+        line.append(f"[{workflow}]", style="bold")
+        if current_phase:
+            line.append(f"  {current_phase}", style="yellow")
+        return line
+
+    line = Text()
+    line.append(f"[{workflow}]", style="bold")
+    line.append("  ")
+
+    current_idx = phases.index(current_phase) if current_phase in phases else -1
+
+    for i, phase in enumerate(phases):
+        label = _PHASE_LABELS.get(phase, phase)
+
+        if current_idx >= 0 and i < current_idx:
+            line.append("\u2713", style="green")
+            line.append(f" {label}", style="dim")
+        elif phase == current_phase:
+            line.append("\u25cf", style="bold yellow")
+            line.append(f" {label}", style="bold")
+        else:
+            line.append("\u25cb", style="dim")
+            line.append(f" {label}", style="dim")
+
+        if i < len(phases) - 1:
+            line.append(" \u2192 ", style="dim")
+
+    return line
+
+
+class _MarkdownPreview(VerticalScroll):
+    """Scrollable markdown preview container that yields children via compose()."""
+
+    def __init__(self, *content_widgets: Any, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self._content_widgets = content_widgets
+
+    def compose(self):
+        yield from self._content_widgets
+
+
+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 pf.bikerack.story_detail_data import fetch_story_detail
+
+            enriched = fetch_story_detail(
+                story_id, jira_key=ws_data.get("jiraKey", "")
+            )
+        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 != []:
+                merged[key] = val
+        return merged
+
+    def compose(self):
+        """Compose the dossier layout with header, ACs, workflow, git info.
+
+        Tufte-style dense layout — absent sections are simply omitted.
+        """
+        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", "")
+        is_archived = data.get("archived", False)
+
+        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 pf.bikerack.sprint_panel import _format_assignee
+
+            name = _format_assignee(assignee)
+            if name:
+                meta_parts.append(name)
+        separator = " \u00b7 "
+        header_text.append(f"\n{separator.join(meta_parts)}", style="dim")
+        if is_archived:
+            header_text.append("  ARCHIVED", style="dim italic")
+        yield Static(header_text, id="dossier-header")
+
+        # Workflow section — phase dots
+        workflow = data.get("workflow", "")
+        phase = data.get("workflow_phase", "")
+        if workflow:
+            wf_text = _render_workflow_dots(workflow, phase)
+            if wf_text is not None:
+                yield Static(wf_text, id="dossier-workflow")
+
+        # AC section — progress bar
+        acs = data.get("acceptance_criteria", [])
+        if acs:
+            done_count = sum(1 for ac in acs if ac.get("done"))
+            total = len(acs)
+            pct = int(done_count / total * 100) if total > 0 else 0
+            ac_line = Text()
+            ac_line.append("AC   ", style="bold")
+            ac_line.append_text(render_progress_bar(pct, width=10))
+            ac_line.append(f"  {done_count}/{total}")
+            yield Static(ac_line, id="dossier-ac")
+
+        # Context section — always show so user knows what's available
+        has_epic_ctx = data.get("has_epic_context", False)
+        has_story_ctx = data.get("has_story_context", False)
+        ctx_text = Text()
+        ctx_text.append("Ctx  ", style="bold")
+        if has_epic_ctx:
+            ctx_text.append("\u2713 Epic", style="green")
+        else:
+            ctx_text.append("\u25cb Epic", style="dim")
+        ctx_text.append("  ")
+        if has_story_ctx:
+            ctx_text.append("\u2713 Story", style="green")
+        else:
+            ctx_text.append("\u25cb Story", style="dim")
+        yield Static(ctx_text, id="dossier-context")
+
+        # Git info section — single line
+        branch = data.get("git_branch", "")
+        pr_url = data.get("pr_url")
+        if branch or pr_url:
+            git_text = Text()
+            git_text.append("Git  ", style="bold")
+            if branch:
+                git_text.append(branch, style="cyan")
+            if pr_url:
+                git_text.append(f"  PR: {pr_url}", style="cyan")
+            yield Static(git_text, id="dossier-git")
+
+        # Review section
+        review_verdict = data.get("review_verdict", "")
+        review_findings = data.get("review_findings", "")
+        if review_verdict or review_findings:
+            review_text = Text()
+            review_text.append("Review  ", style="bold")
+            if review_verdict:
+                if "approved" in review_verdict.lower():
+                    review_text.append(f"\u2713 {review_verdict}", style="green")
+                else:
+                    review_text.append(review_verdict, style="yellow")
+            if review_findings:
+                review_text.append(f"  {review_findings}", style="dim")
+            yield Static(review_text, id="dossier-review")
+
+        # Session notes section
+        notes = data.get("session_notes", "")
+        if notes:
+            notes_text = Text()
+            notes_text.append("Notes  ", style="bold")
+            notes_text.append(notes)
+            yield Static(notes_text, id="dossier-notes")
+
+        # Markdown preview section (context files + session content)
+        epic_content = data.get("epic_context_content", "")
+        story_content = data.get("story_context_content", "")
+        session_content = data.get("session_file_content", "")
+
+        if epic_content or story_content or session_content:
+            children = []
+            if epic_content:
+                children.append(Markdown(epic_content))
+            if story_content:
+                children.append(Markdown(story_content))
+            if session_content:
+                children.append(Markdown(session_content))
+            yield _MarkdownPreview(*children, id="dossier-preview")
+
+        # 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