@pennyfarthing/core 11.2.1 → 11.3.1

package/pennyfarthing_scripts/bellmode_hook.py

@@ -7,11 +7,8 @@ This file will be removed in a future version.
 # Re-export public API from new location for existing tests/imports
 from pennyfarthing_scripts.hooks.bell_mode import (  # noqa: F401
     _check_tandem_files as check_tandem_files,
-    _get_latest_observation as get_latest_observation,
-    _get_tandem_mtime as get_tandem_mtime,
-    _read_bell_queue as read_bell_queue,
-    _read_tandem_observations as read_tandem_observations,
-    _save_tandem_mtime as save_tandem_mtime,
+)
+from pennyfarthing_scripts.hooks.bell_mode import (
     main,
 )
 

package/pennyfarthing_scripts/bikerack/audit_log_panel.py

@@ -8,7 +8,7 @@ Uses native Textual widgets (DataTable) instead of Rich renderables.
 
 from __future__ import annotations
 
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from typing import Any
 
 from rich.console import Console
@@ -19,6 +19,18 @@ from pennyfarthing_scripts.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()
 
@@ -58,8 +70,9 @@ class AuditLogPanel(BasePanel):
     def handle_message(self, message: dict[str, Any] | None) -> None:
         """Handle incoming WebSocket messages for tool events.
 
-        Overrides BasePanel.handle_message to manipulate DataTable directly
-        instead of going through render_panel/post_message.
+        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
@@ -81,6 +94,11 @@ class AuditLogPanel(BasePanel):
             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."""
@@ -104,8 +122,32 @@ class AuditLogPanel(BasePanel):
         self._table.add_row(time_str, tool_name, input_text, result)
 
     def render_panel(self, payload: dict[str, Any]) -> Any:
-        """Not used — handle_message manages DataTable directly."""
-        return self._table
+        """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:
@@ -113,7 +155,7 @@ def _format_timestamp(ts: Any) -> str:
     if ts is None:
         return "\u2014"
     try:
-        dt = datetime.fromtimestamp(float(ts) / 1000, tz=timezone.utc)
+        dt = datetime.fromtimestamp(float(ts) / 1000, tz=UTC)
         return dt.strftime("%H:%M:%S")
     except (ValueError, TypeError, OSError):
         return "\u2014"

package/pennyfarthing_scripts/bikerack/context_meter_footer.py

@@ -4,11 +4,15 @@ Story 110-5: Context meter footer bar. Displays context window usage
 percentage with color-coded tier thresholds, always visible at the
 bottom of the layout.
 
+Story 110-12: Periodic refresh timer, event-driven redraws, and
+throttling for more frequent updates without performance degradation.
+
 Subscribes to /ws/context WebSocket channel.
 """
 
 from __future__ import annotations
 
+import time
 from typing import Any
 
 from rich.text import Text
@@ -35,34 +39,80 @@ class ContextMeterFooter(Static):
     #: WebSocket channel this footer subscribes to
     channel: str = "context"
 
+    #: Seconds between periodic refresh redraws
+    refresh_interval: float = 5.0
+
+    #: Minimum seconds between redraws (throttle)
+    min_redraw_interval: float = 0.25
+
     def __init__(self, client: Any = None, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         self._client = client
         self._context_data: dict[str, Any] | None = None
         self._mounted = False
+        self._refresh_timer: Any = None
+        self._last_redraw_time: float = 0.0
+        self.last_update_time: float = 0.0
+
+    @property
+    def is_stale(self) -> bool:
+        """True if no context data has been received."""
+        return self._context_data is None
 
     def on_mount(self) -> None:
-        """Subscribe to context channel on mount."""
+        """Subscribe to context channel and start periodic refresh on mount."""
         self._mounted = True
         if self._client is not None:
             self._client.subscribe("context", self.handle_context_message)
+            self._client.on_state_change(self.on_connection_state_change)
+        try:
+            self._refresh_timer = self.set_interval(
+                self.refresh_interval, self.request_refresh
+            )
+        except RuntimeError:
+            # No running event loop (e.g. unit tests calling on_mount directly)
+            pass
 
     def on_unmount(self) -> None:
-        """Mark as unmounted so further messages are ignored."""
+        """Stop timer and mark as unmounted so further messages are ignored."""
         self._mounted = False
+        if self._refresh_timer is not None:
+            self._refresh_timer.stop()
 
     def on_context_meter_footer_meter_update(self, event: MeterUpdate) -> None:
         """Process MeterUpdate in Textual message context — triggers repaint."""
         self.update(event.content)
 
+    def request_refresh(self) -> None:
+        """Redraw from cached context data. Safe to call at any time."""
+        if not self._mounted or self._context_data is None:
+            return
+        try:
+            rendered = self.render_meter(self._context_data)
+            self.post_message(self.MeterUpdate(rendered))
+        except Exception:
+            pass
+
+    def on_connection_state_change(self, state: Any) -> None:
+        """Redraw on WebSocket reconnection."""
+        self.request_refresh()
+
     def handle_context_message(self, msg: dict[str, Any] | None) -> None:
-        """Process incoming /ws/context message."""
+        """Process incoming /ws/context message with throttling."""
         if not self._mounted or msg is None:
             return
         ctx = msg.get("context")
         if ctx is None:
             return
         self._context_data = ctx
+        self.last_update_time = time.monotonic()
+
+        # Throttle: skip redraw if too soon after last one
+        now = time.monotonic()
+        if now - self._last_redraw_time < self.min_redraw_interval:
+            return
+        self._last_redraw_time = now
+
         try:
             rendered = self.render_meter(ctx)
             self.post_message(self.MeterUpdate(rendered))

package/pennyfarthing_scripts/bikerack/launcher.py

@@ -24,8 +24,8 @@ def is_process_alive(pid: int) -> bool:
 
 
 def cleanup_files(project_dir: Path) -> None:
-    """Clean up .wheelhub-port, .wheelhub-pid, and .wheelhub-gui-pid files."""
-    for name in (".wheelhub-port", ".wheelhub-pid", ".wheelhub-gui-pid"):
+    """Clean up .bikerack-port, .wheelhub-pid, and .wheelhub-gui-pid files."""
+    for name in (".bikerack-port", ".wheelhub-pid", ".wheelhub-gui-pid"):
         try:
             (project_dir / name).unlink()
         except FileNotFoundError:
@@ -33,9 +33,9 @@ def cleanup_files(project_dir: Path) -> None:
 
 
 def read_port_file(project_dir: Path) -> int | None:
-    """Read port from .wheelhub-port file. Returns None if not found."""
+    """Read port from .bikerack-port file. Returns None if not found."""
     try:
-        return int((project_dir / ".wheelhub-port").read_text().strip())
+        return int((project_dir / ".bikerack-port").read_text().strip())
     except (FileNotFoundError, ValueError):
         return None
 
@@ -104,8 +104,8 @@ def start_wheelhub(project_dir: Path) -> subprocess.Popen:
 def poll_for_port_file(
     project_dir: Path, timeout: float = 5.0, interval: float = 0.1
 ) -> int:
-    """Poll for .wheelhub-port file, return port number."""
-    port_file = project_dir / ".wheelhub-port"
+    """Poll for .bikerack-port file, return port number."""
+    port_file = project_dir / ".bikerack-port"
     deadline = time.monotonic() + timeout
 
     while True:

package/pennyfarthing_scripts/bikerack/progress_panel.py

@@ -265,7 +265,6 @@ class ProgressPanel(BasePanel):
         line = Text()
         line.append("Git  ", style="bold")
 
-        repo_parts: list[str] = []
         for repo in repos:
             if not isinstance(repo, dict):
                 continue

package/pennyfarthing_scripts/bikerack/sprint_panel.py

@@ -228,7 +228,7 @@ class SprintPanel(Widget):
         """Mark unmounted so WS callbacks are ignored."""
         self._mounted = False
 
-    def focus(self, scroll_visible: bool = True) -> "SprintPanel":
+    def focus(self, scroll_visible: bool = True) -> SprintPanel:
         """Delegate focus to the tree widget."""
         try:
             tree = self.query_one("#sprint-tree", Tree)

package/pennyfarthing_scripts/bikerack/story_detail_data.py

@@ -107,9 +107,12 @@ def _parse_session_file(session_path: str) -> dict[str, Any]:
 
 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(
-            ["pf", "sprint", "story", "field", story_id, "status"],
+            [sys.executable, "-m", "pennyfarthing_scripts.cli",
+             "sprint", "story", "field", story_id, "status"],
             capture_output=True,
             text=True,
             timeout=10,

package/pennyfarthing_scripts/bikerack/story_detail_screen.py

@@ -88,7 +88,8 @@ class StoryDetailScreen(Screen):
             name = _format_assignee(assignee)
             if name:
                 meta_parts.append(name)
-        header_text.append(f"\n{' \u00b7 '.join(meta_parts)}", style="dim")
+        separator = " \u00b7 "
+        header_text.append(f"\n{separator.join(meta_parts)}", style="dim")
         yield Static(header_text, id="dossier-header")
 
         # Context section (only if context files exist)