@pennyfarthing/core 11.3.8 → 11.5.0-alpha.0

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

@@ -1,14 +1,22 @@
-"""GitPanel — Multi-repo git status panel for BikeRack TUI.
+"""GitPanel — Multi-repo git status panel with diff drill-through for BikeRack TUI.
 
 Story 103-10: Subscribes to /ws/git, renders multi-repo git status
 as Rich table with Nerd Font glyphs for branch and status indicators.
+
+Merge: Changed panel consolidated into Git panel — clickable file list
+with Enter to view diff inline, Escape to return to repo overview.
 """
 
 from __future__ import annotations
 
+import os
+import re
 from typing import Any
 
+from rich.console import Group as RichGroup
+from rich.syntax import Syntax
 from rich.text import Text
+from textual.binding import Binding
 
 from pf.bikerack.base_panel import PANEL_ICONS, BasePanel
 
@@ -63,27 +71,265 @@ def _parse_file_status(status: str) -> tuple[str, str, str]:
     return ("·", "Changed", "yellow")
 
 
+# ---- Diff rendering helpers (from diffs_panel.py patterns) ----
+
+_LANG_MAP: dict[str, str] = {
+    ".py": "python", ".ts": "typescript", ".tsx": "tsx",
+    ".js": "javascript", ".jsx": "jsx", ".go": "go",
+    ".rs": "rust", ".rb": "ruby", ".java": "java",
+    ".css": "css", ".html": "html", ".json": "json",
+    ".yaml": "yaml", ".yml": "yaml", ".md": "markdown",
+    ".sh": "bash", ".zsh": "bash", ".toml": "toml",
+    ".xml": "xml", ".sql": "sql", ".c": "c", ".cpp": "cpp",
+    ".h": "c", ".hpp": "cpp",
+}
+
+
+def _detect_language(path: str) -> str:
+    """Detect programming language from file path for syntax highlighting."""
+    ext = os.path.splitext(path)[1].lower()
+    return _LANG_MAP.get(ext, "text")
+
+
+def _highlight_code(code: str, language: str) -> Text:
+    """Apply syntax highlighting to a single line."""
+    if not code or not code.strip():
+        return Text(code)
+    try:
+        syntax = Syntax(code, language, theme="monokai", background_color="default")
+        highlighted = syntax.highlight(code)
+        highlighted.rstrip()
+        return highlighted
+    except Exception:
+        return Text(code)
+
+
+def _render_inline_diff(diff_entry: dict[str, Any]) -> list[Any]:
+    """Render a single file diff inline for drill-through view."""
+    path = diff_entry.get("path", "unknown")
+    status = diff_entry.get("status", "")
+    additions = diff_entry.get("additions")
+    deletions = diff_entry.get("deletions")
+    raw_diff = diff_entry.get("diff", "")
+
+    header = Text()
+    header.append(path, style="bold cyan")
+    if status:
+        header.append(f"  {status}", style="dim")
+    if additions is not None and deletions is not None:
+        header.append(f"  +{additions} -{deletions}", style="dim")
+
+    language = _detect_language(path)
+    parts: list[Any] = [header]
+
+    if not raw_diff or not raw_diff.strip():
+        parts.append(Text("(no diff content)", style="dim italic"))
+        return parts
+
+    line_num = 0
+    for line in raw_diff.split("\n"):
+        if line.startswith("diff --git") or line.startswith("index "):
+            continue
+        if line.startswith("---") or line.startswith("+++"):
+            continue
+        if line.startswith("new file") or line.startswith("deleted file"):
+            continue
+        if line.startswith("rename "):
+            continue
+        if line == "":
+            continue
+
+        if line.startswith("Binary files"):
+            parts.append(Text(line, style="dim italic"))
+        elif line.startswith("@@"):
+            match = re.match(r"@@ -\d+(?:,\d+)? \+(\d+)", line)
+            if match:
+                line_num = int(match.group(1)) - 1
+            parts.append(Text(line, style="cyan"))
+        elif line.startswith("+"):
+            line_num += 1
+            t = Text()
+            t.append(f"{line_num:4d} ", style="dim green")
+            t.append_text(_highlight_code(line[1:], language))
+            parts.append(t)
+        elif line.startswith("-"):
+            t = Text()
+            t.append("   - ", style="red")
+            t.append_text(_highlight_code(line[1:], language))
+            parts.append(t)
+        elif line.startswith(" "):
+            line_num += 1
+            t = Text()
+            t.append(f"{line_num:4d} ", style="dim")
+            t.append_text(_highlight_code(line[1:], language))
+            parts.append(t)
+        else:
+            parts.append(Text(line, style="dim"))
+
+    return parts
+
+
 class GitPanel(BasePanel):
-    """Multi-repo git status panel.
+    """Multi-repo git status panel with diff drill-through.
 
-    Subscribes to the ``git`` WebSocket channel and renders
-    git status for all configured repos as a Rich table with
-    columns: Repository, Branch, Commits, Changes, Status.
+    Subscribes to the ``git`` and ``diffs`` WebSocket channels.
+    Renders git status for all configured repos. Clicking a file
+    (Enter) shows its diff inline; Escape returns to the overview.
     """
 
     channel: str = "git"
     panel_name: str = "Git"
     icon: str = PANEL_ICONS["git"][0]
+    can_focus = True
+
+    BINDINGS = [
+        Binding("up", "select_prev_key", "Up"),
+        Binding("down", "select_next_key", "Down"),
+        Binding("enter", "drill_into_file", "View diff"),
+        Binding("escape", "back_to_overview", "Back"),
+    ]
+
+    def __init__(self, client=None, **kwargs):
+        super().__init__(client=client, **kwargs)
+        self._selected_index: int = 0
+        self._file_paths: list[str] = []
+        self._viewing_diff: bool = False
+        self._diff_file_path: str | None = None
+        self._diffs_payload: dict[str, Any] | None = None
+
+        # Subscribe to diffs channel for diff data
+        if client is not None:
+            client.subscribe("diffs", self._handle_diffs_message)
+
+    def _handle_diffs_message(self, message: dict[str, Any] | None) -> None:
+        """Store diffs payload for drill-through rendering."""
+        if message is not None:
+            self._diffs_payload = message
+            # If viewing a diff, re-render with updated diff data
+            if self._viewing_diff:
+                self._rerender()
+
+    def handle_message(self, message: dict[str, Any] | None) -> None:
+        """Handle incoming git message — build file path index then render."""
+        if message is not None:
+            self._build_file_paths(message)
+        super().handle_message(message)
+
+    def _build_file_paths(self, payload: dict[str, Any]) -> None:
+        """Extract flat list of file paths from repos payload."""
+        paths: list[str] = []
+        repos = payload.get("repos", [])
+        if isinstance(repos, list):
+            for repo in repos:
+                if not isinstance(repo, dict):
+                    continue
+                dirty_files = repo.get("dirtyFiles", [])
+                if not isinstance(dirty_files, list):
+                    continue
+                for f in dirty_files:
+                    if isinstance(f, dict):
+                        path = f.get("path", "")
+                        if path:
+                            paths.append(path)
+        self._file_paths = paths
+        if self._selected_index >= len(paths):
+            self._selected_index = max(0, len(paths) - 1)
+
+    def select_next(self) -> None:
+        """Move selection to the next file."""
+        if self._file_paths and self._selected_index < len(self._file_paths) - 1:
+            self._selected_index += 1
+            self._rerender()
+
+    def select_prev(self) -> None:
+        """Move selection to the previous file."""
+        if self._selected_index > 0:
+            self._selected_index -= 1
+            self._rerender()
+
+    def action_select_next_key(self) -> None:
+        """Binding action: move selection down."""
+        if not self._viewing_diff:
+            self.select_next()
+
+    def action_select_prev_key(self) -> None:
+        """Binding action: move selection up."""
+        if not self._viewing_diff:
+            self.select_prev()
+
+    def action_drill_into_file(self) -> None:
+        """Enter diff drill-through for the selected file."""
+        if self._viewing_diff:
+            return
+        if not self._file_paths:
+            return
+        if self._selected_index >= len(self._file_paths):
+            return
+        self._diff_file_path = self._file_paths[self._selected_index]
+        self._viewing_diff = True
+        self._rerender()
+
+    def action_back_to_overview(self) -> None:
+        """Return to the repo overview from diff view."""
+        if self._viewing_diff:
+            self._viewing_diff = False
+            self._diff_file_path = None
+            self._rerender()
+
+    def _rerender(self) -> None:
+        """Re-render panel with current payload."""
+        if self._last_payload:
+            try:
+                self.update(self.render_panel(self._last_payload))
+            except Exception:
+                pass
+
+    def _find_diff_for_path(self, path: str) -> dict[str, Any] | None:
+        """Find a diff entry matching the given file path."""
+        if self._diffs_payload is None:
+            return None
+        diffs = self._diffs_payload.get("diffs", [])
+        for d in diffs:
+            d_path = d.get("path", "")
+            if d_path == path or d_path.endswith(path) or path.endswith(d_path):
+                return d
+        return None
 
     def render_panel(self, payload: dict[str, Any]) -> Any:
-        """Render git status as Rich Tree with expandable file lists."""
-        from rich.console import Group as RichGroup
+        """Render git status or diff drill-through view."""
+        if self._viewing_diff and self._diff_file_path:
+            return self._render_diff_view()
+        return self._render_repo_overview(payload)
+
+    def _render_diff_view(self) -> Any:
+        """Render inline diff for the selected file."""
+        parts: list[Any] = []
 
+        # Back bar
+        back = Text()
+        back.append("← ", style="bold")
+        back.append("Esc", style="bold yellow")
+        back.append(" back  ", style="dim")
+        back.append(self._diff_file_path or "", style="bold cyan")
+        parts.append(back)
+        parts.append(Text(""))
+
+        diff_entry = self._find_diff_for_path(self._diff_file_path or "")
+        if diff_entry:
+            parts.extend(_render_inline_diff(diff_entry))
+        else:
+            parts.append(Text(f"No diff available for {self._diff_file_path}", style="dim italic"))
+
+        return RichGroup(*parts)
+
+    def _render_repo_overview(self, payload: dict[str, Any]) -> Any:
+        """Render git status as repo list with selectable file lists."""
         repos = payload.get("repos", [])
         if not repos:
             return Text("No repository data", style="dim italic")
 
         parts: list[Any] = []
+        flat_idx = 0
         for repo in repos:
             branch = repo.get("branch", "")
             ahead = repo.get("ahead", 0)
@@ -120,7 +366,7 @@ class GitPanel(BasePanel):
 
             parts.append(header)
 
-            # Expanded file list for dirty repos
+            # Expanded file list for dirty repos — with selection highlight
             if not clean and dirty_files:
                 for f in dirty_files:
                     if not isinstance(f, dict):
@@ -128,12 +374,29 @@ class GitPanel(BasePanel):
                     status_code = f.get("status", "  ")
                     path = f.get("path", "")
                     icon, label, style = _parse_file_status(status_code)
+                    is_selected = flat_idx == self._selected_index
                     file_line = Text()
-                    file_line.append("    ")
+                    if is_selected:
+                        file_line.append("  › ", style="bold reverse")
+                    else:
+                        file_line.append("    ")
                     file_line.append(icon, style=f"bold {style}")
-                    file_line.append(f" {path}", style=style)
+                    file_line.append(
+                        f" {path}",
+                        style="bold cyan reverse" if is_selected else style,
+                    )
                     parts.append(file_line)
+                    flat_idx += 1
 
             parts.append(Text(""))  # spacer
 
+        # Hint line
+        if self._file_paths:
+            hint = Text()
+            hint.append("↑↓", style="bold yellow")
+            hint.append(" select  ", style="dim")
+            hint.append("Enter", style="bold yellow")
+            hint.append(" view diff", style="dim")
+            parts.append(hint)
+
         return RichGroup(*parts)

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

@@ -41,6 +41,16 @@ def _extract_agent_slug(theme_yaml: Path, agent: str) -> str | None:
     return None
 
 
+def _is_lfs_pointer(path: Path) -> bool:
+    """Check if a file is a git-lfs pointer instead of actual image data."""
+    try:
+        with open(path, "rb") as f:
+            header = f.read(44)
+        return header.startswith(b"version https://git-lfs")
+    except OSError:
+        return False
+
+
 def _find_portrait(portraits_theme_dir: Path, slug: str) -> Path | None:
     """Find a portrait file matching the slug in a theme's portrait directory."""
     if not portraits_theme_dir.is_dir():
@@ -50,11 +60,13 @@ def _find_portrait(portraits_theme_dir: Path, slug: str) -> Path | None:
         if size_dir.is_dir():
             for f in size_dir.iterdir():
                 if f.name.lower().startswith(slug.lower()) and f.suffix in (".png", ".jpg"):
-                    return f
+                    if not _is_lfs_pointer(f):
+                        return f
     # Fallback to root of theme dir
     for f in portraits_theme_dir.iterdir():
         if f.is_file() and f.name.lower().startswith(slug.lower()) and f.suffix in (".png", ".jpg"):
-            return f
+            if not _is_lfs_pointer(f):
+                return f
     return None
 
 
@@ -101,6 +113,27 @@ def resolve_portrait_path(
         if result:
             return result
 
+    # Fallback: search Cyclist package portrait directories
+    # Portraits are bundled in @pennyfarthing/cyclist, not alongside theme YAMLs
+    root = project_root or Path.cwd()
+    cyclist_portrait_dirs = [
+        root / "packages" / "cyclist" / "portraits" / theme,  # monorepo dev
+        root / "node_modules" / "@pennyfarthing" / "cyclist" / "portraits" / theme,  # npm
+    ]
+    # pnpm: resolve through .pennyfarthing symlink chain
+    pnpm_cyclist = root / "node_modules" / ".pnpm"
+    if pnpm_cyclist.is_dir():
+        for entry in pnpm_cyclist.iterdir():
+            if entry.name.startswith("@pennyfarthing+cyclist@"):
+                candidate = entry / "node_modules" / "@pennyfarthing" / "cyclist" / "portraits" / theme
+                cyclist_portrait_dirs.append(candidate)
+                break
+
+    for portraits_dir in cyclist_portrait_dirs:
+        result = _find_portrait(portraits_dir, slug)
+        if result:
+            return result
+
     return None
 
 

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

@@ -3,6 +3,8 @@
 Combines story context, workflow phase, acceptance criteria, todos, and
 git status into a single at-a-glance panel. Subscribes to 4 WS channels:
 /ws/story, /ws/todos, /ws/git, /ws/sprint.
+
+Story 120-8: Added Enter keybinding for story detail drill-through.
 """
 
 from __future__ import annotations
@@ -11,6 +13,7 @@ from typing import Any
 
 from rich.console import Group
 from rich.text import Text
+from textual.binding import Binding
 
 from pf.bikerack.base_panel import (
     PANEL_ICONS,
@@ -31,6 +34,10 @@ class ProgressPanel(BasePanel):
     panel_name: str = "Progress"
     icon: str = PANEL_ICONS.get("progress", ("\uf200", "P"))[0]
 
+    BINDINGS = [
+        Binding("enter", "drill_detail", "Story Details", show=False),
+    ]
+
     def __init__(self, client: Any = None, **kwargs: Any) -> None:
         super().__init__(client=client, **kwargs)
         self._story_data: dict[str, Any] | None = None
@@ -79,6 +86,49 @@ class ProgressPanel(BasePanel):
         except Exception:
             pass
 
+    def drill_into_story(self) -> None:
+        """Push StoryDetailScreen for the current story."""
+        story_data = self._build_story_detail_data()
+        if story_data is None:
+            return
+        from pf.bikerack.story_detail_screen import StoryDetailScreen
+
+        try:
+            self.app.push_screen(StoryDetailScreen(story_data=story_data))
+        except Exception:
+            pass
+
+    def action_drill_detail(self) -> None:
+        """Action handler for Enter keybinding — drill into story details."""
+        self.drill_into_story()
+
+    def _build_story_detail_data(self) -> dict[str, Any] | None:
+        """Build story_data dict suitable for StoryDetailScreen."""
+        story = self._story_data or {}
+        sprint = self._sprint_data or {}
+
+        current = sprint.get("sprint", {}).get("currentStory")
+        if isinstance(current, str) and current:
+            story_id = current
+        else:
+            story_id = story.get("id", "")
+
+        if not story_id and not story.get("title"):
+            return None
+
+        return {
+            "id": story_id,
+            "title": story.get("title", ""),
+            "points": story.get("points", ""),
+            "status": story.get("status", ""),
+            "assignee": story.get("assignee", ""),
+            "workflow": story.get("workflow", ""),
+            "workflow_phase": story.get("phase", ""),
+            **{k: v for k, v in story.items() if k not in (
+                "id", "title", "points", "status", "assignee", "workflow", "phase",
+            )},
+        }
+
     def render_panel(self, payload: dict[str, Any]) -> Any:
         """Render unified progress view."""
         parts: list[Any] = []
@@ -116,6 +166,10 @@ class ProgressPanel(BasePanel):
         if git is not None:
             parts.append(git)
 
+        # --- Drill-through hint ---
+        parts.append(Text(""))
+        parts.append(Text("[Enter] Story Details", style="dim"))
+
         return Group(*parts)
 
     def _render_story_header(self) -> Text | None:

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

@@ -280,6 +280,16 @@ class SprintPanel(Widget):
             f"In Progress: {in_progress} | "
             f"Velocity: {velocity}"
         )
+        registry = payload.get("registry")
+        if registry and not registry.get("isDefault", True):
+            reg_type = registry.get("type", "")
+            reg_name = registry.get("name", "")
+            if reg_type and reg_name:
+                header_text.append(f" [{reg_type}:{reg_name}]")
+            elif reg_name:
+                header_text.append(f" [{reg_name}]")
+            elif reg_type:
+                header_text.append(f" [{reg_type}]")
         try:
             self.query_one("#sprint-header", Static).update(header_text)
         except Exception:
@@ -289,7 +299,7 @@ class SprintPanel(Widget):
         saved_expanded: dict[str, bool] = {}
         for node in tree.root.children:
             data = node.data
-            if data and data.get("type") == "epic":
+            if data and data.get("type") in ("epic", "future_initiative"):
                 saved_expanded[data["id"]] = node.is_expanded
 
         # Save cursor position by node identity
@@ -356,6 +366,111 @@ class SprintPanel(Widget):
             if cursor_node_key == f"epic:{epic_id}":
                 cursor_target = epic_node
 
+        # Completed Epics section (Story 110-6)
+        completed_epics = payload.get("completedEpics", [])
+        if completed_epics:
+            separator_label = Text("── Completed ──", style="bold dim")
+            tree.root.add_leaf(separator_label, data={"type": "separator"})
+
+            for epic in completed_epics:
+                epic_id = epic.get("id", "")
+                epic_title = epic.get("title", "")
+                stories = epic.get("stories", [])
+
+                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)
+
+                for story in stories:
+                    story_label = _build_story_label(story, current_story_id)
+                    story_data: dict[str, Any] = {"type": "story", "story": story}
+                    epic_node.add_leaf(story_label, data=story_data)
+
+                # Completed epics: collapsed by default, respect saved state
+                if epic_id in saved_expanded:
+                    if saved_expanded[epic_id]:
+                        epic_node.expand()
+                    else:
+                        epic_node.collapse()
+                else:
+                    epic_node.collapse()
+
+                if cursor_node_key == f"epic:{epic_id}":
+                    cursor_target = epic_node
+
+        # Future Initiatives section (Story 118-1)
+        future_epics = payload.get("futureEpics", [])
+        if future_epics:
+            # Section separator
+            separator_label = Text("── Future Initiatives ──", style="bold dim")
+            tree.root.add_leaf(separator_label, data={"type": "separator"})
+
+            for initiative in future_epics:
+                init_id = initiative.get("id", "")
+                init_title = initiative.get("title", "")
+                init_pts = initiative.get("estimatedPoints", 0)
+                init_status = initiative.get("status", "planning")
+                children = initiative.get("children", [])
+
+                # Build initiative label
+                init_label = Text(no_wrap=True, overflow="ellipsis")
+                status_style = "green" if init_status == "ready" else "dim yellow"
+                init_label.append(f"[{init_status}]", style=status_style)
+                init_label.append(f"  {init_title}", style="bold")
+                init_label.append(f"  {init_pts} pts", style="dim")
+                if children:
+                    init_label.append(f"  ({len(children)} epics)", style="dim")
+
+                init_data: dict[str, Any] = {
+                    "type": "future_initiative",
+                    "id": init_id,
+                    "title": init_title,
+                }
+                init_node = tree.root.add(init_label, data=init_data)
+
+                # Add child epics as leaves
+                for child in children:
+                    child_label = Text(no_wrap=True, overflow="ellipsis")
+                    child_status = child.get("status", "planning")
+                    child_style = "green" if child_status == "ready" else "dim yellow"
+                    child_label.append(f"  [{child_status}]", style=child_style)
+                    child_label.append(f"  {child.get('title', '')}")
+                    child_label.append(f"  {child.get('estimatedPoints', 0)} pts", style="dim")
+                    child_label.append(f"  {child.get('storyCount', 0)} stories", style="dim")
+                    child_data: dict[str, Any] = {
+                        "type": "future_epic_child",
+                        "id": child.get("id", ""),
+                    }
+                    init_node.add_leaf(child_label, data=child_data)
+
+                # Restore expand state or collapse by default
+                if init_id in saved_expanded:
+                    if saved_expanded[init_id]:
+                        init_node.expand()
+                    else:
+                        init_node.collapse()
+                else:
+                    init_node.collapse()
+
+                if cursor_node_key == f"epic:{init_id}":
+                    cursor_target = init_node
+
         # Restore cursor position
         if cursor_target is not None:
             try: