@pennyfarthing/core 11.2.0 → 11.2.1

package/pennyfarthing_scripts/bellmode_hook.py

@@ -1,309 +1,25 @@
-#!/usr/bin/env python3
 """
-PostToolUse Hook — Bell Mode + Tandem Injection (Python)
+Backward-compatibility shim — bell mode hook moved to hooks/bell_mode.py.
 
-Called by Claude Code after each tool execution. Handles two independent
-injection systems:
-
-1. Bell queue (Cyclist only) — injects queued user messages when Cyclist
-   is running and bell_mode is enabled. In CLI sessions this is a no-op.
-2. Tandem observations (always active) — injects backseat agent observations
-   when tandem observation files exist. No configuration required.
-
-Bell queue takes precedence: if a queued message exists, tandem is
-deferred to the next hook invocation.
-
-Story: MSSCI-12409 - Hook consistency and WheelHub consolidation
+This file will be removed in a future version.
 """
 
-import json
-import re
-import sys
-from pathlib import Path
-
-# Add parent directory to path for imports
-sys.path.insert(0, str(Path(__file__).parent))
-
-from hooks import (
-    CYCLIST_PORT_FILE,
-    HookResponse,
-    find_project_root,
-    is_bell_mode_enabled,
-    output_hook_response,
-    read_port_file,
-    send_to_cyclist,
+# 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,
+    main,
 )
 
 
-def read_bell_queue(project_root: Path) -> list[dict]:
-    """Read the bell message queue.
-
-    Args:
-        project_root: Project root directory
-
-    Returns:
-        List of queued messages, or empty list if none
-    """
-    queue_path = project_root / ".pennyfarthing" / "bell-queue.json"
-    if not queue_path.exists():
-        return []
-
-    try:
-        with open(queue_path) as f:
-            queue = json.load(f)
-            if isinstance(queue, list):
-                return queue
-    except (json.JSONDecodeError, OSError):
-        pass
-
-    return []
-
-
-def dequeue_message(project_root: Path) -> None:
-    """Remove the first message from the queue.
-
-    Args:
-        project_root: Project root directory
-    """
-    queue_path = project_root / ".pennyfarthing" / "bell-queue.json"
-    if not queue_path.exists():
-        return
-
-    try:
-        with open(queue_path) as f:
-            queue = json.load(f)
-
-        if isinstance(queue, list) and len(queue) > 0:
-            queue = queue[1:]  # Remove first item
-            with open(queue_path, "w") as f:
-                json.dump(queue, f)
-    except (json.JSONDecodeError, OSError):
-        pass
-
-
-def notify_cyclist(project_root: Path, message_text: str) -> None:
-    """Notify Cyclist browser that a queued message was consumed.
-
-    Args:
-        project_root: Project root directory
-        message_text: The message text that was consumed
-    """
-    try:
-        send_to_cyclist(
-            endpoint="/api/bell-consumed",
-            data={"text": message_text},
-            project_root=project_root,
-            timeout=5,
-        )
-    except Exception:
-        # Ignore errors - don't block hook
-        pass
-
-
-# =============================================================================
-# Tandem Observation Injection (Story 95-7 / MSSCI-14672)
-# =============================================================================
-# Stubs for tandem observation injection. Dev will implement.
-
-
-def read_tandem_observations(project_root: Path) -> list[Path]:
-    """Find tandem observation files in .session/ directory.
-
-    Looks for files matching .session/*-tandem-*.md pattern.
-
-    Args:
-        project_root: Project root directory
-
-    Returns:
-        List of Path objects for tandem observation files
-    """
-    session_dir = project_root / ".session"
-    if not session_dir.is_dir():
-        return []
-    return sorted(session_dir.glob("*-tandem-*.md"))
-
-
-def get_latest_observation(file_content: str) -> dict | None:
-    """Extract the latest observation entry from a tandem observation file.
-
-    Parses the markdown format to extract the most recent ## [HH:MM] Observation
-    block, including the observer persona name from the file header.
-
-    Args:
-        file_content: Full text content of the tandem observation file
-
-    Returns:
-        Dict with 'persona' and 'text' keys, or None if no observations found
-    """
-    # Extract persona from header: **Observer:** agent (Persona Name)
-    persona_match = re.search(r"\*\*Observer:\*\*\s*\w+\s*\(([^)]+)\)", file_content)
-    persona = persona_match.group(1) if persona_match else "Unknown"
-
-    # Split on observation headers: ## [HH:MM] Observation
-    entries = re.split(r"## \[\d{1,2}:\d{2}\] Observation\n", file_content)
-    if len(entries) < 2:
-        return None
-
-    # Last entry is the most recent observation
-    last_entry = entries[-1].strip()
-    # Remove trailing --- separator
-    last_entry = re.sub(r"\n---\s*$", "", last_entry).strip()
-    # Remove the **Trigger:** line
-    lines = last_entry.split("\n")
-    text_lines = [line for line in lines if not line.startswith("**Trigger:**")]
-    text = "\n".join(text_lines).strip()
-
-    if not text:
-        return None
-
-    return {"persona": persona, "text": text}
-
-
 def format_tandem_message(persona_name: str, observation_text: str) -> str:
-    """Format a tandem observation as a bell mode injection message.
-
-    Args:
-        persona_name: The backseat agent's persona name
-        observation_text: The observation summary text
-
-    Returns:
-        Formatted string: [Tandem] {persona_name}: {observation_text}
-    """
+    """Format a tandem observation as a bell mode injection message."""
     return f"[Tandem] {persona_name}: {observation_text}"
 
 
-def get_tandem_mtime(project_root: Path, agent: str) -> float:
-    """Read the last-checked mtime for a tandem agent's observation file.
-
-    Args:
-        project_root: Project root directory
-        agent: Agent name (e.g. 'reviewer', 'tea')
-
-    Returns:
-        Last-checked mtime as float, or 0.0 if no sidecar exists
-    """
-    sidecar = project_root / ".session" / f".tandem-mtime-{agent}"
-    if not sidecar.exists():
-        return 0.0
-    try:
-        return float(sidecar.read_text().strip())
-    except (ValueError, OSError):
-        return 0.0
-
-
-def save_tandem_mtime(project_root: Path, agent: str, mtime: float) -> None:
-    """Save the mtime for a tandem agent's observation file.
-
-    Writes to .session/.tandem-mtime-{agent} sidecar file.
-
-    Args:
-        project_root: Project root directory
-        agent: Agent name (e.g. 'reviewer', 'tea')
-        mtime: The mtime value to save
-    """
-    sidecar = project_root / ".session" / f".tandem-mtime-{agent}"
-    try:
-        sidecar.write_text(str(mtime))
-    except OSError:
-        pass
-
-
-def check_tandem_files(project_root: Path) -> list[dict]:
-    """Check for new tandem observations and return injection messages.
-
-    Main entry point for tandem injection in the PostToolUse hook.
-    Always active — no configuration required. The presence of tandem
-    observation files in .session/ is the only signal needed.
-
-    Args:
-        project_root: Project root directory
-
-    Returns:
-        List of dicts with 'agent', 'message' keys for each new observation
-    """
-    tandem_files = read_tandem_observations(project_root)
-    if not tandem_files:
-        return []
-
-    results = []
-    for obs_file in tandem_files:
-        # Extract agent name from filename: *-tandem-{agent}.md
-        agent_match = re.search(r"-tandem-(\w+)\.md$", obs_file.name)
-        if not agent_match:
-            continue
-        agent = agent_match.group(1)
-
-        # Compare mtime
-        try:
-            file_mtime = obs_file.stat().st_mtime
-        except OSError:
-            continue
-        saved_mtime = get_tandem_mtime(project_root, agent)
-        if file_mtime == saved_mtime:
-            continue
-
-        # Read and parse
-        try:
-            content = obs_file.read_text()
-        except OSError:
-            continue
-        obs = get_latest_observation(content)
-        if not obs:
-            # Update mtime even for unparseable files to avoid re-checking
-            save_tandem_mtime(project_root, agent, file_mtime)
-            continue
-
-        message = format_tandem_message(obs["persona"], obs["text"])
-        results.append({"agent": agent, "message": message})
-
-        # Update mtime sidecar
-        save_tandem_mtime(project_root, agent, file_mtime)
-
-    return results
-
-
-def main() -> None:
-    """Main entry point for PostToolUse hook."""
-    try:
-        # Read and discard stdin (required by hook protocol)
-        sys.stdin.read()
-
-        # Find project root
-        project_root = find_project_root()
-        if not project_root:
-            sys.exit(0)
-
-        # --- Bell queue (Cyclist only, requires bell_mode: true) ---
-        # Takes precedence over tandem when active.
-        is_cyclist = read_port_file(CYCLIST_PORT_FILE, project_root) is not None
-        if is_cyclist and is_bell_mode_enabled(project_root):
-            queue = read_bell_queue(project_root)
-            if queue:
-                first_message = queue[0]
-                message_text = first_message.get("text", "")
-                if message_text:
-                    output_hook_response(HookResponse(
-                        event_name="PostToolUse",
-                        additional_context=f"User feedback: {message_text}",
-                    ))
-                    dequeue_message(project_root)
-                    notify_cyclist(project_root, message_text)
-                    sys.exit(0)
-
-        # --- Tandem observations (always active, no config required) ---
-        tandem_results = check_tandem_files(project_root)
-        if tandem_results:
-            output_hook_response(HookResponse(
-                event_name="PostToolUse",
-                additional_context=tandem_results[0]["message"],
-            ))
-
-        sys.exit(0)
-
-    except Exception as e:
-        print(f"[bellmode-hook] Error: {e}", file=sys.stderr)
-        sys.exit(0)
-
-
 if __name__ == "__main__":
     main()

package/pennyfarthing_scripts/bikerack/audit_log_panel.py

@@ -0,0 +1,119 @@
+"""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 datetime, timezone
+from typing import Any
+
+from rich.console import Console
+from textual._context import NoActiveAppError
+from textual.widgets import DataTable
+
+from pennyfarthing_scripts.bikerack.base_panel import PANEL_ICONS, BasePanel
+
+MAX_INPUT_LENGTH = 80
+
+# 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.
+
+        Overrides BasePanel.handle_message to manipulate DataTable directly
+        instead of going through render_panel/post_message.
+        """
+        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)
+
+    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:
+        """Not used — handle_message manages DataTable directly."""
+        return self._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=timezone.utc)
+        return dt.strftime("%H:%M:%S")
+    except (ValueError, TypeError, OSError):
+        return "\u2014"

package/pennyfarthing_scripts/bikerack/base_panel.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 from typing import Any
 
 from rich.text import Text
+from textual.message import Message
 from textual.widgets import Static
 
 # Nerd Font icon registry: panel_name → (nerd_font_icon, ascii_fallback)
@@ -46,7 +47,12 @@ def get_panel_icon(panel_name: str, use_nerd_font: bool = True) -> str:
     return entry[0] if use_nerd_font else entry[1]
 
 
-def render_progress_bar(percent: int | float, width: int = 20, warn_high: bool = False) -> Text:
+def render_progress_bar(
+    percent: int | float,
+    width: int = 20,
+    warn_high: bool = False,
+    fill_style: str | None = None,
+) -> Text:
     """Render a Unicode progress bar with color based on percentage.
 
     Args:
@@ -54,6 +60,7 @@ def render_progress_bar(percent: int | float, width: int = 20, warn_high: bool =
         width: Number of bar characters (default 20).
         warn_high: If True, use red at high values (for resource usage).
                    If False (default), use blue at 100% (for completion).
+        fill_style: Override the computed fill color (e.g. ``"dim green"``).
 
     Returns:
         Rich Text like ``[████████░░░░░░░░░░░░] 22%``
@@ -62,7 +69,9 @@ def render_progress_bar(percent: int | float, width: int = 20, warn_high: bool =
     filled = round(width * percent / 100)
     empty = width - filled
 
-    if warn_high:
+    if fill_style is not None:
+        style = fill_style
+    elif warn_high:
         if percent < 50:
             style = "green"
         elif percent <= 80:
@@ -113,6 +122,13 @@ class BasePanel(Static):
     ``render_panel(payload)`` to return a Rich renderable.
     """
 
+    class DataReceived(Message, bubble=False):
+        """WebSocket data received — routed through Textual message system."""
+
+        def __init__(self, content: Any) -> None:
+            super().__init__()
+            self.content = content
+
     #: WebSocket channel this panel subscribes to (override in subclass)
     channel: str = ""
 
@@ -138,10 +154,17 @@ class BasePanel(Static):
         """Mark panel as unmounted — messages ignored after this."""
         self._mounted = False
 
+    def on_base_panel_data_received(self, event: DataReceived) -> None:
+        """Process DataReceived in Textual message context — triggers repaint."""
+        self.update(event.content)
+
     def handle_message(self, message: dict[str, Any] | None) -> None:
         """Handle incoming WebSocket message.
 
-        Stores payload, calls render_panel, updates widget display.
+        Stores payload, calls render_panel, posts DataReceived message.
+        Uses post_message to route through Textual's message system,
+        ensuring proper repaint cycle (call_from_thread / direct update
+        from async WS tasks does not reliably trigger redraws).
         No-op after unmount or if message is None.
         """
         if not self._mounted or message is None:
@@ -149,7 +172,7 @@ class BasePanel(Static):
         self._last_payload = message
         rendered = self.render_panel(message)
         try:
-            self.update(rendered)
+            self.post_message(self.DataReceived(rendered))
         except Exception:
             pass