@pennyfarthing/core 11.4.0 → 12.0.0

package/pennyfarthing-dist/src/pf/__init__.py

@@ -0,0 +1,17 @@
+"""
+Pennyfarthing Scripts - Python utilities for agent orchestration.
+
+Modules:
+    config: Project root detection, YAML configuration loading
+    output: Colored console output utilities (success, info, warn, error)
+    sprint: Sprint YAML parsing and story access
+    jira: Jira CLI wrapper and JiraClient for REST API operations
+    jira_sync: Async epic sync to Jira
+    jira_sync_story: Single story sync to Jira
+    jira_epic_creation: Create Jira epics from sprint YAML
+    jira_bidirectional_sync: Bidirectional sync between sprint YAML and Jira
+    preflight: Async preflight checks for workflow completion
+    swebench: SWE-bench patch parsing and scenario utilities
+"""
+
+__version__ = "12.0.0"

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

@@ -0,0 +1,240 @@
+"""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
+      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/src/pf/bc/focus.py

@@ -0,0 +1,332 @@
+"""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",
+    "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)}