@pennyfarthing/core 11.3.2 → 11.3.4

package/pennyfarthing_scripts/bc/focus.py

@@ -1,334 +0,0 @@
-"""Panel focus management — read/write focus key in config.local.yaml.
-
-Story 104-1: pf bc CLI command + /bc user skill
-Story 104-4: Save and clear named layouts via /bc
-Epic: 104 — /bc CLI Panel Focus
-"""
-
-from __future__ import annotations
-
-import io
-import re
-from pathlib import Path
-
-from ruamel.yaml import YAML
-
-
-def _get_root() -> Path:
-    """Get project root, falling back to cwd."""
-    try:
-        from pennyfarthing_scripts.common.config import get_project_root
-
-        return get_project_root()
-    except Exception:
-        return Path.cwd()
-
-VALID_PANELS = [
-    "sprint",
-    "git",
-    "diffs",
-    "todo",
-    "workflow",
-    "background",
-    "audit-log",
-    "changed",
-    "ac",
-    "debug",
-    "progress",
-    "settings",
-    "tty",
-]
-
-
-def set_panel_focus(panel_name: str, project_dir: Path | None = None) -> dict:
-    """Set focus panel in config.local.yaml.
-
-    Args:
-        panel_name: Panel to focus on (must be in VALID_PANELS)
-        project_dir: Override project root (for testing)
-
-    Returns:
-        {success: bool, data?: str, error?: str}
-    """
-    if panel_name not in VALID_PANELS:
-        return {
-            "success": False,
-            "error": f"Invalid panel '{panel_name}'. Valid panels: {', '.join(VALID_PANELS)}",
-        }
-
-    try:
-        config_path, config = _read_config(project_dir)
-        if config is None:
-            return {"success": False, "error": "Config is not a YAML mapping"}
-        config["focus"] = panel_name
-        _write_config(config_path, config)
-        return {"success": True, "data": panel_name}
-    except Exception as exc:
-        return {"success": False, "error": str(exc)}
-
-
-def clear_panel_focus(project_dir: Path | None = None) -> dict:
-    """Clear focus setting from config.local.yaml.
-
-    Args:
-        project_dir: Override project root (for testing)
-
-    Returns:
-        {success: bool, message?: str, error?: str}
-    """
-    try:
-        root = project_dir or _get_root()
-        config_path = root / ".pennyfarthing" / "config.local.yaml"
-
-        if not config_path.exists():
-            return {"success": True, "message": "No focus setting to clear"}
-
-        config_path, config = _read_config(project_dir)
-        if config is None:
-            config = _make_yaml().load("{}")
-        if "focus" in config:
-            del config["focus"]
-        _write_config(config_path, config)
-
-        return {"success": True, "message": "focus cleared"}
-    except Exception as exc:
-        return {"success": False, "error": str(exc)}
-
-
-LAYOUT_NAME_PATTERN = re.compile(r"^[a-zA-Z0-9_]+$")
-
-
-def _make_yaml() -> YAML:
-    """Create a configured ruamel.yaml instance that preserves formatting."""
-    yml = YAML()
-    yml.preserve_quotes = True
-    yml.default_flow_style = False
-    yml.width = 4096
-    yml.indent(mapping=2, sequence=4, offset=2)
-    return yml
-
-
-def _read_config(project_dir: Path | None = None):
-    """Read config.local.yaml using ruamel.yaml to preserve formatting.
-
-    Returns:
-        (config_path, config) where config is a CommentedMap or None if invalid.
-    """
-    root = project_dir or _get_root()
-    config_path = root / ".pennyfarthing" / "config.local.yaml"
-    yml = _make_yaml()
-    if config_path.exists():
-        config = yml.load(config_path.read_text())
-        if config is None:
-            config = yml.load("{}")
-        return config_path, config
-    return config_path, yml.load("{}")
-
-
-def _write_config(config_path: Path, config) -> None:
-    """Write config to YAML file, preserving formatting via ruamel.yaml."""
-    config_path.parent.mkdir(parents=True, exist_ok=True)
-    yml = _make_yaml()
-    stream = io.StringIO()
-    yml.dump(config, stream)
-    config_path.write_text(stream.getvalue())
-
-
-def validate_layout_name(name: str) -> bool:
-    """Validate a layout name (alphanumeric + underscore only).
-
-    Args:
-        name: Layout name to validate
-
-    Returns:
-        True if valid, False otherwise
-    """
-    return bool(LAYOUT_NAME_PATTERN.match(name))
-
-
-def save_named_layout(
-    name: str, layout_data: dict, project_dir: Path | None = None
-) -> dict:
-    """Save a named layout to config.local.yaml.
-
-    Args:
-        name: Layout name (must match LAYOUT_NAME_PATTERN)
-        layout_data: Serialized dockview layout
-        project_dir: Override project root (for testing)
-
-    Returns:
-        {success: bool, data?: str, error?: str}
-    """
-    if not validate_layout_name(name):
-        return {"success": False, "error": f"Invalid layout name '{name}'"}
-    try:
-        config_path, config = _read_config(project_dir)
-        if "layouts" not in config or not isinstance(config.get("layouts"), dict):
-            config["layouts"] = {}
-        config["layouts"][name] = layout_data
-        _write_config(config_path, config)
-        return {"success": True, "data": name}
-    except Exception as exc:
-        return {"success": False, "error": str(exc)}
-
-
-def load_named_layout(name: str, project_dir: Path | None = None) -> dict:
-    """Load a named layout from config.local.yaml.
-
-    Args:
-        name: Layout name to load
-        project_dir: Override project root (for testing)
-
-    Returns:
-        {success: bool, data?: dict, error?: str}
-    """
-    if not validate_layout_name(name):
-        return {"success": False, "error": f"Invalid layout name '{name}'"}
-    try:
-        _, config = _read_config(project_dir)
-        layouts = config.get("layouts")
-        if not isinstance(layouts, dict) or name not in layouts:
-            return {"success": False, "error": f"Layout '{name}' not found"}
-        return {"success": True, "data": layouts[name]}
-    except Exception as exc:
-        return {"success": False, "error": str(exc)}
-
-
-def list_named_layouts(project_dir: Path | None = None) -> dict:
-    """List all saved named layouts.
-
-    Args:
-        project_dir: Override project root (for testing)
-
-    Returns:
-        {success: bool, data?: list[str], error?: str}
-    """
-    try:
-        _, config = _read_config(project_dir)
-        layouts = config.get("layouts")
-        if not isinstance(layouts, dict):
-            return {"success": True, "data": []}
-        return {"success": True, "data": list(layouts.keys())}
-    except Exception as exc:
-        return {"success": False, "error": str(exc)}
-
-
-def clear_named_layout(name: str, project_dir: Path | None = None) -> dict:
-    """Delete a specific named layout from config.local.yaml.
-
-    Args:
-        name: Layout name to delete
-        project_dir: Override project root (for testing)
-
-    Returns:
-        {success: bool, message?: str, error?: str}
-    """
-    if not validate_layout_name(name):
-        return {"success": False, "error": f"Invalid layout name '{name}'"}
-    try:
-        config_path, config = _read_config(project_dir)
-        layouts = config.get("layouts")
-        if not isinstance(layouts, dict) or name not in layouts:
-            return {"success": False, "error": f"Layout '{name}' not found"}
-        del config["layouts"][name]
-        _write_config(config_path, config)
-        return {"success": True, "message": f"Layout '{name}' cleared"}
-    except Exception as exc:
-        return {"success": False, "error": str(exc)}
-
-
-def clear_all_named_layouts(project_dir: Path | None = None) -> dict:
-    """Delete all named layouts from config.local.yaml.
-
-    Args:
-        project_dir: Override project root (for testing)
-
-    Returns:
-        {success: bool, message?: str, error?: str}
-    """
-    try:
-        config_path, config = _read_config(project_dir)
-        config.pop("layouts", None)
-        _write_config(config_path, config)
-        return {"success": True, "message": "All layouts cleared"}
-    except Exception as exc:
-        return {"success": False, "error": str(exc)}
-
-
-def get_last_panel(project_dir: Path | None = None) -> dict:
-    """Read last_panel from config.local.yaml.
-
-    Story 103-8: Panel persistence — single source of truth for last-viewed
-    panel, shared between ERB and TUI.
-
-    Args:
-        project_dir: Override project root (for testing)
-
-    Returns:
-        {success: bool, last_panel?: str|None, error?: str}
-    """
-    try:
-        _, config = _read_config(project_dir)
-        last_panel = config.get("last_panel") if config else None
-        if last_panel is not None and last_panel not in VALID_PANELS:
-            return {"success": True, "last_panel": None}
-        return {"success": True, "last_panel": last_panel}
-    except Exception:
-        return {"success": True, "last_panel": None}
-
-
-def save_last_panel(panel_name: str, project_dir: Path | None = None) -> dict:
-    """Save last_panel to config.local.yaml.
-
-    Story 103-8: Panel persistence — persists the active panel so it can
-    be restored on next launch. Shared between ERB and TUI.
-
-    Args:
-        panel_name: Panel ID to persist (must be in VALID_PANELS)
-        project_dir: Override project root (for testing)
-
-    Returns:
-        {success: bool, data?: str, error?: str}
-    """
-    if panel_name not in VALID_PANELS:
-        return {
-            "success": False,
-            "error": f"Invalid panel '{panel_name}'. Valid panels: {', '.join(VALID_PANELS)}",
-        }
-
-    try:
-        config_path, config = _read_config(project_dir)
-        if config is None:
-            config = _make_yaml().load("{}")
-        config["last_panel"] = panel_name
-        _write_config(config_path, config)
-        return {"success": True, "data": panel_name}
-    except Exception as exc:
-        return {"success": False, "error": str(exc)}
-
-
-def get_panel_focus(project_dir: Path | None = None) -> dict:
-    """Read current focus setting from config.local.yaml.
-
-    Args:
-        project_dir: Override project root (for testing)
-
-    Returns:
-        {success: bool, focus?: str|None, error?: str}
-    """
-    try:
-        root = project_dir or _get_root()
-        config_path = root / ".pennyfarthing" / "config.local.yaml"
-
-        if not config_path.exists():
-            return {"success": True, "focus": None}
-
-        try:
-            _, config = _read_config(project_dir)
-            if config is not None:
-                return {"success": True, "focus": config.get("focus")}
-            return {"success": True, "focus": None}
-        except Exception:
-            return {"success": True, "focus": None}
-    except Exception as exc:
-        return {"success": False, "error": str(exc)}

package/pennyfarthing_scripts/bc/split.py

@@ -1,52 +0,0 @@
-"""Split layout management — read/write split config in config.local.yaml.
-
-Story 110-4: /bc split <left> <right> command support.
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-
-from pennyfarthing_scripts.bc.focus import (
-    VALID_PANELS,
-    _read_config,
-    _write_config,
-)
-
-
-def set_split_layout(
-    left: str, right: str, project_dir: Path | None = None
-) -> dict:
-    """Set split layout in config.local.yaml.
-
-    Args:
-        left: Panel for left pane (must be in VALID_PANELS).
-        right: Panel for right pane (must be in VALID_PANELS).
-        project_dir: Override project root (for testing).
-
-    Returns:
-        {success: bool, data?: dict, error?: str}
-    """
-    if left not in VALID_PANELS:
-        return {
-            "success": False,
-            "error": f"Invalid panel '{left}'. Valid panels: {', '.join(VALID_PANELS)}",
-        }
-    if right not in VALID_PANELS:
-        return {
-            "success": False,
-            "error": f"Invalid panel '{right}'. Valid panels: {', '.join(VALID_PANELS)}",
-        }
-    if left == right:
-        return {
-            "success": False,
-            "error": f"Left and right panels must be different (both are '{left}'). Use same panel in single mode instead.",
-        }
-
-    try:
-        config_path, config = _read_config(project_dir)
-        config["split"] = {"left": left, "right": right}
-        _write_config(config_path, config)
-        return {"success": True, "data": {"left": left, "right": right}}
-    except Exception as exc:
-        return {"success": False, "error": str(exc)}

package/pennyfarthing_scripts/bellmode_hook.py

@@ -1,22 +0,0 @@
-"""
-Backward-compatibility shim — bell mode hook moved to hooks/bell_mode.py.
-
-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,
-)
-from pennyfarthing_scripts.hooks.bell_mode import (
-    main,
-)
-
-
-def format_tandem_message(persona_name: str, observation_text: str) -> str:
-    """Format a tandem observation as a bell mode injection message."""
-    return f"[Tandem] {persona_name}: {observation_text}"
-
-
-if __name__ == "__main__":
-    main()

package/pennyfarthing_scripts/bikerack/__init__.py

@@ -1,44 +0,0 @@
-"""BikeRack Mode — Decoupled WheelHub launcher for CLI-first developers.
-
-Story 101-5: BikeRack launcher CLI (pf bikerack start/stop/status)
-"""
-
-from pennyfarthing_scripts.bikerack.launcher import (
-    build_otel_env,
-    cleanup_files,
-    exec_claude,
-    get_status,
-    is_already_running,
-    is_process_alive,
-    poll_for_port_file,
-    read_pid_file,
-    read_port_file,
-    read_tui_pid_file,
-    register_cleanup,
-    resolve_project_dir,
-    start_tui,
-    start_wheelhub,
-    stop_bikerack,
-    write_pid_file,
-    write_tui_pid_file,
-)
-
-__all__ = [
-    "build_otel_env",
-    "cleanup_files",
-    "exec_claude",
-    "get_status",
-    "is_already_running",
-    "is_process_alive",
-    "poll_for_port_file",
-    "read_pid_file",
-    "read_port_file",
-    "read_tui_pid_file",
-    "register_cleanup",
-    "resolve_project_dir",
-    "start_tui",
-    "start_wheelhub",
-    "stop_bikerack",
-    "write_pid_file",
-    "write_tui_pid_file",
-]

package/pennyfarthing_scripts/bikerack/__main__.py

@@ -1,5 +0,0 @@
-"""Entry point for python -m pennyfarthing_scripts.bikerack."""
-
-from pennyfarthing_scripts.bikerack.cli import bikerack
-
-bikerack()

package/pennyfarthing_scripts/bikerack/audit_log_panel.py

@@ -1,161 +0,0 @@
-"""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 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()
-
-
-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"