@pennyfarthing/core 9.2.0 → 9.3.0

package/pennyfarthing_scripts/sprint/import_epic.py

@@ -1,431 +0,0 @@
-"""
-Import BMAD epics-and-stories output to future.yaml.
-
-Transforms the markdown output from the epics-and-stories workflow into
-the YAML format used by sprint/future.yaml.
-"""
-
-import re
-from datetime import date
-from pathlib import Path
-from typing import Any
-
-import yaml
-
-from pennyfarthing_scripts.common.config import get_project_root, load_yaml_config
-
-
-def parse_epics_markdown(content: str) -> dict[str, Any]:
-    """Parse epics markdown file from BMAD epics-and-stories workflow.
-
-    Args:
-        content: Markdown content to parse
-
-    Returns:
-        Dict with parsed initiative data
-    """
-    result: dict[str, Any] = {
-        "title": "",
-        "description": "",
-        "total_points": 0,
-        "epics": [],
-    }
-
-    # Extract title from first # heading
-    title_match = re.search(r"^# (.+?)( - Epic Breakdown)?$", content, re.MULTILINE)
-    if title_match:
-        result["title"] = title_match.group(1).replace(" - Epics and Stories", "")
-
-    # Extract description from Overview section
-    overview_match = re.search(
-        r"## Overview\s*\n\s*\n(.+?)(?=\n\n##|\n##)", content, re.DOTALL
-    )
-    if overview_match:
-        result["description"] = overview_match.group(1).strip()
-
-    # Extract total points
-    points_match = re.search(r"\*\*Points:\*\*\s*(\d+)", content)
-    if points_match:
-        result["total_points"] = int(points_match.group(1))
-    else:
-        effort_match = re.search(
-            r"Total Effort.*?(\d+)\s*story points", content, re.IGNORECASE
-        )
-        if effort_match:
-            result["total_points"] = int(effort_match.group(1))
-
-    # Parse all epics
-    epic_pattern = re.compile(r"^## Epic (\d+):\s*(.+)$", re.MULTILINE)
-    epic_positions = []
-    for match in epic_pattern.finditer(content):
-        epic_positions.append(
-            {
-                "num": int(match.group(1)),
-                "title": match.group(2),
-                "index": match.start(),
-            }
-        )
-
-    # Process each epic
-    for i, epic_pos in enumerate(epic_positions):
-        start_index = epic_pos["index"]
-        end_index = (
-            epic_positions[i + 1]["index"] if i < len(epic_positions) - 1 else len(content)
-        )
-        epic_content = content[start_index:end_index]
-
-        epic: dict[str, Any] = {
-            "num": epic_pos["num"],
-            "title": epic_pos["title"],
-            "description": "",
-            "points": 0,
-            "stories": [],
-        }
-
-        # Extract epic description (User Outcome)
-        user_outcome_match = re.search(r"\*\*User Outcome:\*\*\s*(.+)", epic_content)
-        if user_outcome_match:
-            epic["description"] = user_outcome_match.group(1)
-
-        # Extract epic points
-        epic_points_match = re.search(r"\*\*Points:\*\*\s*(\d+)", epic_content)
-        if epic_points_match:
-            epic["points"] = int(epic_points_match.group(1))
-
-        # Parse stories within this epic
-        story_pattern = re.compile(
-            rf"^### Story {epic_pos['num']}\.(\d+):\s*(.+)$", re.MULTILINE
-        )
-        story_positions = []
-        for match in story_pattern.finditer(epic_content):
-            story_positions.append(
-                {
-                    "num": int(match.group(1)),
-                    "title": match.group(2),
-                    "index": match.start(),
-                }
-            )
-
-        for j, story_pos in enumerate(story_positions):
-            story_start = story_pos["index"]
-            story_end = (
-                story_positions[j + 1]["index"]
-                if j < len(story_positions) - 1
-                else len(epic_content)
-            )
-            story_content = epic_content[story_start:story_end]
-
-            # Extract story description
-            i_want_match = re.search(r"^I want \*\*(.+?)\*\*,", story_content, re.MULTILINE)
-            description = i_want_match.group(1) if i_want_match else ""
-
-            # Extract story points
-            story_points_match = re.search(r"\*\*Points:\*\*\s*(\d+)", story_content)
-            points = int(story_points_match.group(1)) if story_points_match else 1
-
-            epic["stories"].append(
-                {
-                    "num": story_pos["num"],
-                    "title": story_pos["title"],
-                    "description": description,
-                    "points": points,
-                }
-            )
-
-        result["epics"].append(epic)
-
-    # Calculate total if not found
-    if result["total_points"] == 0:
-        result["total_points"] = sum(e.get("points", 0) for e in result["epics"])
-
-    return result
-
-
-def get_next_epic_number(project_root: Path | None = None) -> int:
-    """Get next available epic number from future.yaml.
-
-    Args:
-        project_root: Project root path (defaults to auto-detect)
-
-    Returns:
-        Next available epic number
-    """
-    root = project_root or get_project_root()
-    future_path = root / "sprint" / "future.yaml"
-
-    if not future_path.exists():
-        return 74  # Default starting point
-
-    content = future_path.read_text()
-
-    # Look for "Next Available Epic Number: XX"
-    next_match = re.search(r"Next Available Epic Number:\s*(\d+)", content, re.IGNORECASE)
-    if next_match:
-        return int(next_match.group(1))
-
-    # Fallback: find highest epic-XX number
-    max_num = 73
-    for match in re.finditer(r"epic-(\d+)", content):
-        num = int(match.group(1))
-        if num > max_num:
-            max_num = num
-
-    return max_num + 1
-
-
-def generate_initiative_yaml(
-    parsed: dict[str, Any],
-    start_epic_num: int,
-    initiative_name: str,
-    source_file: str,
-    marker: str = "imported",
-) -> tuple[str, int]:
-    """Generate YAML for an initiative.
-
-    Args:
-        parsed: Parsed markdown data
-        start_epic_num: Starting epic number
-        initiative_name: Name for the initiative
-        source_file: Path to source markdown file
-        marker: Marker tag for stories
-
-    Returns:
-        Tuple of (YAML string, next epic number)
-    """
-    today = date.today().isoformat()
-
-    lines = [
-        f"    # ==========================================================================",
-        f"    # {initiative_name.upper()}",
-        f"    # Imported from: {source_file}",
-        f"    # Date: {today}",
-        f"    # ==========================================================================",
-        f'    - name: "{initiative_name}"',
-        f"      description: |",
-    ]
-
-    # Add description lines with proper indentation
-    for line in parsed.get("description", initiative_name).split("\n"):
-        lines.append(f"        {line}")
-
-    lines.extend(
-        [
-            f"      status: ready",
-            f"      blocked_by: null",
-            f"      total_points: {parsed['total_points']}",
-            f"      epics:",
-        ]
-    )
-
-    current_epic_num = start_epic_num
-
-    for epic in parsed.get("epics", []):
-        epic_points = epic.get("points", 0)
-        if epic_points == 0:
-            epic_points = sum(s.get("points", 1) for s in epic.get("stories", []))
-
-        lines.extend(
-            [
-                f"        - id: epic-{current_epic_num}",
-                f'          title: "{epic["title"]}"',
-                f"          description: |",
-                f"            {epic.get('description', epic['title'])}",
-                f"          points: {epic_points}",
-                f"          priority: P1",
-                f'          marker: "{marker}"',
-                f"          repos: pennyfarthing",
-                f"          status: planning",
-                f"          stories:",
-            ]
-        )
-
-        for story in epic.get("stories", []):
-            story_id = f"{current_epic_num}-{story['num']}"
-            # Escape quotes in title
-            title = story["title"].replace('"', '\\"')
-            lines.extend(
-                [
-                    f'            - id: "{story_id}"',
-                    f'              title: "{title}"',
-                    f"              description: |",
-                    f"                {story.get('description', title)}",
-                    f"              points: {story.get('points', 1)}",
-                    f"              priority: P0",
-                    f"              status: planning",
-                    f"              repos: pennyfarthing",
-                ]
-            )
-
-        current_epic_num += 1
-
-    return "\n".join(lines), current_epic_num
-
-
-def import_epic(
-    epics_file: str | Path,
-    initiative_name: str | None = None,
-    marker: str = "imported",
-    *,
-    project_root: Path | None = None,
-    dry_run: bool = False,
-) -> dict[str, Any]:
-    """Import BMAD epics-and-stories markdown to future.yaml.
-
-    Args:
-        epics_file: Path to the markdown file from epics-and-stories workflow
-        initiative_name: Name for the initiative (extracted from file if not provided)
-        marker: Marker tag for stories
-        project_root: Project root path (defaults to auto-detect)
-        dry_run: If True, show what would be done without making changes
-
-    Returns:
-        Dict with success status and details
-    """
-    root = project_root or get_project_root()
-
-    # Resolve epics file path
-    epics_path = Path(epics_file)
-    if not epics_path.is_absolute():
-        epics_path = root / epics_path
-
-    if not epics_path.exists():
-        return {"success": False, "error": f"File not found: {epics_path}"}
-
-    # Read and parse
-    content = epics_path.read_text()
-    parsed = parse_epics_markdown(content)
-
-    if not parsed.get("epics"):
-        return {"success": False, "error": "No epics found in markdown file"}
-
-    # Use provided name or extract from file
-    name = initiative_name or parsed.get("title") or "Imported Initiative"
-
-    # Get next epic number
-    start_epic_num = get_next_epic_number(root)
-
-    # Generate YAML
-    relative_path = str(epics_path.relative_to(root)) if epics_path.is_relative_to(root) else str(epics_path)
-    new_yaml, next_epic_num = generate_initiative_yaml(
-        parsed, start_epic_num, name, relative_path, marker
-    )
-
-    if dry_run:
-        return {
-            "success": True,
-            "dry_run": True,
-            "initiative_name": name,
-            "epics_count": len(parsed["epics"]),
-            "stories_count": sum(len(e.get("stories", [])) for e in parsed["epics"]),
-            "total_points": parsed["total_points"],
-            "start_epic_num": start_epic_num,
-            "next_epic_num": next_epic_num,
-            "yaml_preview": new_yaml,
-            "message": f"Would import '{name}' with {len(parsed['epics'])} epics",
-        }
-
-    # Update future.yaml
-    future_path = root / "sprint" / "future.yaml"
-    future_content = future_path.read_text()
-
-    # Update next epic number comment
-    future_content = re.sub(
-        r"Next Available Epic Number:\s*\d+",
-        f"Next Available Epic Number: {next_epic_num}",
-        future_content,
-        flags=re.IGNORECASE,
-    )
-
-    # Find insertion point (before SUMMARY section)
-    summary_marker = "# =============================================================================\n# SUMMARY"
-    summary_index = future_content.find(summary_marker)
-
-    if summary_index == -1:
-        future_content += "\n" + new_yaml
-    else:
-        future_content = (
-            future_content[:summary_index] + new_yaml + "\n" + future_content[summary_index:]
-        )
-
-    future_path.write_text(future_content)
-
-    return {
-        "success": True,
-        "initiative_name": name,
-        "epics_count": len(parsed["epics"]),
-        "stories_count": sum(len(e.get("stories", [])) for e in parsed["epics"]),
-        "total_points": parsed["total_points"],
-        "start_epic_num": start_epic_num,
-        "next_epic_num": next_epic_num,
-        "message": f"Imported '{name}' with {len(parsed['epics'])} epics (epic-{start_epic_num} to epic-{next_epic_num - 1})",
-    }
-
-
-def main(args: list[str] | None = None) -> int:
-    """CLI entry point for epic import.
-
-    Args:
-        args: Command line arguments
-
-    Returns:
-        Exit code
-    """
-    import argparse
-    import sys
-
-    parser = argparse.ArgumentParser(
-        description="Import BMAD epics-and-stories workflow output to future.yaml"
-    )
-    parser.add_argument(
-        "epics_file",
-        help="Path to the markdown file from epics-and-stories workflow",
-    )
-    parser.add_argument(
-        "initiative_name",
-        nargs="?",
-        help="Name for the initiative (optional, extracted from file if not provided)",
-    )
-    parser.add_argument(
-        "--marker",
-        default="imported",
-        help="Marker tag for stories (default: imported)",
-    )
-    parser.add_argument(
-        "--dry-run",
-        action="store_true",
-        help="Show what would be done without making changes",
-    )
-
-    parsed = parser.parse_args(args)
-
-    result = import_epic(
-        parsed.epics_file,
-        initiative_name=parsed.initiative_name,
-        marker=parsed.marker,
-        dry_run=parsed.dry_run,
-    )
-
-    if result.get("success"):
-        if result.get("dry_run"):
-            print(f"[DRY-RUN] {result.get('message')}")
-            print(f"  Epics: {result.get('epics_count')}")
-            print(f"  Stories: {result.get('stories_count')}")
-            print(f"  Points: {result.get('total_points')}")
-            print(f"  Epic numbers: epic-{result.get('start_epic_num')} to epic-{result.get('next_epic_num') - 1}")
-            print("\nYAML Preview:")
-            print("-" * 60)
-            print(result.get("yaml_preview"))
-            print("-" * 60)
-        else:
-            print(f"✓ {result.get('message')}")
-            print(f"  Next available epic number: {result.get('next_epic_num')}")
-        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/loader.py

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