@pennyfarthing/core 11.3.8 → 11.4.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

@@ -101,6 +101,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/sprint_panel.py

@@ -289,7 +289,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 +356,63 @@ class SprintPanel(Widget):
             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:

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

@@ -27,11 +27,9 @@ from pf.bc.focus import get_last_panel, save_last_panel
 from pf.bikerack.audit_log_panel import AuditLogPanel
 from pf.bikerack.background_panel import BackgroundPanel
 from pf.bikerack.base_panel import get_panel_icon
-from pf.bikerack.changed_panel import ChangedPanel
 from pf.bikerack.context_meter_footer import ContextMeterFooter
 from pf.bikerack.debug_panel import DebugPanel
 from pf.bikerack.diffs_panel import DiffsPanel
-from pf.bikerack.events import NavigateToFile
 from pf.bikerack.git_panel import GitPanel
 from pf.bikerack.progress_panel import ProgressPanel
 from pf.bikerack.sprint_panel import SprintPanel
@@ -79,7 +77,6 @@ PANEL_REGISTRY: list[tuple[str, str]] = [
     ("sprint", "Sprint"),
     ("git", "Git"),
     ("diffs", "Diffs"),
-    ("changed", "Changed"),
     ("background", "Background"),
     ("audit-log", "Audit Log"),
     ("debug", "Debug"),
@@ -95,7 +92,6 @@ PANEL_DISPLAY_NAMES: dict[str, str] = {
     "workflow": "Workflow",
     "background": "Background",
     "audit-log": "Audit Log",
-    "changed": "Changed",
     "ac": "Acceptance Criteria",
     "debug": "Debug",
     "progress": "Progress",
@@ -110,7 +106,7 @@ _PANEL_KEYS = [key for key, _ in PANEL_REGISTRY]
 # Story 110-4: Named presets for common side-by-side views.
 SPLIT_PRESETS: dict[str, tuple[str, str]] = {
     "sprint+diffs": ("sprint", "diffs"),
-    "changed+diffs": ("changed", "diffs"),
+    "git+diffs": ("git", "diffs"),
     "progress+debug": ("progress", "debug"),
 }
 
@@ -442,11 +438,10 @@ class BikeRackApp(App):
         Binding("1", "switch_panel('sprint')", "Sprint", show=False),
         Binding("2", "switch_panel('git')", "Git", show=False),
         Binding("3", "switch_panel('diffs')", "Diffs", show=False),
-        Binding("4", "switch_panel('changed')", "Changed", show=False),
-        Binding("5", "switch_panel('background')", "Background", show=False),
-        Binding("6", "switch_panel('audit-log')", "Audit Log", show=False),
-        Binding("7", "switch_panel('debug')", "Debug", show=False),
-        Binding("8", "switch_panel('progress')", "Progress", show=False),
+        Binding("4", "switch_panel('background')", "Background", show=False),
+        Binding("5", "switch_panel('audit-log')", "Audit Log", show=False),
+        Binding("6", "switch_panel('debug')", "Debug", show=False),
+        Binding("7", "switch_panel('progress')", "Progress", show=False),
         Binding("bracketright", "next_panel", "]Next"),
         Binding("bracketleft", "prev_panel", "[Prev"),
         Binding("tab", "next_panel", show=False, priority=True),
@@ -491,7 +486,6 @@ class BikeRackApp(App):
             yield SprintPanel(client=self._client, id="panel-sprint")
             yield GitPanel(client=self._client, id="panel-git")
             yield DiffsPanel(client=self._client, id="panel-diffs")
-            yield ChangedPanel(client=self._client, id="panel-changed")
             yield BackgroundPanel(client=self._client, id="panel-background")
             yield AuditLogPanel(client=self._client, id="panel-audit-log")
             yield DebugPanel(client=self._client, id="panel-debug")
@@ -537,15 +531,6 @@ class BikeRackApp(App):
             self._client.subscribe("persona", self._handle_persona_message)
             self.run_worker(self._client.connect(), exclusive=True, name="ws-client")
 
-    def on_navigate_to_file(self, event: NavigateToFile) -> None:
-        """Handle NavigateToFile — switch to diffs and navigate to file."""
-        self.action_switch_panel("diffs")
-        try:
-            diffs = self.query_one("#panel-diffs", DiffsPanel)
-            diffs.navigate_to_file(event.path)
-        except Exception:
-            pass
-
     def action_switch_panel(self, key: str) -> None:
         """Switch to a panel by key."""
         if key not in _PANEL_KEYS:

package/pennyfarthing-dist/pf/bmad/parser.py

@@ -61,7 +61,7 @@ _HEADER_PATTERNS: dict[str, re.Pattern[str]] = {
     "date": re.compile(r"^Date:\s*(.+)$", re.MULTILINE),
 }
 
-_TITLE_RE = re.compile(r"^#\s+Story\s+\d+\.\d+:\s*(.+)$", re.MULTILINE)
+_TITLE_RE = re.compile(r"^#\s+Story\s+\d+\.\d+(?:\.\d+)?:\s*(.+)$", re.MULTILINE)
 
 # AC block: everything between ## Acceptance Criteria and the next ## heading
 _AC_RE = re.compile(
@@ -88,10 +88,17 @@ def parse_bmad_story(path: Path) -> dict[str, Any]:
             fields[name] = match.group(1).strip()
 
     story_key = fields.get("story_key", "")
-    parts = story_key.split("-", 2)  # e.g. "1-5-testing-framework" → ["1","5","testing-framework"]
-    epic_num = parts[0] if len(parts) >= 2 else "0"
-    story_num = parts[1] if len(parts) >= 2 else "0"
-    pf_id = f"{epic_num}-{story_num}"
+    # Consume all leading numeric segments as the ID
+    # e.g. "1-5-testing-framework" → "1-5", "2-8-1-claroty-plugin" → "2-8-1"
+    key_parts = story_key.split("-")
+    id_segments: list[str] = []
+    for seg in key_parts:
+        if seg.isdigit():
+            id_segments.append(seg)
+        else:
+            break
+    pf_id = "-".join(id_segments) if len(id_segments) >= 2 else "0-0"
+    epic_num = id_segments[0] if id_segments else "0"
 
     # Title from # heading
     title_match = _TITLE_RE.search(content)
@@ -194,10 +201,9 @@ def discover_bmad_stories(
         story = parse_bmad_story(md_file)
         stories.append(story)
 
-    # Sort by epic number, then story number
-    def sort_key(s: dict) -> tuple[int, int]:
-        parts = s["id"].split("-")
-        return (int(parts[0]), int(parts[1]))
+    # Sort by epic number, then story number (supports variable-length IDs like 2-8-1)
+    def sort_key(s: dict) -> tuple[int, ...]:
+        return tuple(int(p) for p in s["id"].split("-"))
 
     stories.sort(key=sort_key)
     return stories

package/pennyfarthing-dist/pf/common/pr_config.py

@@ -1,8 +1,9 @@
 """PR mode configuration reader.
 
-Reads the pr_mode preference from .pennyfarthing/config.local.yaml.
+Reads the pr_mode and pr_merge preferences from .pennyfarthing/config.local.yaml.
 
-Values: draft | ready | none (default: draft)
+pr_mode values: draft | ready | none (default: draft)
+pr_merge values: auto | human (default: auto)
 """
 
 from __future__ import annotations
@@ -12,6 +13,9 @@ from pf.common.config import load_pennyfarthing_config
 VALID_PR_MODES = {"draft", "ready", "none"}
 DEFAULT_PR_MODE = "draft"
 
+VALID_PR_MERGE_MODES = {"auto", "human"}
+DEFAULT_PR_MERGE_MODE = "auto"
+
 
 def get_pr_mode() -> str:
     """Read pr_mode from pennyfarthing config.
@@ -34,5 +38,26 @@ def get_pr_mode() -> str:
     return mode
 
 
+def get_pr_merge_mode() -> str:
+    """Read pr_merge from pennyfarthing config.
+
+    Looks for workflow.pr_merge in .pennyfarthing/config.local.yaml.
+    Falls back to 'auto' if not set or invalid.
+
+    Returns:
+        One of: 'auto', 'human'
+    """
+    config = load_pennyfarthing_config()
+    workflow = config.get("workflow", {})
+    if not isinstance(workflow, dict):
+        return DEFAULT_PR_MERGE_MODE
+
+    mode = workflow.get("pr_merge", DEFAULT_PR_MERGE_MODE)
+    if mode not in VALID_PR_MERGE_MODES:
+        return DEFAULT_PR_MERGE_MODE
+
+    return mode
+
+
 if __name__ == "__main__":
     print(get_pr_mode())