@pennyfarthing/core 11.3.2 → 11.3.4

package/pennyfarthing_scripts/bikerack/git_panel.py

@@ -1,139 +0,0 @@
-"""GitPanel — Multi-repo git status panel for BikeRack TUI.
-
-Story 103-10: Subscribes to /ws/git, renders multi-repo git status
-as Rich table with Nerd Font glyphs for branch and status indicators.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-from rich.text import Text
-
-from pennyfarthing_scripts.bikerack.base_panel import PANEL_ICONS, BasePanel
-
-
-def _file_breakdown(dirty_files: list[dict]) -> Text:
-    """Break down dirty files into +staged ~modified ?untracked counts."""
-    staged = 0
-    modified = 0
-    untracked = 0
-    for f in dirty_files:
-        if not isinstance(f, dict):
-            continue
-        status = f.get("status", "  ")
-        idx = status[0] if len(status) >= 1 else " "
-        wt = status[1] if len(status) >= 2 else " "
-        if idx == "?" and wt == "?":
-            untracked += 1
-        elif idx not in (" ", "?"):
-            staged += 1
-        elif wt not in (" ", "?"):
-            modified += 1
-
-    parts = Text()
-    parts.append(f"+{staged}", style="green")
-    parts.append(" ")
-    parts.append(f"~{modified}", style="yellow")
-    parts.append(" ")
-    parts.append(f"?{untracked}", style="dim")
-    return parts
-
-
-_FILE_STATUS_MAP: dict[str, tuple[str, str, str]] = {
-    "M": ("~", "Modified", "yellow"),
-    "A": ("+", "Added", "green"),
-    "D": ("-", "Deleted", "red"),
-    "?": ("?", "Untracked", "dim"),
-    "R": ("→", "Renamed", "cyan"),
-}
-
-
-def _parse_file_status(status: str) -> tuple[str, str, str]:
-    """Parse git status code into (icon, label, style)."""
-    if len(status) < 2:
-        return _FILE_STATUS_MAP.get(status[:1], ("·", "Changed", "yellow"))
-    idx, wt = status[0], status[1]
-    if idx == "?" and wt == "?":
-        return _FILE_STATUS_MAP["?"]
-    if idx not in (" ", "?"):
-        return _FILE_STATUS_MAP.get(idx, ("·", "Changed", "yellow"))
-    if wt not in (" ", "?"):
-        return _FILE_STATUS_MAP.get(wt, ("·", "Changed", "yellow"))
-    return ("·", "Changed", "yellow")
-
-
-class GitPanel(BasePanel):
-    """Multi-repo git status panel.
-
-    Subscribes to the ``git`` WebSocket channel and renders
-    git status for all configured repos as a Rich table with
-    columns: Repository, Branch, Commits, Changes, Status.
-    """
-
-    channel: str = "git"
-    panel_name: str = "Git"
-    icon: str = PANEL_ICONS["git"][0]
-
-    def render_panel(self, payload: dict[str, Any]) -> Any:
-        """Render git status as Rich Tree with expandable file lists."""
-        from rich.console import Group as RichGroup
-
-        repos = payload.get("repos", [])
-        if not repos:
-            return Text("No repository data", style="dim italic")
-
-        parts: list[Any] = []
-        for repo in repos:
-            branch = repo.get("branch", "")
-            ahead = repo.get("ahead", 0)
-            behind = repo.get("behind", 0)
-            clean = repo.get("clean", True)
-            dirty_files = repo.get("dirtyFiles", [])
-            name = repo.get("name", "")
-
-            # Build repo header line
-            header = Text()
-            arrow = "▼" if not clean and dirty_files else "▶"
-            header.append(f"{arrow} ", style="bold")
-            header.append(name, style="bold cyan")
-            header.append(f"  \ue0a0 {branch}", style="dim")
-
-            # Commits
-            commit_parts = []
-            if ahead:
-                commit_parts.append(f"↑{ahead}")
-            if behind:
-                commit_parts.append(f"↓{behind}")
-            header.append(f"  {' '.join(commit_parts) if commit_parts else '—'}", style="dim")
-
-            # File breakdown
-            header.append("  ")
-            header.append_text(_file_breakdown(dirty_files))
-
-            # Status
-            header.append("  ")
-            if clean:
-                header.append("✓ clean", style="green")
-            else:
-                header.append("✗ dirty", style="red")
-
-            parts.append(header)
-
-            # Expanded file list for dirty repos
-            if not clean and dirty_files:
-                for f in dirty_files:
-                    if not isinstance(f, dict):
-                        continue
-                    status_code = f.get("status", "  ")
-                    path = f.get("path", "")
-                    icon, label, style = _parse_file_status(status_code)
-                    file_line = Text()
-                    file_line.append("    ")
-                    file_line.append(icon, style=f"bold {style}")
-                    file_line.append(f" {path}", style=style)
-                    parts.append(file_line)
-
-            parts.append(Text(""))  # spacer
-
-        return RichGroup(*parts)

package/pennyfarthing_scripts/bikerack/launcher.py

@@ -1,240 +0,0 @@
-"""BikeRack launcher — core lifecycle functions.
-
-Story 101-5: BikeRack launcher CLI (pf bikerack start/stop/status)
-"""
-
-from __future__ import annotations
-
-import atexit
-import os
-import signal
-import subprocess
-import time
-from pathlib import Path
-from typing import NoReturn
-
-
-def is_process_alive(pid: int) -> bool:
-    """Check if a process with given PID is alive."""
-    try:
-        os.kill(pid, 0)
-        return True
-    except (ProcessLookupError, PermissionError, OSError):
-        return False
-
-
-def cleanup_files(project_dir: Path) -> None:
-    """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:
-            pass
-
-
-def read_port_file(project_dir: Path) -> int | None:
-    """Read port from .bikerack-port file. Returns None if not found."""
-    try:
-        return int((project_dir / ".bikerack-port").read_text().strip())
-    except (FileNotFoundError, ValueError):
-        return None
-
-
-def read_pid_file(project_dir: Path) -> int | None:
-    """Read PID from .wheelhub-pid file. Returns None if not found."""
-    try:
-        return int((project_dir / ".wheelhub-pid").read_text().strip())
-    except (FileNotFoundError, ValueError):
-        return None
-
-
-def write_pid_file(project_dir: Path, pid: int) -> None:
-    """Write .wheelhub-pid file."""
-    (project_dir / ".wheelhub-pid").write_text(str(pid))
-
-
-def build_otel_env(port: int) -> dict[str, str]:
-    """Build the 5 OTEL environment variables from discovered port (Rule 5)."""
-    return {
-        "CLAUDE_CODE_ENABLE_TELEMETRY": "1",
-        "OTEL_LOGS_EXPORTER": "otlp",
-        "OTEL_METRICS_EXPORTER": "otlp",
-        "OTEL_EXPORTER_OTLP_PROTOCOL": "http/json",
-        "OTEL_EXPORTER_OTLP_ENDPOINT": f"http://localhost:{port}",
-    }
-
-
-def resolve_project_dir(project_dir: str | None) -> Path:
-    """Resolve project directory from option → env var → cwd.
-
-    Used by bikerack and launch CLI commands.
-    """
-    if project_dir:
-        return Path(project_dir)
-    env = os.environ.get("CYCLIST_PROJECT_DIR")
-    if env:
-        return Path(env)
-    return Path.cwd()
-
-
-def _find_framework_dir() -> Path:
-    """Locate the pennyfarthing framework root from this package's location."""
-    # pennyfarthing_scripts/bikerack/launcher.py -> pennyfarthing/
-    return Path(__file__).resolve().parent.parent.parent
-
-
-def start_wheelhub(project_dir: Path) -> subprocess.Popen:
-    """Start WheelHub server in background with IS_BIKERACK=1."""
-    framework_dir = _find_framework_dir()
-    bikerack_entry = framework_dir / "packages" / "cyclist" / "dist" / "bikerack.js"
-
-    env = os.environ.copy()
-    env["IS_BIKERACK"] = "1"
-    env["CYCLIST_PROJECT_DIR"] = str(project_dir)
-
-    return subprocess.Popen(
-        ["node", str(bikerack_entry)],
-        env=env,
-        cwd=str(project_dir),
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-    )
-
-
-def poll_for_port_file(
-    project_dir: Path, timeout: float = 5.0, interval: float = 0.1
-) -> int:
-    """Poll for .bikerack-port file, return port number."""
-    port_file = project_dir / ".bikerack-port"
-    deadline = time.monotonic() + timeout
-
-    while True:
-        if port_file.exists():
-            return int(port_file.read_text().strip())
-        if time.monotonic() >= deadline:
-            raise TimeoutError(
-                f"Timed out waiting for {port_file} after {timeout}s"
-            )
-        time.sleep(interval)
-
-
-def register_cleanup(project_dir: Path, pid: int) -> None:
-    """Register atexit handler to kill WheelHub and clean up files (Rule 8)."""
-
-    def _cleanup(project_dir: Path, pid: int) -> None:
-        try:
-            os.kill(pid, signal.SIGTERM)
-        except (ProcessLookupError, OSError):
-            pass
-        cleanup_files(project_dir)
-
-    atexit.register(_cleanup, project_dir, pid)
-
-
-def exec_claude(otel_env: dict[str, str], project_dir: Path | None = None) -> NoReturn:
-    """Replace current process with Claude CLI using os.execvpe (CE-4)."""
-    env = os.environ.copy()
-    env.update(otel_env)
-    if project_dir:
-        os.chdir(project_dir)
-    os.execvpe("claude", ["claude"], env)
-
-
-def is_already_running(project_dir: Path) -> tuple[bool, int | None, int | None]:
-    """Check if BikeRack is already running.
-
-    Returns (is_running, pid_or_none, port_or_none).
-    Cleans up stale files if PID is dead.
-    """
-    pid = read_pid_file(project_dir)
-    port = read_port_file(project_dir)
-
-    if pid is None or port is None:
-        return (False, None, None)
-
-    if is_process_alive(pid):
-        return (True, pid, port)
-
-    cleanup_files(project_dir)
-    return (False, None, None)
-
-
-def stop_bikerack(project_dir: Path) -> dict:
-    """Stop running BikeRack instance and TUI. Returns {success, pid, message}."""
-    pid = read_pid_file(project_dir)
-
-    if pid is None:
-        return {"success": False, "message": "BikeRack is not running"}
-
-    if not is_process_alive(pid):
-        cleanup_files(project_dir)
-        return {"success": False, "message": "BikeRack is not running (stale PID)"}
-
-    os.kill(pid, signal.SIGTERM)
-
-    # Also kill TUI process if running
-    tui_pid = read_tui_pid_file(project_dir)
-    if tui_pid is not None:
-        try:
-            os.kill(tui_pid, signal.SIGTERM)
-        except (ProcessLookupError, OSError):
-            pass
-
-    cleanup_files(project_dir)
-    return {"success": True, "pid": pid, "message": f"Stopped BikeRack (PID {pid})"}
-
-
-def get_status(project_dir: Path) -> dict:
-    """Get BikeRack running status. Returns {running, pid, port, dashboard}."""
-    pid = read_pid_file(project_dir)
-    port = read_port_file(project_dir)
-
-    if pid is None or port is None:
-        return {"running": False}
-
-    if not is_process_alive(pid):
-        return {"running": False}
-
-    result = {
-        "running": True,
-        "pid": pid,
-        "port": port,
-        "dashboard": f"http://localhost:{port}/bikerack",
-        "tui_pid": read_tui_pid_file(project_dir),
-    }
-    return result
-
-
-# --- Story 103-3: TUI launcher functions ---
-
-
-def read_tui_pid_file(project_dir: Path) -> int | None:
-    """Read TUI PID from .wheelhub-gui-pid file. Returns None if not found."""
-    try:
-        return int((project_dir / ".wheelhub-gui-pid").read_text().strip())
-    except (FileNotFoundError, ValueError):
-        return None
-
-
-def write_tui_pid_file(project_dir: Path, pid: int) -> None:
-    """Write .wheelhub-gui-pid file."""
-    (project_dir / ".wheelhub-gui-pid").write_text(str(pid))
-
-
-def start_tui(project_dir: Path, port: int) -> subprocess.Popen:
-    """Start TUI as independent subprocess.
-
-    Uses start_new_session=True so TUI survives parent exit.
-    Writes .wheelhub-gui-pid for lifecycle tracking.
-    """
-    import sys
-
-    proc = subprocess.Popen(
-        [sys.executable, "-m", "pennyfarthing_scripts.bikerack.tui", "--port", str(port)],
-        cwd=str(project_dir),
-        start_new_session=True,
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-    )
-    write_tui_pid_file(project_dir, proc.pid)
-    return proc

package/pennyfarthing_scripts/bikerack/portrait_resolver.py

@@ -1,139 +0,0 @@
-"""Portrait path resolution for BikeRack TUI.
-
-Resolves persona portrait image paths using the canonical theme discovery
-from ``pennyfarthing_scripts.common.themes``.  Each theme directory that
-contains ``themes/{name}.yaml`` has a sibling ``portraits/{name}/`` with
-size-bucketed portrait images.
-
-Story 110-3: Portrait image header with textual-image.
-"""
-
-from __future__ import annotations
-
-import re
-from pathlib import Path
-
-import yaml
-
-
-def _to_slug(name: str) -> str:
-    """Convert a name to URL-safe slug (lowercase kebab-case)."""
-    return re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")
-
-
-def _extract_agent_slug(theme_yaml: Path, agent: str) -> str | None:
-    """Extract portrait slug (shortName-OCEAN) from a theme YAML file."""
-    if not theme_yaml.exists():
-        return None
-    try:
-        data = yaml.safe_load(theme_yaml.read_text())
-        agent_data = (data or {}).get("agents", {}).get(agent)
-        if not agent_data:
-            return None
-        short_name = agent_data.get("shortName") or (
-            agent_data.get("character", "").split()[0] if agent_data.get("character") else None
-        )
-        ocean = agent_data.get("ocean", {})
-        if short_name and all(k in ocean for k in "OCEAN"):
-            return f"{_to_slug(short_name)}-{ocean['O']}{ocean['C']}{ocean['E']}{ocean['A']}{ocean['N']}"
-    except Exception:
-        pass
-    return None
-
-
-def _find_portrait(portraits_theme_dir: Path, slug: str) -> Path | None:
-    """Find a portrait file matching the slug in a theme's portrait directory."""
-    if not portraits_theme_dir.is_dir():
-        return None
-    for size in ["medium", "large", "small", "original"]:
-        size_dir = portraits_theme_dir / size
-        if size_dir.is_dir():
-            for f in size_dir.iterdir():
-                if f.name.lower().startswith(slug.lower()) and f.suffix in (".png", ".jpg"):
-                    return f
-    # Fallback to root of theme dir
-    for f in portraits_theme_dir.iterdir():
-        if f.is_file() and f.name.lower().startswith(slug.lower()) and f.suffix in (".png", ".jpg"):
-            return f
-    return None
-
-
-def resolve_portrait_path(
-    theme: str, agent: str, project_root: Path | None = None
-) -> Path | None:
-    """Resolve the full path to a portrait image.
-
-    Uses ``discover_all_theme_dirs`` from ``common.themes`` to search core
-    themes, installed theme packages, monorepo workspace packages, and
-    custom themes — in canonical priority order.
-
-    For each theme directory the portrait sibling is derived:
-    - ``.pennyfarthing/personas/themes/`` → ``.pennyfarthing/personas/portraits/``
-    - ``themes-*/themes/`` → ``themes-*/portraits/``
-
-    Args:
-        theme: Theme name (e.g., 'hogans-heroes', 'monty-python')
-        agent: Agent role (e.g., 'sm', 'tea', 'dev')
-        project_root: Project root for path resolution. Defaults to cwd.
-
-    Returns:
-        Path to portrait file, or None if not found.
-    """
-    from pennyfarthing_scripts.common.themes import discover_all_theme_dirs
-
-    theme_dirs = discover_all_theme_dirs(project_root)
-
-    # Resolve slug from the first theme dir that has this theme's YAML
-    slug: str | None = None
-    for themes_dir in theme_dirs:
-        theme_yaml = themes_dir / f"{theme}.yaml"
-        slug = _extract_agent_slug(theme_yaml, agent)
-        if slug:
-            break
-
-    if not slug:
-        return None
-
-    # Search portrait directories (sibling of each themes dir)
-    for themes_dir in theme_dirs:
-        portraits_dir = themes_dir.parent / "portraits" / theme
-        result = _find_portrait(portraits_dir, slug)
-        if result:
-            return result
-
-    return None
-
-
-def detect_image_protocol() -> str | None:
-    """Detect the best available terminal image protocol.
-
-    Uses environment variables for reliable detection since subprocess
-    stdout may not be a TTY (e.g., when launched via Claude Code).
-
-    Returns:
-        Protocol name ('kitty', 'sixel', 'halfcell', None for unsupported).
-    """
-    import os
-
-    # Kitty: TERM=xterm-kitty or KITTY_WINDOW_ID present
-    term = os.environ.get("TERM", "")
-    if "kitty" in term or os.environ.get("KITTY_WINDOW_ID"):
-        return "kitty"
-
-    # Sixel: some terminals advertise via TERM or COLORTERM
-    # WezTerm, foot, mlterm support sixel
-    term_program = os.environ.get("TERM_PROGRAM", "")
-    if term_program.lower() in ("wezterm", "foot", "mlterm"):
-        return "sixel"
-
-    # Fallback: try textual-image's cell size probe for halfcell baseline
-    try:
-        from textual_image._terminal import get_cell_size
-
-        cell_size = get_cell_size()
-        if cell_size and cell_size.width > 0:
-            return "halfcell"
-    except Exception:
-        pass
-
-    return None