@pennyfarthing/core 7.8.1 → 7.8.4

package/pennyfarthing_scripts/sprint/cli.py

@@ -0,0 +1,124 @@
+"""
+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())

package/pennyfarthing_scripts/sprint/loader.py

@@ -0,0 +1,193 @@
+"""
+Sprint YAML parsing utilities for Pennyfarthing scripts.
+
+Provides access to sprint/current-sprint.yaml data.
+"""
+
+from pathlib import Path
+from typing import Any
+
+from pennyfarthing_scripts.common.config import get_project_root, load_yaml_config
+
+
+def load_sprint(project_root: Path | None = None) -> dict[str, Any] | None:
+    """Load sprint data from project root.
+
+    Args:
+        project_root: Project root path (defaults to auto-detect)
+
+    Returns:
+        Sprint data as dict, or None if not found
+    """
+    root = project_root or get_project_root()
+    sprint_path = root / "sprint" / "current-sprint.yaml"
+    return load_yaml_config(sprint_path)
+
+
+def find_epic(sprint_data: dict[str, Any], epic_num: str) -> dict[str, Any] | None:
+    """Find epic in sprint data (handles various ID formats).
+
+    Args:
+        sprint_data: Sprint YAML data
+        epic_num: Epic number (e.g., "63", "epic-63", or "63")
+
+    Returns:
+        Epic dict if found, None otherwise
+    """
+    if not sprint_data or "epics" not in sprint_data:
+        return None
+
+    # Normalize the epic number
+    epic_num_clean = epic_num.replace("epic-", "")
+
+    for epic in sprint_data["epics"]:
+        epic_id = str(epic.get("id", ""))
+        # Match "63", "epic-63", or just the number
+        if epic_id == epic_num or epic_id == f"epic-{epic_num}" or epic_id == epic_num_clean:
+            return epic
+        # Also try without prefix
+        if epic_id.replace("epic-", "") == epic_num_clean:
+            return epic
+
+    return None
+
+
+# Alias for backwards compatibility
+load_current_sprint = load_sprint
+
+
+def get_sprint_info() -> dict[str, Any]:
+    """Get sprint metadata (number, dates, status, etc).
+
+    Returns:
+        Sprint info dict with number, status, goal, etc.
+    """
+    data = load_sprint()
+    if data and "sprint" in data:
+        return data["sprint"]
+    return {}
+
+
+def get_all_stories() -> list[dict[str, Any]]:
+    """Get all stories from all epics.
+
+    Returns:
+        Flat list of all story dicts
+    """
+    data = load_sprint()
+    if not data or "epics" not in data:
+        return []
+
+    stories = []
+    for epic in data["epics"]:
+        if "stories" in epic:
+            stories.extend(epic["stories"])
+    return stories
+
+
+def get_story_by_id(story_id: str) -> dict[str, Any] | None:
+    """Find a story by its ID.
+
+    Args:
+        story_id: The story ID (e.g., "63-4" or "MSSCI-12398")
+
+    Returns:
+        Story dict if found, None otherwise
+    """
+    for story in get_all_stories():
+        if story.get("id") == story_id:
+            return story
+        # Also check jira field
+        if story.get("jira") == story_id:
+            return story
+    return None
+
+
+def get_stories_by_status(status: str) -> list[dict[str, Any]]:
+    """Get all stories with a given status.
+
+    Args:
+        status: Status to filter by (e.g., "backlog", "in_progress", "done")
+
+    Returns:
+        List of stories matching the status
+    """
+    return [s for s in get_all_stories() if s.get("status") == status]
+
+
+def get_epic_by_id(epic_id: str) -> dict[str, Any] | None:
+    """Find an epic by its ID.
+
+    Args:
+        epic_id: The epic ID
+
+    Returns:
+        Epic dict if found, None otherwise
+    """
+    data = load_sprint()
+    if not data or "epics" not in data:
+        return None
+
+    for epic in data["epics"]:
+        if epic.get("id") == epic_id:
+            return epic
+    return None
+
+
+def find_story(epic: dict[str, Any] | None, story_id: str) -> dict[str, Any] | None:
+    """Find a story within an epic by its ID.
+
+    Args:
+        epic: Epic dict containing stories
+        story_id: The story ID (e.g., "63-7")
+
+    Returns:
+        Story dict if found, None otherwise
+    """
+    if not epic or "stories" not in epic:
+        return None
+
+    for story in epic["stories"]:
+        if story.get("id") == story_id:
+            return story
+
+    return None
+
+
+def get_story_field(
+    sprint_data: dict[str, Any], story_id: str, field_name: str
+) -> Any | None:
+    """Get a specific field from a story in sprint data.
+
+    Extracts the epic number from the story ID (e.g., "63-7" -> epic 63)
+    and looks up the story within that epic.
+
+    Args:
+        sprint_data: Sprint YAML data
+        story_id: The story ID (e.g., "63-7")
+        field_name: The field to extract (e.g., "status", "points", "workflow")
+
+    Returns:
+        Field value if found, None otherwise
+    """
+    if not sprint_data or not story_id:
+        return None
+
+    # Extract epic number from story ID (e.g., "63-7" -> "63")
+    parts = story_id.split("-")
+    if len(parts) < 2:
+        return None
+
+    epic_num = parts[0]
+
+    # Find the epic
+    epic = find_epic(sprint_data, epic_num)
+    if not epic:
+        return None
+
+    # Find the story within the epic
+    story = find_story(epic, story_id)
+    if not story:
+        return None
+
+    return story.get(field_name)

package/pennyfarthing_scripts/sprint/status.py

@@ -0,0 +1,122 @@
+"""
+Sprint status operations.
+
+Provides functions for getting and displaying sprint status.
+"""
+
+from typing import Any
+
+from pennyfarthing_scripts.sprint.loader import get_all_stories, get_sprint_info, load_sprint
+
+
+def get_sprint_status(filter_status: str | None = None) -> dict[str, Any]:
+    """Get sprint status with story counts.
+
+    Args:
+        filter_status: Optional status to filter by
+
+    Returns:
+        Dict with sprint status information
+    """
+    sprint_info = get_sprint_info()
+    stories = get_all_stories()
+
+    if not stories:
+        return {}
+
+    # Count by status
+    status_counts: dict[str, int] = {}
+    total_points = 0
+    completed_points = 0
+
+    for story in stories:
+        status = story.get("status", "backlog")
+        points = story.get("points", 0) or 0
+
+        status_counts[status] = status_counts.get(status, 0) + 1
+        total_points += points
+
+        if status in ("done", "completed"):
+            completed_points += points
+
+    return {
+        "sprint": sprint_info,
+        "total_stories": len(stories),
+        "by_status": status_counts,
+        "backlog": status_counts.get("backlog", 0),
+        "in_progress": status_counts.get("in_progress", 0),
+        "review": status_counts.get("review", 0),
+        "completed": status_counts.get("done", 0) + status_counts.get("completed", 0),
+        "total_points": total_points,
+        "completed_points": completed_points,
+    }
+
+
+def format_status(status: dict[str, Any]) -> str:
+    """Format sprint status as human-readable string.
+
+    Args:
+        status: Status dict from get_sprint_status
+
+    Returns:
+        Formatted status string
+    """
+    if not status:
+        return "No sprint data available"
+
+    lines = []
+
+    # Sprint header
+    sprint = status.get("sprint", {})
+    if sprint:
+        lines.append(f"Sprint: {sprint.get('name', 'Unknown')}")
+        lines.append(f"Status: {sprint.get('status', 'unknown')}")
+        if sprint.get("goal"):
+            lines.append(f"Goal: {sprint['goal']}")
+        lines.append("")
+
+    # Story counts
+    lines.append(f"Total Stories: {status.get('total_stories', 0)}")
+    lines.append(f"  Backlog: {status.get('backlog', 0)}")
+    lines.append(f"  In Progress: {status.get('in_progress', 0)}")
+    lines.append(f"  In Review: {status.get('review', 0)}")
+    lines.append(f"  Completed: {status.get('completed', 0)}")
+    lines.append("")
+
+    # Points
+    lines.append(f"Points: {status.get('completed_points', 0)}/{status.get('total_points', 0)}")
+
+    return "\n".join(lines)
+
+
+def main(args: list[str] | None = None) -> int:
+    """CLI entry point for sprint status.
+
+    Args:
+        args: Command line arguments
+
+    Returns:
+        Exit code
+    """
+    import argparse
+    import sys
+
+    parser = argparse.ArgumentParser(description="Show sprint status")
+    parser.add_argument(
+        "filter",
+        nargs="?",
+        choices=["backlog", "todo", "in-progress", "review", "done"],
+        help="Filter by status",
+    )
+
+    parsed = parser.parse_args(args)
+
+    status = get_sprint_status(parsed.filter)
+    print(format_status(status))
+
+    return 0
+
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(main())