@pennyfarthing/core 7.9.0 → 7.9.2

package/pennyfarthing_scripts/prime/workflow.py

@@ -1,275 +0,0 @@
-"""
-Workflow state detection for Prime v2.
-
-Detects current workflow state by analyzing:
-- Active session files in .session/
-- Session headers for phase and workflow
-- Sprint backlog for available stories
-"""
-
-from __future__ import annotations
-
-import re
-from pathlib import Path
-from typing import Any
-
-import yaml
-
-from pennyfarthing_scripts.common.config import get_project_root
-from pennyfarthing_scripts.prime.models import WorkflowState, WorkflowStatus
-
-
-def find_active_session(project_root: Path) -> Path | None:
-    """Find the active session file.
-
-    Looks in .session/ for *-session.md files, excluding context-*.md.
-    Returns the most recently modified session file.
-
-    Args:
-        project_root: Project root path
-
-    Returns:
-        Path to active session file, or None if not found
-    """
-    session_dir = project_root / ".session"
-    if not session_dir.is_dir():
-        return None
-
-    # Find *-session.md files (not context-*)
-    session_files = [
-        f for f in session_dir.glob("*-session.md")
-        if not f.name.startswith("context-")
-    ]
-
-    if not session_files:
-        return None
-
-    # Return the most recently modified one
-    return max(session_files, key=lambda f: f.stat().st_mtime)
-
-
-def parse_session_header(session_path: Path) -> dict[str, Any]:
-    """Parse session file header to extract metadata.
-
-    Looks for key: value patterns throughout the session file header sections.
-    Extracts workflow, phase, story_id, status from:
-    - ## Story Context section
-    - ## Workflow Phase section
-
-    Args:
-        session_path: Path to session file
-
-    Returns:
-        Dict with extracted metadata (workflow, phase, story_id, status)
-    """
-    content = session_path.read_text()
-    lines = content.split("\n")
-
-    result: dict[str, Any] = {}
-
-    # Extract story ID from filename (e.g., MSSCI-12419-session.md -> MSSCI-12419)
-    filename = session_path.stem
-    if filename.endswith("-session"):
-        result["story_id"] = filename[:-8]  # Remove "-session"
-
-    # Track which sections we're in (we care about Story Context and Workflow Phase)
-    in_relevant_section = True  # Start True to capture content before any ##
-
-    for line in lines:
-        # Track section headers
-        if line.startswith("## "):
-            # We care about Story Context and Workflow Phase sections
-            section_name = line[3:].strip().lower()
-            in_relevant_section = (
-                "story context" in section_name or
-                "workflow phase" in section_name or
-                "branch" in section_name
-            )
-            # Stop at assessment sections (too far down)
-            if "assessment" in section_name:
-                break
-            continue
-
-        # Only parse lines in relevant sections
-        if not in_relevant_section:
-            continue
-
-        # Look for key-value patterns
-        # Format is "**Key:** Value" (colon inside the bold)
-        # e.g., "- **Workflow:** tdd" or "- **Current Phase:** green"
-        match = re.search(r"\*\*([^*:]+):\*\*\s*(.+)", line)
-        if match:
-            key = match.group(1).lower().strip()
-            value = match.group(2).strip()
-
-            if key == "workflow":
-                result["workflow"] = value.lower()
-            elif key == "current phase":
-                # Extract phase name, handling "(APPROVED)" suffix
-                phase_match = re.match(r"(\w+)(?:\s*\(([^)]+)\))?", value)
-                if phase_match:
-                    result["phase"] = phase_match.group(1).lower()
-                    if phase_match.group(2):
-                        result["phase_status"] = phase_match.group(2).lower()
-            elif key == "id" and "story_id" not in result:
-                result["story_id"] = value
-            elif key == "status":
-                result["status"] = value.lower()
-
-    return result
-
-
-def get_phase_owner(workflow: str, phase: str, project_root: Path) -> str | None:
-    """Look up the agent that owns a workflow phase.
-
-    Reads the workflow YAML and finds the agent for the given phase.
-
-    Args:
-        workflow: Workflow name (tdd, trivial, bdd, etc.)
-        phase: Phase name (setup, red, green, review, finish)
-        project_root: Project root path
-
-    Returns:
-        Agent name (sm, tea, dev, reviewer), or None if not found
-    """
-    workflow_path = project_root / "pennyfarthing-dist" / "workflows" / f"{workflow}.yaml"
-
-    if not workflow_path.exists():
-        # Fallback to symlinked location
-        workflow_path = project_root / ".pennyfarthing" / "workflows" / f"{workflow}.yaml"
-        if not workflow_path.exists():
-            return None
-
-    try:
-        data = yaml.safe_load(workflow_path.read_text())
-        phases = data.get("workflow", {}).get("phases", [])
-
-        for p in phases:
-            if p.get("name") == phase:
-                return p.get("agent")
-
-        return None
-    except Exception:
-        return None
-
-
-def get_backlog_count(project_root: Path) -> int:
-    """Count stories in backlog or ready status.
-
-    Args:
-        project_root: Project root path
-
-    Returns:
-        Number of stories with status backlog or ready
-    """
-    # Import here to avoid circular imports
-    from pennyfarthing_scripts.sprint.loader import load_sprint
-
-    sprint = load_sprint(project_root)
-    if not sprint or "epics" not in sprint:
-        return 0
-
-    count = 0
-    for epic in sprint["epics"]:
-        for story in epic.get("stories", []):
-            status = story.get("status", "").lower()
-            if status in ("backlog", "ready"):
-                count += 1
-
-    return count
-
-
-def detect_workflow_state(project_root: Path | None = None) -> WorkflowStatus:
-    """Detect the current workflow state.
-
-    Returns one of:
-    - FINISH_STATE: Session exists with phase=approved or review-approved
-    - IN_PROGRESS_STATE: Session exists with active phase
-    - NEW_WORK_STATE: No session and backlog has stories
-    - EMPTY_BACKLOG_STATE: No session and backlog is empty
-
-    Args:
-        project_root: Project root path (auto-detected if not provided)
-
-    Returns:
-        WorkflowStatus with detected state and metadata
-    """
-    root = project_root or get_project_root()
-    session_file = find_active_session(root)
-
-    if session_file:
-        header = parse_session_header(session_file)
-        story_id = header.get("story_id")
-        workflow = header.get("workflow", "tdd")
-        phase = header.get("phase")
-        phase_status = header.get("phase_status", "")
-
-        # Check for finish state
-        if phase in ("approved", "review-approved", "finish"):
-            return WorkflowStatus(
-                state=WorkflowState.FINISH_STATE,
-                story_id=story_id,
-                phase=phase,
-                phase_owner="sm",
-                workflow=workflow,
-                session_file=str(session_file),
-            )
-
-        # Check if phase is approved (e.g., "REVIEW (APPROVED)")
-        if phase_status == "approved":
-            return WorkflowStatus(
-                state=WorkflowState.FINISH_STATE,
-                story_id=story_id,
-                phase=phase,
-                phase_owner="sm",
-                workflow=workflow,
-                session_file=str(session_file),
-            )
-
-        # In progress state - look up phase owner
-        owner = get_phase_owner(workflow, phase, root) if phase else None
-
-        return WorkflowStatus(
-            state=WorkflowState.IN_PROGRESS_STATE,
-            story_id=story_id,
-            phase=phase,
-            phase_owner=owner,
-            workflow=workflow,
-            session_file=str(session_file),
-        )
-
-    # No active session - check backlog
-    backlog_count = get_backlog_count(root)
-
-    if backlog_count > 0:
-        return WorkflowStatus(
-            state=WorkflowState.NEW_WORK_STATE,
-            backlog_count=backlog_count,
-        )
-
-    return WorkflowStatus(
-        state=WorkflowState.EMPTY_BACKLOG_STATE,
-    )
-
-
-def check_redirect(workflow_status: WorkflowStatus, agent_name: str) -> tuple[str, str] | None:
-    """Check if the activated agent should redirect to another agent.
-
-    Returns redirect info if:
-    - IN_PROGRESS_STATE and agent_name != phase_owner
-
-    Args:
-        workflow_status: Current workflow status
-        agent_name: Name of the activated agent
-
-    Returns:
-        Tuple of (target_agent, reason) if redirect needed, None otherwise
-    """
-    if workflow_status.state == WorkflowState.IN_PROGRESS_STATE:
-        if workflow_status.phase_owner and workflow_status.phase_owner != agent_name:
-            return (
-                workflow_status.phase_owner,
-                f"Phase '{workflow_status.phase}' is owned by '{workflow_status.phase_owner}'",
-            )
-
-    return None

package/pennyfarthing_scripts/sprint/__init__.py

@@ -1,66 +0,0 @@
-"""
-Sprint management package for Pennyfarthing scripts.
-
-This package provides:
-- loader: Sprint YAML loading and parsing
-- status: Sprint status operations
-- work: Work session management
-- archive: Story archiving
-
-Usage:
-    # Use the loader module
-    from pennyfarthing_scripts.sprint import load_sprint, find_epic
-    sprint_data = load_sprint()
-    epic = find_epic(sprint_data, "63")
-
-    # Use CLI
-    python -m pennyfarthing_scripts.sprint <subcommand> [args]
-"""
-
-# Re-export from loader for backwards compatibility
-from pennyfarthing_scripts.sprint.loader import (
-    find_epic,
-    find_story,
-    get_all_stories,
-    get_epic_by_id,
-    get_sprint_info,
-    get_stories_by_status,
-    get_story_by_id,
-    get_story_field,
-    load_current_sprint,
-    load_sprint,
-)
-
-# Import submodules to make them accessible
-from pennyfarthing_scripts.sprint import (
-    archive,
-    loader,
-    status,
-    work,
-)
-
-# CLI entry point - import module, not function, so "from sprint import cli" gets the module
-from pennyfarthing_scripts.sprint import cli
-from pennyfarthing_scripts.sprint.cli import main
-
-__all__ = [
-    # Loader functions
-    "find_epic",
-    "find_story",
-    "get_all_stories",
-    "get_epic_by_id",
-    "get_sprint_info",
-    "get_stories_by_status",
-    "get_story_by_id",
-    "get_story_field",
-    "load_current_sprint",
-    "load_sprint",
-    # Submodules
-    "archive",
-    "loader",
-    "status",
-    "work",
-    # CLI
-    "cli",
-    "main",
-]

package/pennyfarthing_scripts/sprint/__main__.py

@@ -1,10 +0,0 @@
-"""
-Entry point for python -m pennyfarthing_scripts.sprint
-"""
-
-import sys
-
-from pennyfarthing_scripts.sprint.cli import cli
-
-if __name__ == "__main__":
-    sys.exit(cli())

package/pennyfarthing_scripts/sprint/archive.py

@@ -1,108 +0,0 @@
-"""
-Sprint story archiving.
-
-Provides functions for archiving completed stories.
-"""
-
-from pathlib import Path
-from typing import Any
-
-from pennyfarthing_scripts.common.config import get_project_root
-from pennyfarthing_scripts.sprint.loader import get_story_by_id
-
-
-def archive_story(
-    story_id: str,
-    pr_number: str | None = None,
-    *,
-    dry_run: bool = False,
-    apply: bool = False,
-) -> dict[str, Any]:
-    """Archive a completed story.
-
-    Args:
-        story_id: Story ID to archive
-        pr_number: PR number if merged via PR
-        dry_run: If True, show what would be done
-        apply: If True, also remove from current-sprint.yaml
-
-    Returns:
-        Dict with success status and details
-    """
-    # Find the story
-    story = get_story_by_id(story_id)
-    if not story:
-        return {
-            "success": False,
-            "error": f"Story '{story_id}' not found in sprint YAML",
-        }
-
-    # Check status
-    status = story.get("status", "backlog")
-    if status not in ("done", "completed", "review"):
-        return {
-            "success": False,
-            "error": f"Story status is '{status}', expected 'done' or 'completed'",
-        }
-
-    if dry_run:
-        return {
-            "success": True,
-            "dry_run": True,
-            "story": story,
-            "pr_number": pr_number,
-            "message": f"Would archive {story_id}",
-        }
-
-    # In a real implementation, this would:
-    # 1. Write to archive file
-    # 2. Optionally remove from current-sprint.yaml
-    return {
-        "success": True,
-        "story": story,
-        "pr_number": pr_number,
-        "message": f"Archived {story_id}",
-    }
-
-
-def main(args: list[str] | None = None) -> int:
-    """CLI entry point for sprint archive.
-
-    Args:
-        args: Command line arguments
-
-    Returns:
-        Exit code
-    """
-    import argparse
-    import sys
-
-    parser = argparse.ArgumentParser(description="Archive a completed story")
-    parser.add_argument("story_id", help="Story ID to archive")
-    parser.add_argument("pr_number", nargs="?", help="PR number if merged via PR")
-    parser.add_argument("--apply", action="store_true", help="Also remove from current-sprint.yaml")
-    parser.add_argument("--dry-run", action="store_true", help="Show what would be done")
-
-    parsed = parser.parse_args(args)
-
-    result = archive_story(
-        parsed.story_id,
-        pr_number=parsed.pr_number,
-        dry_run=parsed.dry_run,
-        apply=parsed.apply,
-    )
-
-    if result.get("success"):
-        if result.get("dry_run"):
-            print(f"[DRY-RUN] {result.get('message')}")
-        else:
-            print(result.get("message"))
-        return 0
-    else:
-        print(f"Failed: {result.get('error')}", file=sys.stderr)
-        return 1
-
-
-if __name__ == "__main__":
-    import sys
-    sys.exit(main())

package/pennyfarthing_scripts/sprint/cli.py

@@ -1,124 +0,0 @@
-"""
-Sprint CLI - Fan-out CLI for sprint operations.
-
-Usage:
-    python -m pennyfarthing_scripts.sprint <subcommand> [args]
-
-Subcommands:
-    status      Show sprint status
-    backlog     Show available stories
-    work        Start work on a story
-    archive     Archive a completed story
-"""
-
-import argparse
-import sys
-
-
-def status(args: list[str]) -> int:
-    """Show sprint status."""
-    from pennyfarthing_scripts.sprint.status import main as status_main
-    return status_main(args)
-
-
-def backlog(args: list[str]) -> int:
-    """Show available stories."""
-    from pennyfarthing_scripts.sprint.loader import get_stories_by_status
-
-    stories = get_stories_by_status("backlog")
-    print(f"Backlog: {len(stories)} stories")
-    print("")
-    for story in stories:
-        priority = story.get("priority", "P2")
-        points = story.get("points", "?")
-        print(f"  [{priority}] {story.get('id')}: {story.get('title')} [{points}pts]")
-    return 0
-
-
-def work(args: list[str]) -> int:
-    """Start work on a story."""
-    from pennyfarthing_scripts.sprint.work import main as work_main
-    return work_main(args)
-
-
-def archive(args: list[str]) -> int:
-    """Archive a completed story."""
-    from pennyfarthing_scripts.sprint.archive import main as archive_main
-    return archive_main(args)
-
-
-# Subcommand registry
-SUBCOMMANDS = {
-    "status": status,
-    "backlog": backlog,
-    "work": work,
-    "archive": archive,
-}
-
-
-def cli(args: list[str] | None = None) -> int:
-    """Main CLI entry point.
-
-    Args:
-        args: Command line arguments (defaults to sys.argv[1:])
-
-    Returns:
-        Exit code
-    """
-    if args is None:
-        args = sys.argv[1:]
-
-    parser = argparse.ArgumentParser(
-        prog="sprint",
-        description="Sprint CLI for Pennyfarthing",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Subcommands:
-    status [filter]     Show sprint status (optional filter: backlog, in-progress, done)
-    backlog             Show available stories
-    work [story-id]     Start work on a story (or show available)
-    archive <id> [pr]   Archive a completed story
-
-Examples:
-    sprint status
-    sprint status in-progress
-    sprint backlog
-    sprint work MSSCI-12345
-    sprint work next
-    sprint archive 63-7 489
-""",
-    )
-
-    parser.add_argument(
-        "subcommand",
-        nargs="?",
-        choices=list(SUBCOMMANDS.keys()),
-        help="Subcommand to run",
-    )
-    parser.add_argument(
-        "args",
-        nargs=argparse.REMAINDER,
-        help="Arguments for subcommand",
-    )
-
-    parsed = parser.parse_args(args)
-
-    if not parsed.subcommand:
-        # Default to status
-        return status([])
-
-    handler = SUBCOMMANDS.get(parsed.subcommand)
-    if handler:
-        return handler(parsed.args)
-    else:
-        print(f"Unknown subcommand: {parsed.subcommand}", file=sys.stderr)
-        return 1
-
-
-def main(args: list[str] | None = None) -> int:
-    """Alias for cli()."""
-    return cli(args)
-
-
-if __name__ == "__main__":
-    sys.exit(cli())