@pennyfarthing/core 11.3.2 → 11.3.4

package/pennyfarthing_scripts/bikerack/background_panel.py

@@ -1,162 +0,0 @@
-"""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 pennyfarthing_scripts.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_scripts/bikerack/changed_panel.py

@@ -1,201 +0,0 @@
-"""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 pennyfarthing_scripts.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 pennyfarthing_scripts.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)

package/pennyfarthing_scripts/bikerack/cli.py

@@ -1,145 +0,0 @@
-"""BikeRack CLI — Click-based CLI for bikerack operations.
-
-Usage:
-    pf bikerack [COMMAND]
-
-Commands:
-    start   Start BikeRack mode (default)
-    stop    Stop running BikeRack instance
-    status  Show running state
-"""
-
-import sys
-
-import click
-
-
-@click.group(invoke_without_command=True)
-@click.pass_context
-def bikerack(ctx):
-    """BikeRack Mode — Decoupled WheelHub dashboard launcher.
-
-    \b
-    Commands:
-      start   - Start WheelHub + Claude CLI (default)
-      stop    - Stop running BikeRack instance
-      status  - Show running state (PID, port, uptime)
-    """
-    if ctx.invoked_subcommand is None:
-        ctx.invoke(start)
-
-
-@bikerack.command()
-@click.option(
-    "--project-dir",
-    type=click.Path(exists=True, file_okay=False, resolve_path=True),
-    default=None,
-    help="Project directory (where .pennyfarthing/ lives). Falls back to CYCLIST_PROJECT_DIR env var, then cwd.",
-)
-@click.option("--dry-run", is_flag=True, help="Show what would be done without making changes")
-def start(project_dir, dry_run):
-    """Start BikeRack mode.
-
-    Starts WheelHub in background, waits for readiness,
-    sets OTEL env vars, and execs Claude CLI.
-    """
-    from pennyfarthing_scripts.bikerack.launcher import (
-        build_otel_env,
-        exec_claude,
-        is_already_running,
-        poll_for_port_file,
-        register_cleanup,
-        resolve_project_dir,
-        start_wheelhub,
-        write_pid_file,
-    )
-
-    project_dir = resolve_project_dir(project_dir)
-
-    if dry_run:
-        click.echo("[DRY-RUN] Would start BikeRack mode")
-        click.echo(f"  Project: {project_dir}")
-        click.echo("  Actions: start WheelHub, set OTEL env, exec Claude CLI")
-        return
-
-    running, pid, port = is_already_running(project_dir)
-    if running:
-        # Idempotent: WheelHub already up, just exec Claude with OTEL env
-        click.echo(f"BikeRack already running (PID {pid}, port {port})")
-        otel_env = build_otel_env(port)
-        click.echo(f"Dashboard: http://localhost:{port}/bikerack")
-        click.echo("Starting Claude CLI...")
-        exec_claude(otel_env, project_dir)
-
-    click.echo("Starting BikeRack mode...")
-    try:
-        proc = start_wheelhub(project_dir)
-        write_pid_file(project_dir, proc.pid)
-
-        port = poll_for_port_file(project_dir)
-        click.echo(f"WheelHub listening on http://localhost:{port}")
-
-        otel_env = build_otel_env(port)
-        click.echo("Setting OTEL environment variables...")
-
-        register_cleanup(project_dir, proc.pid)
-
-        click.echo(f"Dashboard: http://localhost:{port}/bikerack")
-        click.echo("Starting Claude CLI...")
-        exec_claude(otel_env, project_dir)
-    except TimeoutError as e:
-        click.echo(f"Error: {e}", err=True)
-        sys.exit(1)
-    except Exception as e:
-        click.echo(f"Error: {e}", err=True)
-        sys.exit(1)
-
-
-@bikerack.command()
-@click.option(
-    "--project-dir",
-    type=click.Path(exists=True, file_okay=False, resolve_path=True),
-    default=None,
-    help="Project directory. Falls back to CYCLIST_PROJECT_DIR env var, then cwd.",
-)
-@click.option("--dry-run", is_flag=True, help="Show what would be done without making changes")
-def stop(project_dir, dry_run):
-    """Stop running BikeRack instance."""
-    from pennyfarthing_scripts.bikerack.launcher import resolve_project_dir, stop_bikerack
-
-    project_dir = resolve_project_dir(project_dir)
-
-    if dry_run:
-        click.echo("[DRY-RUN] Would stop BikeRack instance")
-        click.echo(f"  Project: {project_dir}")
-        return
-
-    result = stop_bikerack(project_dir)
-
-    click.echo(result["message"])
-    if not result["success"]:
-        # "Not running" is not an error for stop — idempotent
-        sys.exit(0)
-
-
-@bikerack.command()
-@click.option(
-    "--project-dir",
-    type=click.Path(exists=True, file_okay=False, resolve_path=True),
-    default=None,
-    help="Project directory. Falls back to CYCLIST_PROJECT_DIR env var, then cwd.",
-)
-def status(project_dir):
-    """Show BikeRack running state."""
-    from pennyfarthing_scripts.bikerack.launcher import get_status, resolve_project_dir
-
-    project_dir = resolve_project_dir(project_dir)
-    result = get_status(project_dir)
-
-    if result["running"]:
-        click.echo("BikeRack is running")
-        click.echo(f"  PID: {result['pid']}")
-        click.echo(f"  Port: {result['port']}")
-        click.echo(f"  Dashboard: {result['dashboard']}")
-    else:
-        click.echo("BikeRack is not running")

package/pennyfarthing_scripts/bikerack/context_meter_footer.py

@@ -1,138 +0,0 @@
-"""ContextMeterFooter — Persistent context usage footer bar for BikeRack TUI.
-
-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
-from textual.message import Message
-from textual.widgets import Static
-
-from pennyfarthing_scripts.bikerack.base_panel import render_progress_bar
-
-
-class ContextMeterFooter(Static):
-    """Persistent footer bar showing context window usage.
-
-    Not a Footer subclass — this is a Static widget mounted between
-    #main-content and BindingFooter in the app layout.
-    """
-
-    class MeterUpdate(Message, bubble=False):
-        """Context meter data received — routed through Textual message system."""
-
-        def __init__(self, content: Any) -> None:
-            super().__init__()
-            self.content = content
-
-    #: 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 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:
-        """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 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))
-        except Exception:
-            pass
-
-    def render_meter(self, ctx: dict[str, Any]) -> Text:
-        """Render a compact context usage bar with percentage and tier badge."""
-        percent = ctx.get("percent", 0)
-        tier = ctx.get("tier", "")
-
-        bar = render_progress_bar(percent, warn_high=True)
-
-        if tier:
-            if percent < 50:
-                tier_style = "green"
-            elif percent <= 80:
-                tier_style = "yellow"
-            else:
-                tier_style = "red"
-            bar.append(f" {tier}", style=f"bold {tier_style}")
-
-        return bar