@pennyfarthing/core 11.3.3 → 11.3.4

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

@@ -0,0 +1,161 @@
+"""AuditLogPanel — Real-time tool event audit log for BikeRack TUI.
+
+Story 110-8: Subscribes to /ws/spans, displays tool events in a native
+Textual DataTable with timestamp, tool name, input excerpt, and result.
+
+Uses native Textual widgets (DataTable) instead of Rich renderables.
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from typing import Any
+
+from rich.console import Console
+from textual._context import NoActiveAppError
+from textual.widgets import DataTable
+
+from pf.bikerack.base_panel import PANEL_ICONS, BasePanel
+
+MAX_INPUT_LENGTH = 80
+
+# Tool name → Rich style (matches GUI CSS custom properties)
+_TOOL_COLORS: dict[str, str] = {
+    "read": "blue",
+    "write": "dark_orange",
+    "bash": "green",
+    "glob": "medium_purple1",
+    "grep": "dark_cyan",
+    "edit": "yellow",
+    "task": "hot_pink",
+    "skill": "dim",
+}
+
+# Shared fallback console for offline column/cell measurement
+_FALLBACK_CONSOLE = Console()
+
+
+class _OfflineDataTable(DataTable):
+    """DataTable subclass that works without an active Textual app.
+
+    Textual's DataTable.add_columns/add_row need self.app.console for
+    column width measurement. This subclass provides a fallback Rich Console
+    so the table can be constructed and populated in unit tests.
+    """
+
+    @property
+    def app(self):
+        try:
+            return super().app
+        except NoActiveAppError:
+            return type("_Stub", (), {"console": _FALLBACK_CONSOLE})()
+
+
+class AuditLogPanel(BasePanel):
+    """Audit log panel — real-time tool event display via DataTable.
+
+    Subscribes to the 'spans' WebSocket channel and renders tool events
+    in a native Textual DataTable with columns: Time, Tool, Input, Result.
+    """
+
+    channel: str = "spans"
+    panel_name: str = "Audit Log"
+    icon: str = PANEL_ICONS["audit-log"][0]
+
+    def __init__(self, client=None, **kwargs):
+        super().__init__(client=client, **kwargs)
+        self._table = _OfflineDataTable()
+        self._table.add_columns("Time", "Tool", "Input", "Result")
+
+    def handle_message(self, message: dict[str, Any] | None) -> None:
+        """Handle incoming WebSocket messages for tool events.
+
+        Mutates the internal DataTable then delegates to
+        super().handle_message() which calls render_panel() →
+        post_message(DataReceived) for thread-safe Textual repaint.
+        """
+        if not self._mounted or message is None:
+            return
+        if not isinstance(message, dict):
+            return
+
+        msg_type = message.get("type")
+
+        if msg_type == "init":
+            spans = message.get("spans")
+            if not isinstance(spans, list):
+                return
+            self._table.clear()
+            for span in spans:
+                if isinstance(span, dict):
+                    self._add_row(span)
+
+        elif msg_type == "span":
+            span = message.get("span")
+            if isinstance(span, dict):
+                self._add_row(span)
+        else:
+            return
+
+        # Trigger repaint through BasePanel's message system
+        super().handle_message(message)
+
+    def _add_row(self, span: dict[str, Any]) -> None:
+        """Add a single tool event row to the DataTable."""
+        timestamp = span.get("timestamp")
+        tool_name = span.get("toolName", "")
+        input_text = span.get("input", "")
+        success = span.get("success")
+
+        time_str = _format_timestamp(timestamp)
+
+        if len(input_text) > MAX_INPUT_LENGTH:
+            input_text = input_text[: MAX_INPUT_LENGTH - 1] + "\u2026"
+
+        if success is True:
+            result = "\u2713"
+        elif success is False:
+            result = "\u2717"
+        else:
+            result = "\u2014"
+
+        self._table.add_row(time_str, tool_name, input_text, result)
+
+    def render_panel(self, payload: dict[str, Any]) -> Any:
+        """Render current DataTable rows as a Rich Table renderable."""
+        from rich.table import Table as RichTable
+        from rich.text import Text
+
+        if self._table.row_count == 0:
+            return Text("No audit events yet", style="dim italic")
+
+        rich_table = RichTable(show_header=True, expand=True, box=None)
+        rich_table.add_column("Time", style="dim", no_wrap=True)
+        rich_table.add_column("Tool", no_wrap=True)
+        rich_table.add_column("Input")
+        rich_table.add_column("Result", justify="center", no_wrap=True)
+
+        for row_key in reversed(list(self._table.rows)):
+            row_data = self._table.get_row(row_key)
+            time_str, tool_name, input_text, result = (str(c) for c in row_data)
+            tool_style = _TOOL_COLORS.get(tool_name.lower(), "bold cyan")
+            result_style = "green" if result == "\u2713" else "red" if result == "\u2717" else "dim"
+            rich_table.add_row(
+                time_str,
+                Text(tool_name, style=f"bold {tool_style}"),
+                Text(input_text, style="dim") if input_text else Text(""),
+                Text(result, style=result_style),
+            )
+
+        return rich_table
+
+
+def _format_timestamp(ts: Any) -> str:
+    """Format millisecond timestamp to HH:MM:SS."""
+    if ts is None:
+        return "\u2014"
+    try:
+        dt = datetime.fromtimestamp(float(ts) / 1000, tz=UTC)
+        return dt.strftime("%H:%M:%S")
+    except (ValueError, TypeError, OSError):
+        return "\u2014"

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

@@ -0,0 +1,162 @@
+"""BackgroundPanel — Background task status display for BikeRack TUI.
+
+Story 103-16: Subscribes to /ws/background-tasks, renders background task
+list with status indicators (running, completed, failed).
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any
+
+from rich.console import Group
+from rich.text import Text
+
+from pf.bikerack.base_panel import PANEL_ICONS, BasePanel, format_duration
+
+
+class BackgroundPanel(BasePanel):
+    """Background task status panel.
+
+    Subscribes to the ``background-tasks`` WebSocket channel and renders
+    a list of background tasks with status indicators.
+    """
+
+    channel: str = "background-tasks"
+    panel_name: str = "Background"
+    icon: str = PANEL_ICONS["background"][0]
+
+    def __init__(self, client=None, **kwargs):
+        super().__init__(client=client, **kwargs)
+        self._timer = None
+
+    def on_mount(self) -> None:
+        """Subscribe to channel and start elapsed timer."""
+        super().on_mount()
+        self._timer = self.set_interval(1, self._tick)
+
+    def on_unmount(self) -> None:
+        """Stop timer and cleanup."""
+        if self._timer is not None:
+            self._timer.stop()
+        super().on_unmount()
+
+    def _tick(self) -> None:
+        """Re-render every second to update elapsed times."""
+        if self._last_payload is not None:
+            rendered = self.render_panel(self._last_payload)
+            try:
+                self.update(rendered)
+            except Exception:
+                pass
+
+    def render_panel(self, payload: dict[str, Any]) -> Any:
+        """Render background task data from WebSocket payload."""
+        tasks = payload.get("tasks", [])
+        if not isinstance(tasks, list) or not tasks:
+            return Text("No background tasks", style="dim italic")
+
+        running = 0
+        done = 0
+        failed = 0
+        for task in tasks:
+            if not isinstance(task, dict):
+                continue
+            if task.get("completedAt") is not None:
+                if task.get("success"):
+                    done += 1
+                else:
+                    failed += 1
+            else:
+                running += 1
+
+        # Summary header
+        summary = Text()
+        summary.append(f"{running} running", style="yellow")
+        summary.append("  ")
+        summary.append(f"{done} done", style="green")
+        if failed > 0:
+            summary.append("  ")
+            summary.append(f"{failed} failed", style="red")
+
+        separator = Text("─" * 30, style="dim")
+
+        # Task list
+        parts: list[Any] = []
+        for task in tasks:
+            if not isinstance(task, dict):
+                continue
+            parts.append(_render_task(task))
+
+        if not parts:
+            return Text("No background tasks", style="dim italic")
+
+        return Group(summary, separator, *parts)
+
+
+def _render_task(task: dict[str, Any]) -> Text:
+    """Render a single background task as a styled Text line."""
+    description = task.get("description", "Unknown task")
+    subagent_type = task.get("subagentType", "")
+    completed_at = task.get("completedAt")
+    started_at = task.get("startedAt")
+    success = task.get("success")
+    result = task.get("result", "")
+    error = task.get("error", "")
+
+    line = Text()
+
+    if completed_at is not None:
+        if success:
+            line.append("✓ ", style="bold green")
+            line.append(description)
+            if subagent_type:
+                line.append(f" [{subagent_type}]", style="dim")
+            # Show duration if timestamps available
+            duration = _calc_duration(started_at, completed_at)
+            if duration:
+                line.append(f" — {duration}", style="green")
+            else:
+                line.append(" — done", style="green")
+            if result:
+                line.append(f" ({result})", style="dim green")
+        else:
+            line.append("✗ ", style="bold red")
+            line.append(description)
+            if subagent_type:
+                line.append(f" [{subagent_type}]", style="dim")
+            duration = _calc_duration(started_at, completed_at)
+            if duration:
+                line.append(f" — {duration}", style="red")
+            else:
+                line.append(" — failed", style="red")
+            if error:
+                line.append(f"\n  {error}", style="red")
+    else:
+        line.append("⟳ ", style="bold yellow")
+        line.append(description)
+        if subagent_type:
+            line.append(f" [{subagent_type}]", style="dim")
+        # Live elapsed time for running tasks
+        if started_at:
+            try:
+                elapsed = time.time() - float(started_at) / 1000  # startedAt is typically ms
+                line.append(f" — {format_duration(elapsed)}", style="yellow")
+            except (ValueError, TypeError):
+                line.append(" — running", style="yellow")
+        else:
+            line.append(" — running", style="yellow")
+
+    return line
+
+
+def _calc_duration(started_at, completed_at) -> str:
+    """Calculate duration string from timestamps."""
+    if started_at is None or completed_at is None:
+        return ""
+    try:
+        start = float(started_at) / 1000  # ms to seconds
+        end = float(completed_at) / 1000
+        return format_duration(end - start)
+    except (ValueError, TypeError):
+        return ""

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

@@ -0,0 +1,201 @@
+"""ChangedPanel — Changed file list with status for BikeRack TUI.
+
+Story 103-14: Subscribes to /ws/git, extracts dirtyFiles from all repos,
+renders Rich table with file path, change type icon, and status.
+
+Story 110-1: Selectable file list with arrow navigation and Enter to navigate.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from rich.text import Text
+from textual.binding import Binding
+
+from pf.bikerack.base_panel import PANEL_ICONS, BasePanel
+
+# Status code → (icon, label, style)
+_STATUS_MAP: dict[str, tuple[str, str, str]] = {
+    "M": ("~", "Modified", "yellow"),
+    "A": ("+", "Added", "green"),
+    "D": ("-", "Deleted", "red"),
+    "?": ("?", "Untracked", "dim"),
+    "R": ("→", "Renamed", "cyan"),
+}
+
+_DEFAULT_STATUS: tuple[str, str, str] = ("·", "Changed", "yellow")
+
+
+def _parse_status(status: str) -> tuple[str, str, str]:
+    """Parse 2-char git status code into (icon, label, style).
+
+    First char = index (staging area), second char = working tree.
+    Uses the most significant non-space character.
+    """
+    if len(status) < 2:
+        return _STATUS_MAP.get(status[:1], _DEFAULT_STATUS)
+
+    idx, wt = status[0], status[1]
+
+    # Untracked: both chars are '?'
+    if idx == "?" and wt == "?":
+        return _STATUS_MAP["?"]
+
+    # Index change takes priority if present
+    if idx not in (" ", "?"):
+        return _STATUS_MAP.get(idx, _DEFAULT_STATUS)
+
+    # Working tree change
+    if wt not in (" ", "?"):
+        return _STATUS_MAP.get(wt, _DEFAULT_STATUS)
+
+    return _DEFAULT_STATUS
+
+
+class ChangedPanel(BasePanel):
+    """Changed file list panel.
+
+    Subscribes to the ``git`` WebSocket channel and renders
+    dirty files from all repos as a Rich table with file path,
+    change type icon, and status. Supports arrow-key selection
+    and Enter to navigate to diffs.
+    """
+
+    channel: str = "git"
+    panel_name: str = "Changed"
+    icon: str = PANEL_ICONS["changed"][0]
+    can_focus = True
+
+    BINDINGS = [
+        Binding("up", "select_prev_key", "Up"),
+        Binding("down", "select_next_key", "Down"),
+        Binding("enter", "select_file", "Select file"),
+    ]
+
+    def __init__(self, client=None, **kwargs):
+        super().__init__(client=client, **kwargs)
+        self._selected_index: int = 0
+        self._file_paths: list[str] = []
+
+    def handle_message(self, message: dict[str, Any] | None) -> None:
+        """Handle incoming 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."""
+        self.select_next()
+
+    def action_select_prev_key(self) -> None:
+        """Binding action: move selection up."""
+        self.select_prev()
+
+    def _rerender(self) -> None:
+        """Re-render panel with current payload after selection change."""
+        if self._last_payload:
+            try:
+                self.update(self.render_panel(self._last_payload))
+            except Exception:
+                pass
+
+    def get_selected_path(self) -> str | None:
+        """Return the currently selected file path, or None if empty."""
+        if not self._file_paths:
+            return None
+        if self._selected_index >= len(self._file_paths):
+            return None
+        return self._file_paths[self._selected_index]
+
+    def action_select_file(self) -> None:
+        """Post NavigateToFile event for the selected file."""
+        path = self.get_selected_path()
+        if path is not None:
+            from pf.bikerack.events import NavigateToFile
+
+            self.post_message(NavigateToFile(path=path))
+
+    def render_panel(self, payload: dict[str, Any]) -> Any:
+        """Render changed files grouped by repository with selection highlight."""
+        repos = payload.get("repos", [])
+        if not isinstance(repos, list):
+            return Text("No changed files", style="dim italic")
+
+        # Group files by repo
+        repo_files: dict[str, list[dict[str, Any]]] = {}
+        for repo in repos:
+            if not isinstance(repo, dict):
+                continue
+            repo_name = repo.get("name", "unknown")
+            dirty_files = repo.get("dirtyFiles", [])
+            if not isinstance(dirty_files, list) or not dirty_files:
+                continue
+            repo_files[repo_name] = [f for f in dirty_files if isinstance(f, dict)]
+
+        if not repo_files:
+            return Text("No changed files", style="dim italic")
+
+        from rich.console import Group as RichGroup
+
+        parts: list[Any] = []
+        flat_idx = 0
+        for repo_name, files in repo_files.items():
+            count = len(files)
+            label = "file" if count == 1 else "files"
+            header = Text()
+            header.append(repo_name, style="bold cyan")
+            header.append(f" ({count} {label})", style="dim")
+            parts.append(header)
+
+            for f in files:
+                status_code = f.get("status", "  ")
+                path = f.get("path", "")
+                icon, label_text, style = _parse_status(status_code)
+                is_selected = flat_idx == self._selected_index
+                line = Text()
+                if is_selected:
+                    line.append("› ", style="bold reverse")
+                else:
+                    line.append("  ")
+                line.append(icon, style=f"bold {style}")
+                line.append(f" {path}", style="bold cyan reverse" if is_selected else "cyan")
+                line.append(f"  {label_text}", style=style)
+                parts.append(line)
+                flat_idx += 1
+
+            parts.append(Text(""))  # spacer between repos
+
+        return RichGroup(*parts)