@pennyfarthing/core 11.4.0 → 12.0.0

package/pennyfarthing-dist/pf/bikerack/ws_client.py

@@ -1,176 +0,0 @@
-"""WheelHub WebSocket client with auto-reconnect.
-
-Story 103-2: Python WebSocket client that connects to WheelHub,
-subscribes to panel channels, receives JSON payloads, dispatches
-to handlers, and auto-reconnects on disconnect with backoff.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import json
-from collections.abc import Callable
-from enum import Enum
-from pathlib import Path
-from typing import Any
-
-import websockets
-
-
-class ConnectionState(Enum):
-    """WebSocket connection states."""
-
-    DISCONNECTED = "disconnected"
-    CONNECTING = "connecting"
-    CONNECTED = "connected"
-    RECONNECTING = "reconnecting"
-
-
-# Default port for BikeRack mode
-DEFAULT_PORT = 2898
-
-# Reconnect delay in seconds (matches React hook pattern)
-RECONNECT_DELAY = 2.0
-
-# Type alias for message handlers
-MessageHandler = Callable[[dict[str, Any]], None]
-StateChangeCallback = Callable[[ConnectionState], None]
-
-
-class WheelHubClient:
-    """WebSocket client for WheelHub server.
-
-    Connects to WheelHub, subscribes to channels, dispatches
-    JSON messages to registered handlers, auto-reconnects on disconnect.
-    """
-
-    def __init__(
-        self,
-        port: int | None = None,
-        project_dir: Path | None = None,
-    ) -> None:
-        self._port = port
-        self._project_dir = project_dir
-        self._state = ConnectionState.DISCONNECTED
-        self._handlers: dict[str, list[MessageHandler]] = {}
-        self._state_callbacks: list[StateChangeCallback] = []
-        self._connections: dict[str, Any] = {}
-        self._tasks: list[asyncio.Task] = []
-        self._stopped = False
-
-    @property
-    def state(self) -> ConnectionState:
-        """Current connection state."""
-        return self._state
-
-    @property
-    def port(self) -> int | None:
-        """Configured port, if any."""
-        return self._port
-
-    def _set_state(self, new_state: ConnectionState) -> None:
-        """Transition to a new state and notify callbacks."""
-        self._state = new_state
-        for cb in self._state_callbacks:
-            cb(new_state)
-
-    def discover_port(self) -> int:
-        """Read port from .bikerack-port file, fallback to DEFAULT_PORT.
-
-        Priority: explicit port > port file > DEFAULT_PORT.
-        """
-        if self._port is not None:
-            return self._port
-        if self._project_dir is not None:
-            port_file = self._project_dir / ".bikerack-port"
-            if port_file.exists():
-                try:
-                    return int(port_file.read_text().strip())
-                except (ValueError, OSError):
-                    pass
-        return DEFAULT_PORT
-
-    def subscribe(self, channel: str, handler: MessageHandler) -> None:
-        """Register a handler for messages on a channel."""
-        if channel not in self._handlers:
-            self._handlers[channel] = []
-        self._handlers[channel].append(handler)
-
-    def on_state_change(self, callback: StateChangeCallback) -> None:
-        """Register a callback for connection state changes."""
-        self._state_callbacks.append(callback)
-
-    async def connect(self) -> None:
-        """Connect to WheelHub and start receiving messages.
-
-        Blocks while channel recv loops are running. Returns when all
-        loops complete (via CancelledError or disconnect).
-        """
-        self._stopped = False
-        port = self.discover_port()
-
-        if not self._handlers:
-            self._set_state(ConnectionState.CONNECTED)
-            return
-
-        async def channel_loop(
-            channel: str, handlers: list[MessageHandler]
-        ) -> None:
-            while not self._stopped:
-                try:
-                    url = f"ws://localhost:{port}/ws/{channel}"
-                    ws = await websockets.connect(url)
-                    self._connections[channel] = ws
-                    self._set_state(ConnectionState.CONNECTED)
-                    while True:
-                        raw = await ws.recv()
-                        try:
-                            msg = json.loads(raw)
-                            for h in handlers:
-                                h(msg)
-                        except (json.JSONDecodeError, TypeError):
-                            pass
-                except asyncio.CancelledError:
-                    raise
-                except Exception:
-                    if self._stopped:
-                        break
-                    self._set_state(ConnectionState.RECONNECTING)
-                    _sleep = asyncio.create_task(
-                        asyncio.sleep(RECONNECT_DELAY)
-                    )
-                    try:
-                        await _sleep
-                    except asyncio.CancelledError:
-                        _sleep.cancel()
-                        raise
-
-        self._tasks = [
-            asyncio.create_task(channel_loop(ch, hs))
-            for ch, hs in self._handlers.items()
-        ]
-
-        results = await asyncio.gather(*self._tasks, return_exceptions=True)
-        for r in results:
-            if isinstance(r, asyncio.CancelledError):
-                raise r
-
-    async def disconnect(self) -> None:
-        """Disconnect from WheelHub and cancel reconnect timers."""
-        self._stopped = True
-
-        for task in self._tasks:
-            task.cancel()
-
-        if self._tasks:
-            await asyncio.gather(*self._tasks, return_exceptions=True)
-        self._tasks = []
-
-        for ws in self._connections.values():
-            try:
-                await ws.close()
-            except Exception:
-                pass
-        self._connections = {}
-
-        self._set_state(ConnectionState.DISCONNECTED)

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

@@ -1,197 +0,0 @@
-"""
-CLI commands for BMAD adapter.
-
-Provides:
-    pf bmad import <path>              — Initial import from BMAD project
-    pf bmad sync --pull [--dry-run]    — Pull BMAD changes into PF YAML
-    pf bmad sync --push [--dry-run]    — Push PF changes to BMAD markdown
-    pf bmad sync --both [--dry-run]    — Bidirectional sync
-    pf bmad status                     — Drift report
-"""
-
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-
-import click
-
-
-@click.group()
-def bmad():
-    """BMAD adapter — bidirectional sprint sync."""
-    pass
-
-
-# =============================================================================
-# pf bmad import
-# =============================================================================
-
-
-@bmad.command("import")
-@click.argument("bmad_path", type=click.Path(exists=True))
-@click.option("--repos", default="axiathon", help="Default repos value for stories")
-@click.option("--dry-run", is_flag=True, help="Preview without writing")
-def bmad_import(bmad_path: str, repos: str, dry_run: bool):
-    """Import a BMAD project into PF sprint YAML.
-
-    BMAD_PATH is the path to the _bmad-output/ directory.
-    """
-    from pf.bmad.importer import import_bmad_project
-    from pf.common.config import get_project_root
-
-    root = get_project_root()
-    sprint_dir = root / "sprint"
-    source = Path(bmad_path).resolve()
-
-    result = import_bmad_project(
-        bmad_root=source,
-        sprint_dir=sprint_dir,
-        repos=repos,
-        dry_run=dry_run,
-        project_root=root,
-    )
-
-    if result.get("success"):
-        prefix = "[DRY-RUN] " if result.get("dry_run") else ""
-        click.echo(f"{prefix}{result['message']}")
-        click.echo(f"  Epics:   {result['epics_count']}")
-        click.echo(f"  Stories: {result['stories_count']}")
-        click.echo(f"  Points:  {result['total_points']}")
-        if result.get("epic_ids"):
-            click.echo(f"  Epic IDs: {', '.join(result['epic_ids'])}")
-    else:
-        click.echo(f"Failed: {result.get('error')}", err=True)
-        raise SystemExit(1)
-
-
-# =============================================================================
-# pf bmad sync
-# =============================================================================
-
-
-@bmad.command()
-@click.option("--pull", "direction", flag_value="pull", help="Pull BMAD changes into PF")
-@click.option("--push", "direction", flag_value="push", help="Push PF changes to BMAD")
-@click.option("--both", "direction", flag_value="both", help="Bidirectional sync")
-@click.option("--dry-run", is_flag=True, help="Preview without applying")
-@click.option("--pf-wins", is_flag=True, default=True, help="PF status wins on conflict (default)")
-@click.option("--bmad-wins", is_flag=True, help="BMAD status wins on conflict")
-@click.option("--import-new", is_flag=True, help="Import new BMAD stories not in PF")
-def sync(
-    direction: str | None,
-    dry_run: bool,
-    pf_wins: bool,
-    bmad_wins: bool,
-    import_new: bool,
-):
-    """Sync status between PF YAML and BMAD markdown."""
-    if not direction:
-        click.echo("Specify --pull, --push, or --both", err=True)
-        raise SystemExit(1)
-
-    from pf.bmad.parser import discover_bmad_stories
-    from pf.bmad.sync import (
-        _collect_pf_stories,
-        execute_sync_plan,
-        format_sync_plan,
-        generate_sync_plan,
-    )
-    from pf.common.config import get_project_root, load_pennyfarthing_config
-
-    root = get_project_root()
-    config = load_pennyfarthing_config(root)
-    bmad_config = config.get("bmad", {})
-
-    source_root_str = bmad_config.get("source_root")
-    if not source_root_str:
-        click.echo(
-            "No bmad.source_root configured in .pennyfarthing/config.local.yaml",
-            err=True,
-        )
-        raise SystemExit(1)
-
-    bmad_root = (root / source_root_str).resolve()
-    if not bmad_root.is_dir():
-        click.echo(f"BMAD source root not found: {bmad_root}", err=True)
-        raise SystemExit(1)
-
-    sprint_path = root / "sprint" / "current-sprint.yaml"
-    if not sprint_path.exists():
-        click.echo(f"Sprint file not found: {sprint_path}", err=True)
-        click.echo("Run 'pf bmad import' first.", err=True)
-        raise SystemExit(1)
-
-    story_subdir = bmad_config.get("story_dir", "implementation-artifacts")
-    wins_pf = not bmad_wins
-
-    pf_stories = _collect_pf_stories(sprint_path)
-    bmad_stories = discover_bmad_stories(bmad_root, story_dir=story_subdir)
-
-    plan = generate_sync_plan(
-        pf_stories,
-        bmad_stories,
-        direction=direction,
-        pf_wins=wins_pf,
-    )
-
-    click.echo(format_sync_plan(plan))
-
-    if not plan.changes and not (import_new and plan.bmad_only):
-        return
-
-    result = execute_sync_plan(
-        plan,
-        dry_run=dry_run,
-        sprint_path=sprint_path,
-        bmad_root=bmad_root,
-        import_new=import_new,
-    )
-
-    if dry_run:
-        click.echo(f"\n[DRY-RUN] {result.changes_planned} changes would be applied")
-        if import_new and plan.bmad_only:
-            click.echo(f"[DRY-RUN] {len(plan.bmad_only)} new stories would be imported")
-        return
-
-    click.echo(f"\nApplied {result.changes_applied}/{result.changes_planned} changes")
-    if result.new_stories_imported:
-        click.echo(f"Imported {result.new_stories_imported} new stories")
-    if result.errors:
-        for err in result.errors:
-            click.echo(f"  Error: {err}", err=True)
-        raise SystemExit(1)
-
-
-# =============================================================================
-# pf bmad status
-# =============================================================================
-
-
-@bmad.command()
-def status():
-    """Show drift report — what's out of sync between PF and BMAD."""
-    from pf.bmad.sync import drift_report
-    from pf.common.config import get_project_root, load_pennyfarthing_config
-
-    root = get_project_root()
-    config = load_pennyfarthing_config(root)
-    bmad_config = config.get("bmad", {})
-
-    source_root_str = bmad_config.get("source_root")
-    if not source_root_str:
-        click.echo(
-            "No bmad.source_root configured in .pennyfarthing/config.local.yaml",
-            err=True,
-        )
-        raise SystemExit(1)
-
-    bmad_root = (root / source_root_str).resolve()
-    sprint_path = root / "sprint" / "current-sprint.yaml"
-
-    if not sprint_path.exists():
-        click.echo("No sprint file found. Run 'pf bmad import' first.", err=True)
-        raise SystemExit(1)
-
-    report = drift_report(sprint_path, bmad_root)
-    click.echo(report)

package/pennyfarthing-dist/pf/bmad/importer.py

@@ -1,200 +0,0 @@
-"""
-BMAD project importer — initial import from BMAD markdown to PF sprint YAML.
-
-Creates current-sprint.yaml + epic shard files from BMAD's
-implementation-artifacts/ and planning-artifacts/epics/ directories.
-"""
-
-from __future__ import annotations
-
-from datetime import date
-from pathlib import Path
-from typing import Any
-
-from pf.bmad.parser import (
-    discover_bmad_epics,
-    discover_bmad_stories,
-    map_bmad_to_pf,
-)
-from pf.common.config import get_project_root, load_pennyfarthing_config
-
-
-def _get_bmad_config(project_root: Path) -> dict[str, Any]:
-    """Read bmad section from .pennyfarthing/config.local.yaml."""
-    config = load_pennyfarthing_config(project_root)
-    return config.get("bmad", {})
-
-
-def _group_stories_by_epic(stories: list[dict]) -> dict[int, list[dict]]:
-    """Group story dicts by their epic number."""
-    groups: dict[int, list[dict]] = {}
-    for story in stories:
-        epic_num = int(story["epic_num"])
-        groups.setdefault(epic_num, []).append(story)
-    return groups
-
-
-def _build_epic_shard(
-    epic_num: int,
-    epic_meta: dict[str, Any] | None,
-    stories: list[dict],
-    repos: str,
-) -> dict[str, Any]:
-    """Build a PF epic shard dict from BMAD data.
-
-    Args:
-        epic_num: Epic number
-        epic_meta: Parsed BMAD epic metadata (or None if no epic file)
-        stories: List of parsed BMAD story dicts for this epic
-        repos: Default repos value
-
-    Returns:
-        PF epic shard dict ready for validation and writing.
-    """
-    title = epic_meta["title"] if epic_meta else f"Epic {epic_num}"
-    phase = epic_meta.get("phase", "MVP") if epic_meta else "MVP"
-
-    pf_stories: list[dict[str, Any]] = []
-    for story in stories:
-        pf_story: dict[str, Any] = {
-            "id": story["id"],
-            "title": story["title"],
-            "points": story.get("points", 3),
-            "priority": story.get("priority", "P1"),
-            "status": story["status"],
-            "repos": repos,
-            "workflow": story.get("workflow", "tdd"),
-            "bmad_key": story["bmad_key"],
-        }
-        if story.get("jira"):
-            pf_story["jira"] = story["jira"]
-        pf_stories.append(pf_story)
-
-    total_points = sum(s.get("points", 3) for s in pf_stories)
-
-    return {
-        "id": str(epic_num),
-        "title": title,
-        "status": "planning",
-        "description": f"Phase: {phase}",
-        "priority": "P1",
-        "points": total_points,
-        "marker": "bmad",
-        "repos": repos,
-        "stories": pf_stories,
-    }
-
-
-def import_bmad_project(
-    bmad_root: Path,
-    sprint_dir: Path,
-    *,
-    repos: str = "axiathon",
-    dry_run: bool = False,
-    project_root: Path | None = None,
-) -> dict[str, Any]:
-    """Import a BMAD project into PF sprint YAML.
-
-    Args:
-        bmad_root: Path to BMAD _bmad-output/ directory
-        sprint_dir: Path to PF sprint/ directory
-        repos: Default repos value for stories
-        dry_run: If True, preview without writing
-        project_root: Project root (auto-detect if None)
-
-    Returns:
-        Result dict with success, counts, and details.
-    """
-    from pf.sprint.validator import validate_epic_shard
-    from pf.sprint.yaml_io import write_sprint
-
-    root = project_root or get_project_root()
-    bmad_config = _get_bmad_config(root)
-
-    # Resolve paths from config if available
-    story_subdir = bmad_config.get("story_dir", "implementation-artifacts")
-    epic_subdir = bmad_config.get("epic_dir", "planning-artifacts/epics")
-
-    # Discover BMAD content
-    stories = discover_bmad_stories(bmad_root, story_dir=story_subdir)
-    epics_meta = discover_bmad_epics(bmad_root, epic_dir=epic_subdir)
-
-    if not stories:
-        return {"success": False, "error": f"No stories found in {bmad_root / story_subdir}"}
-
-    # Build epic metadata lookup
-    epic_lookup: dict[int, dict] = {e["epicNumber"]: e for e in epics_meta}
-
-    # Group stories by epic
-    grouped = _group_stories_by_epic(stories)
-
-    # Build epic shards
-    epic_shards: list[dict[str, Any]] = []
-    validation_errors: list[str] = []
-
-    for epic_num in sorted(grouped.keys()):
-        epic_stories = grouped[epic_num]
-        epic_meta = epic_lookup.get(epic_num)
-        shard = _build_epic_shard(epic_num, epic_meta, epic_stories, repos)
-
-        # Validate
-        result = validate_epic_shard(shard)
-        if not result.valid:
-            msgs = "; ".join(e.message for e in result.errors)
-            validation_errors.append(f"Epic {epic_num}: {msgs}")
-        else:
-            epic_shards.append(shard)
-
-    if validation_errors:
-        return {
-            "success": False,
-            "error": "Validation failed:\n  " + "\n  ".join(validation_errors),
-        }
-
-    total_stories = sum(len(e["stories"]) for e in epic_shards)
-    total_points = sum(e.get("points", 0) for e in epic_shards)
-
-    if dry_run:
-        return {
-            "success": True,
-            "dry_run": True,
-            "epics_count": len(epic_shards),
-            "stories_count": total_stories,
-            "total_points": total_points,
-            "epic_ids": [e["id"] for e in epic_shards],
-            "message": (
-                f"Would import {len(epic_shards)} epics, "
-                f"{total_stories} stories ({total_points} points)"
-            ),
-        }
-
-    # Build sprint data structure
-    today = date.today().isoformat()
-    sprint_data: dict[str, Any] = {
-        "sprint": {
-            "name": "BMAD Import",
-            "goal": f"Imported from BMAD on {today}",
-            "start_date": today,
-            "end_date": today,
-            "status": "active",
-        },
-        "epics": epic_shards,
-    }
-
-    # Write using shard-aware writer
-    sprint_path = sprint_dir / "current-sprint.yaml"
-    sprint_dir.mkdir(parents=True, exist_ok=True)
-    write_sprint(sprint_path, sprint_data)
-
-    return {
-        "success": True,
-        "epics_count": len(epic_shards),
-        "stories_count": total_stories,
-        "total_points": total_points,
-        "sprint_path": str(sprint_path),
-        "message": (
-            f"Imported {len(epic_shards)} epics, "
-            f"{total_stories} stories ({total_points} points) "
-            f"to {sprint_path}"
-        ),
-    }