@pennyfarthing/core 11.4.0 → 12.0.0

package/pennyfarthing-dist/pf/bc/cli.py

@@ -1,241 +0,0 @@
-"""BC CLI — Panel focus management for Cyclist.
-
-Usage:
-    pf bc <panel>    Set focus to a panel
-    pf bc reset      Clear focus setting
-    pf bc save       Save a named layout
-    pf bc load       Load a named layout
-    pf bc list       List saved layouts
-    pf bc clear      Delete a named layout
-    pf bc clear-all  Delete all named layouts
-"""
-
-from __future__ import annotations
-
-import json
-import sys
-import urllib.error
-import urllib.request
-
-import click
-
-from pf.bc.focus import (
-    VALID_PANELS,
-    clear_all_named_layouts,
-    clear_named_layout,
-    clear_panel_focus,
-    list_named_layouts,
-    load_named_layout,
-    save_named_layout,
-    set_panel_focus,
-)
-from pf.bc.split import set_split_layout
-
-
-def _get_current_layout() -> dict | None:
-    """Fetch the current layout from a running Cyclist or BikeRack server.
-
-    Reads .bikerack-port (shared by both Cyclist and BikeRack) and fetches
-    the layout endpoint.
-
-    Returns:
-        Layout dict, or None if no server is running or fetch fails.
-    """
-    from pf.bc.focus import _get_root
-
-    root = _get_root()
-
-    candidates = [
-        (root / ".bikerack-port", "/api/settings/bikerack-layout"),
-    ]
-
-    for port_file, endpoint in candidates:
-        if not port_file.exists():
-            continue
-        try:
-            port = int(port_file.read_text().strip())
-        except (ValueError, OSError):
-            continue
-
-        url = f"http://localhost:{port}{endpoint}"
-        try:
-            req = urllib.request.Request(url, headers={"Accept": "application/json"})
-            with urllib.request.urlopen(req, timeout=3) as resp:
-                data = json.loads(resp.read().decode())
-                layout = data.get("layout")
-                if layout and isinstance(layout, dict) and layout.get("panels"):
-                    return layout
-        except (urllib.error.URLError, OSError, json.JSONDecodeError):
-            continue
-
-    return None
-
-
-@click.group()
-def bc():
-    """Panel focus management.
-
-    \b
-    Commands:
-      sprint      - Focus on Sprint panel
-      git         - Focus on Git panel
-      diffs       - Focus on Diffs panel
-      todo        - Focus on Todo panel
-      workflow    - Focus on Workflow panel
-      background  - Focus on Background panel
-      audit-log   - Focus on Audit Log panel
-      ac          - Focus on Acceptance Criteria panel
-      debug       - Focus on Debug panel
-      settings    - Focus on Settings panel
-      tty         - Focus on TTY panel
-      reset       - Clear focus setting
-    """
-    pass
-
-
-def _make_focus_command(panel_name: str):
-    """Create a Click command for a panel."""
-
-    @click.command(panel_name, help=f"Focus on {panel_name} panel.")
-    @click.option("--dry-run", is_flag=True, help="Show what would be done without making changes")
-    def focus_cmd(dry_run):
-        if dry_run:
-            click.echo(json.dumps({"dry_run": True, "action": "set_focus", "panel": panel_name}))
-            return
-        result = set_panel_focus(panel_name)
-        if result["success"]:
-            click.echo(json.dumps({"success": True, "panel": result["data"]}))
-        else:
-            click.echo(json.dumps({"success": False, "error": result["error"]}), err=True)
-            sys.exit(1)
-
-    return focus_cmd
-
-
-for _panel in VALID_PANELS:
-    bc.add_command(_make_focus_command(_panel))
-
-
-@bc.command("reset")
-@click.option("--dry-run", is_flag=True, help="Show what would be done without making changes")
-def reset_focus(dry_run):
-    """Clear focus setting."""
-    if dry_run:
-        click.echo(json.dumps({"dry_run": True, "action": "clear_focus"}))
-        return
-    result = clear_panel_focus()
-    if result["success"]:
-        click.echo(json.dumps({"success": True, "message": result.get("message", "focus cleared")}))
-    else:
-        click.echo(json.dumps({"success": False, "error": result["error"]}), err=True)
-        sys.exit(1)
-
-
-# --- Story 104-4: Named layout commands ---
-
-
-@bc.command("save")
-@click.argument("name")
-@click.option("--dry-run", is_flag=True, help="Show what would be done without making changes")
-def save_layout(name: str, dry_run: bool):
-    """Save current layout under a name.
-
-    Fetches the active layout from the running Cyclist/BikeRack server
-    and stores it in config.local.yaml under the given name.
-    """
-    layout_data = _get_current_layout()
-    if not layout_data:
-        click.echo(
-            json.dumps({"success": False, "error": "No running Cyclist/BikeRack server found, or layout is empty"}),
-            err=True,
-        )
-        sys.exit(1)
-    if dry_run:
-        panel_count = len(layout_data.get("panels", {}))
-        click.echo(json.dumps({"dry_run": True, "action": "save_layout", "name": name, "panels": panel_count}))
-        return
-    result = save_named_layout(name, layout_data)
-    if result["success"]:
-        panel_count = len(layout_data.get("panels", {}))
-        click.echo(json.dumps({"success": True, "name": result["data"], "panels": panel_count}))
-    else:
-        click.echo(json.dumps({"success": False, "error": result["error"]}), err=True)
-        sys.exit(1)
-
-
-@bc.command("load")
-@click.argument("name")
-@click.option("--dry-run", is_flag=True, help="Show what would be done without making changes")
-def load_layout(name: str, dry_run: bool):
-    """Load a previously saved named layout."""
-    if dry_run:
-        click.echo(json.dumps({"dry_run": True, "action": "load_layout", "name": name}))
-        return
-    result = load_named_layout(name)
-    if result["success"]:
-        click.echo(json.dumps({"success": True, "name": name, "layout": result["data"]}))
-    else:
-        click.echo(json.dumps({"success": False, "error": result["error"]}), err=True)
-        sys.exit(1)
-
-
-@bc.command("list")
-def list_layouts():
-    """List all saved named layouts."""
-    result = list_named_layouts()
-    if result["success"]:
-        click.echo(json.dumps({"success": True, "layouts": result["data"]}))
-    else:
-        click.echo(json.dumps({"success": False, "error": result["error"]}), err=True)
-        sys.exit(1)
-
-
-@bc.command("clear")
-@click.argument("name")
-@click.option("--dry-run", is_flag=True, help="Show what would be done without making changes")
-def clear_layout(name: str, dry_run: bool):
-    """Delete a specific named layout."""
-    if dry_run:
-        click.echo(json.dumps({"dry_run": True, "action": "clear_layout", "name": name}))
-        return
-    result = clear_named_layout(name)
-    if result["success"]:
-        click.echo(json.dumps({"success": True, "message": result.get("message", "layout cleared")}))
-    else:
-        click.echo(json.dumps({"success": False, "error": result["error"]}), err=True)
-        sys.exit(1)
-
-
-@bc.command("split")
-@click.argument("left")
-@click.argument("right")
-@click.option("--dry-run", is_flag=True, help="Show what would be done without making changes")
-def split_layout(left: str, right: str, dry_run: bool):
-    """Set split-pane layout with LEFT and RIGHT panels.
-
-    Example: pf bc split sprint diffs
-    """
-    if dry_run:
-        click.echo(json.dumps({"dry_run": True, "action": "split", "left": left, "right": right}))
-        return
-    result = set_split_layout(left, right)
-    if result["success"]:
-        click.echo(json.dumps({"success": True, "split": result["data"]}))
-    else:
-        click.echo(json.dumps({"success": False, "error": result["error"]}), err=True)
-        sys.exit(1)
-
-
-@bc.command("clear-all")
-@click.option("--dry-run", is_flag=True, help="Show what would be done without making changes")
-def clear_all_layouts(dry_run: bool):
-    """Delete all named layouts."""
-    if dry_run:
-        click.echo(json.dumps({"dry_run": True, "action": "clear_all_layouts"}))
-        return
-    result = clear_all_named_layouts()
-    if result["success"]:
-        click.echo(json.dumps({"success": True, "message": result.get("message", "all layouts cleared")}))
-    else:
-        click.echo(json.dumps({"success": False, "error": result["error"]}), err=True)
-        sys.exit(1)

package/pennyfarthing-dist/pf/bc/focus.py

@@ -1,333 +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 pf.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",
-    "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)}