@pennyfarthing/core 11.4.0 → 12.0.0

package/pennyfarthing-dist/src/pf/bikerack/layout_order.py

@@ -0,0 +1,84 @@
+"""Layout order configuration for BikeRack TUI.
+
+Story 120-10: Customizable bar layout ordering (menu/profile/content/status).
+
+Validates and resolves the layout_order setting from config.local.yaml.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+# The four layout regions in their default order
+VALID_REGIONS = frozenset({"menu", "profile", "content", "status"})
+DEFAULT_ORDER: list[str] = ["menu", "profile", "content", "status"]
+
+# Maps region name → workflow config toggle key
+_BAR_TOGGLE_MAP: dict[str, str] = {
+    "status": "statusbar",
+    "profile": "profile_bar",
+    "menu": "menu_bar",
+}
+
+
+def validate_layout_order(order: Any) -> dict[str, Any]:
+    """Validate a layout_order setting.
+
+    Args:
+        order: The layout_order value from config (should be a list of 4 region strings).
+
+    Returns:
+        Result dict: {success: bool, error?: str}
+    """
+    if not isinstance(order, list):
+        return {"success": False, "error": "layout_order must be a list"}
+    if len(order) != 4:
+        return {
+            "success": False,
+            "error": f"layout_order must have exactly 4 regions, got {len(order)}",
+        }
+    if len(set(order)) != len(order):
+        return {"success": False, "error": "layout_order contains duplicate regions"}
+    if set(order) != VALID_REGIONS:
+        unknown = set(order) - VALID_REGIONS
+        if unknown:
+            return {
+                "success": False,
+                "error": f"Unknown regions: {', '.join(sorted(unknown))}",
+            }
+        missing = VALID_REGIONS - set(order)
+        return {
+            "success": False,
+            "error": f"Missing regions: {', '.join(sorted(missing))}",
+        }
+    return {"success": True}
+
+
+def get_layout_order(config: dict[str, Any]) -> list[str]:
+    """Resolve the effective layout order from config.
+
+    Reads ``layout_order`` from *config*, validates it, and filters out
+    any bars disabled via ``workflow.<toggle>`` settings.
+
+    Args:
+        config: The full pennyfarthing config dict.
+
+    Returns:
+        Ordered list of region names to render.
+    """
+    raw = config.get("layout_order")
+    if raw is not None and validate_layout_order(raw)["success"]:
+        order = list(raw)
+    else:
+        order = list(DEFAULT_ORDER)
+
+    workflow = config.get("workflow") or {}
+    return [r for r in order if _is_bar_enabled(r, workflow)]
+
+
+def _is_bar_enabled(region: str, workflow: dict[str, Any]) -> bool:
+    """Check whether a bar region is enabled in the workflow config."""
+    toggle_key = _BAR_TOGGLE_MAP.get(region)
+    if toggle_key is None:
+        return True  # content has no toggle — always enabled
+    return workflow.get(toggle_key, True)

package/pennyfarthing-dist/src/pf/bikerack/portrait_resolver.py

@@ -0,0 +1,191 @@
+"""Portrait path resolution for BikeRack TUI.
+
+Resolves persona portrait image paths using the canonical theme discovery
+from ``pf.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 _is_lfs_pointer(path: Path) -> bool:
+    """Check if a file is a git-lfs pointer instead of actual image data."""
+    try:
+        with open(path, "rb") as f:
+            header = f.read(44)
+        return header.startswith(b"version https://git-lfs")
+    except OSError:
+        return False
+
+
+def _find_portrait(
+    portraits_theme_dir: Path, slug: str, preferred_size: str | None = None
+) -> Path | None:
+    """Find a portrait file matching the slug in a theme's portrait directory.
+
+    Args:
+        portraits_theme_dir: Path to the theme's portrait directory.
+        slug: Portrait slug (shortName-OCEAN).
+        preferred_size: Preferred size bucket. ``"large"`` or ``"medium"``
+            searches large first; ``"small"`` searches small first.
+            ``None`` keeps the default order (medium first).
+    """
+    if not portraits_theme_dir.is_dir():
+        return None
+    if preferred_size == "small":
+        size_order = ["small", "medium", "large", "original"]
+    elif preferred_size in ("large", "medium"):
+        size_order = ["large", "medium", "small", "original"]
+    else:
+        size_order = ["medium", "large", "small", "original"]
+    for size in size_order:
+        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"):
+                    if not _is_lfs_pointer(f):
+                        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"):
+            if not _is_lfs_pointer(f):
+                return f
+    return None
+
+
+def resolve_portrait_path(
+    theme: str,
+    agent: str,
+    project_root: Path | None = None,
+    preferred_size: str | 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 pf.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, preferred_size=preferred_size)
+        if result:
+            return result
+
+    # Fallback: search Cyclist package portrait directories
+    # Portraits are bundled in @pennyfarthing/cyclist, not alongside theme YAMLs
+    root = project_root or Path.cwd()
+    cyclist_portrait_dirs = [
+        root / "packages" / "cyclist" / "portraits" / theme,  # monorepo dev
+        root / "node_modules" / "@pennyfarthing" / "cyclist" / "portraits" / theme,  # npm
+    ]
+    # pnpm: resolve through .pennyfarthing symlink chain
+    pnpm_cyclist = root / "node_modules" / ".pnpm"
+    if pnpm_cyclist.is_dir():
+        for entry in pnpm_cyclist.iterdir():
+            if entry.name.startswith("@pennyfarthing+cyclist@"):
+                candidate = entry / "node_modules" / "@pennyfarthing" / "cyclist" / "portraits" / theme
+                cyclist_portrait_dirs.append(candidate)
+                break
+
+    for portraits_dir in cyclist_portrait_dirs:
+        result = _find_portrait(portraits_dir, slug, preferred_size=preferred_size)
+        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