@pennyfarthing/core 11.3.2 → 11.3.4

package/pennyfarthing_scripts/jira/create.py

@@ -1,311 +0,0 @@
-"""
-Create Jira stories and epics from sprint YAML definitions.
-
-Replaces:
-- create-jira-epic.sh (96 lines)
-- create-jira-story.sh (92 lines)
-
-All operations use REST API via JiraClient — no interactive prompt issues.
-
-Usage:
-    pf jira create epic <epic-id> [--dry-run]
-    pf jira create story <epic-jira-key> <story-id> [--dry-run]
-"""
-
-import sys
-from pathlib import Path
-from typing import Any
-
-from pennyfarthing_scripts.jira.client import JIRA_PROJECT, get_client
-from pennyfarthing_scripts.sprint.loader import find_epic, find_story, load_sprint
-from pennyfarthing_scripts.sprint.yaml_io import read_sprint, write_sprint
-
-# Priority mapping: Pennyfarthing -> Jira
-PRIORITY_MAP = {
-    "P0": "Highest",
-    "P1": "High",
-    "P2": "Medium",
-    "P3": "Low",
-}
-
-PROJECT_LABEL = "pennyfarthing"
-
-
-def _get_sprint_path() -> Path:
-    """Get path to current-sprint.yaml."""
-    from pennyfarthing_scripts.common.config import get_project_root
-
-    return get_project_root() / "sprint" / "current-sprint.yaml"
-
-
-def _build_adf_description(text: str) -> dict[str, Any]:
-    """Build Atlassian Document Format description from plain text."""
-    return {
-        "type": "doc",
-        "version": 1,
-        "content": [
-            {
-                "type": "paragraph",
-                "content": [{"type": "text", "text": text}] if text else [],
-            }
-        ],
-    }
-
-
-def create_story_in_jira(
-    epic_jira_key: str,
-    story_id: str,
-    *,
-    sprint_path: Path | None = None,
-    dry_run: bool = False,
-) -> dict[str, Any]:
-    """Create a single Jira story from sprint YAML.
-
-    Args:
-        epic_jira_key: Parent epic Jira key (e.g., "MSSCI-12077")
-        story_id: Story ID from sprint YAML (e.g., "63-7")
-        sprint_path: Path to sprint YAML (defaults to auto-detect)
-        dry_run: If True, preview without creating
-
-    Returns:
-        {success, jira_key?, error?}
-    """
-    path = sprint_path or _get_sprint_path()
-    data = read_sprint(path)
-
-    # Find the story under the epic
-    epic = None
-    story = None
-    for e in data.get("epics", []):
-        if e.get("jira") == epic_jira_key or e.get("id") == epic_jira_key:
-            epic = e
-            story = find_story(e, story_id)
-            break
-
-    if not epic:
-        return {"success": False, "error": f"Epic {epic_jira_key} not found"}
-    if not story:
-        return {"success": False, "error": f"Story {story_id} not found under epic {epic_jira_key}"}
-
-    # Check if already has Jira key
-    existing_key = story.get("jira")
-    if existing_key:
-        return {"success": False, "error": f"Story already has Jira key: {existing_key}"}
-
-    title = story.get("title", "Untitled")
-    description = story.get("description", "")
-    points = story.get("points", 0)
-    priority = PRIORITY_MAP.get(story.get("priority", "P2"), "Medium")
-
-    if dry_run:
-        print(f"[DRY RUN] Would create: {story_id} - {title}")
-        print(f"  Parent: {epic_jira_key}, Priority: {priority}, Points: {points}")
-        return {"success": True, "dry_run": True, "story_id": story_id}
-
-    client = get_client()
-
-    # Build payload
-    payload = {
-        "fields": {
-            "project": {"key": JIRA_PROJECT},
-            "summary": title,
-            "description": _build_adf_description(description),
-            "issuetype": {"name": "Story"},
-            "parent": {"key": epic_jira_key},
-            "priority": {"name": priority},
-            "labels": [PROJECT_LABEL],
-        }
-    }
-
-    response = client.create_issue_sync(payload)
-    if not response or "key" not in response:
-        return {
-            "success": False,
-            "error": f"Failed to create story: {response}",
-        }
-
-    jira_key = response["key"]
-    print(f"Created: {jira_key} ({title})")
-
-    # Set story points
-    if points and int(points) > 0:
-        client.update_issue_sync(jira_key, {"customfield_10031": int(points)})
-
-    # Add to sprint
-    sprint_info = data.get("sprint", {})
-    sprint_jira_id = sprint_info.get("jira_sprint_id")
-    if sprint_jira_id:
-        client.add_to_sprint_sync(sprint_jira_id, jira_key)
-
-    # Update sprint YAML with new Jira key
-    story["jira"] = jira_key
-    write_sprint(path, data)
-    print("Updated sprint YAML")
-
-    return {"success": True, "jira_key": jira_key}
-
-
-def create_epic_in_jira(
-    epic_id: str,
-    *,
-    sprint_path: Path | None = None,
-    dry_run: bool = False,
-    force: bool = False,
-) -> dict[str, Any]:
-    """Create a Jira epic and its child stories from sprint YAML.
-
-    Args:
-        epic_id: Epic ID from sprint YAML (e.g., "epic-63" or "63")
-        sprint_path: Path to sprint YAML (defaults to auto-detect)
-        dry_run: If True, preview without creating
-        force: If True, create even if duplicate title detected
-
-    Returns:
-        {success, epic_key?, stories: [{id, jira_key}], error?}
-    """
-    path = sprint_path or _get_sprint_path()
-    data = read_sprint(path)
-
-    sprint_data = load_sprint()
-    if not sprint_data:
-        return {"success": False, "error": "Could not load sprint YAML"}
-
-    epic = find_epic(sprint_data, epic_id)
-    if not epic:
-        return {"success": False, "error": f"Epic '{epic_id}' not found in sprint YAML"}
-
-    # Also find it in the ruamel data for mutation
-    epic_ruamel = None
-    for e in data.get("epics", []):
-        eid = str(e.get("id", ""))
-        epic_num = epic_id.replace("epic-", "")
-        if eid == epic_id or eid == f"epic-{epic_id}" or eid == epic_num or eid.replace("epic-", "") == epic_num:
-            epic_ruamel = e
-            break
-
-    if not epic_ruamel:
-        return {"success": False, "error": f"Epic '{epic_id}' not found in ruamel data"}
-
-    # Validate epic shard before any Jira operations (ADR-0022)
-    from pennyfarthing_scripts.sprint.validator import validate_epic_shard
-    validation = validate_epic_shard(dict(epic_ruamel))
-    if not validation.valid:
-        error_msgs = "; ".join(e.message for e in validation.errors)
-        return {"success": False, "error": f"Epic validation failed: {error_msgs}"}
-
-    title = epic.get("title", f"Epic {epic_id}")
-    description = epic.get("description", "")
-    epic_jira_key = epic.get("jira")
-
-    print(f"\nEpic: {title}")
-    print(f"Dry run: {dry_run}\n")
-
-    # Create epic if needed
-    if epic_jira_key:
-        print(f"Epic already exists: {epic_jira_key}")
-    else:
-        if dry_run:
-            print(f"[DRY RUN] Would create epic: {title}")
-            epic_jira_key = "MSSCI-XXXXX"
-        else:
-            client = get_client()
-
-            # Idempotency check: search for existing epic with same title (ADR-0022)
-            try:
-                existing = client.search_issues_sync(
-                    f'project = {JIRA_PROJECT} AND issuetype = Epic AND summary ~ "{title}"'
-                )
-                if existing and not force:
-                    existing_key = existing[0]["key"]
-                    print(f"Found existing epic with same title: {existing_key}")
-                    epic_jira_key = existing_key
-
-                    # Update YAML with existing key
-                    epic_ruamel["jira"] = epic_jira_key
-                    write_sprint(path, data)
-
-                    return {
-                        "success": True,
-                        "epic_key": epic_jira_key,
-                        "duplicate_detected": True,
-                        "stories": [],
-                    }
-                elif existing and force:
-                    import warnings
-                    warnings.warn(
-                        f"Duplicate epic title detected ({existing[0]['key']}), "
-                        "proceeding with --force",
-                        stacklevel=2,
-                    )
-            except Exception as exc:
-                import warnings
-                warnings.warn(
-                    f"Jira search for duplicate titles failed: {exc}",
-                    stacklevel=2,
-                )
-
-            payload = {
-                "fields": {
-                    "project": {"key": JIRA_PROJECT},
-                    "summary": title,
-                    "description": _build_adf_description(description),
-                    "issuetype": {"name": "Epic"},
-                    "labels": [PROJECT_LABEL],
-                }
-            }
-            response = client.create_issue_sync(payload)
-            if not response or "key" not in response:
-                return {"success": False, "error": f"Failed to create epic: {response}"}
-
-            epic_jira_key = response["key"]
-            print(f"Created epic: {epic_jira_key}")
-
-            # Update YAML
-            epic_ruamel["jira"] = epic_jira_key
-            write_sprint(path, data)
-
-    # Create stories
-    print("\nCreating stories...\n")
-
-    stories_created = []
-    stories = epic_ruamel.get("stories", [])
-    for story in stories:
-        if story.get("jira"):
-            continue  # Already has Jira key
-
-        sid = story.get("id", "")
-        story_title = story.get("title", "Untitled")
-
-        if dry_run:
-            print(f"[DRY RUN] Would create: {sid} - {story_title}")
-            stories_created.append({"id": sid, "dry_run": True})
-        else:
-            # Re-read data to pick up previous writes
-            data = read_sprint(path)
-            # Find epic again in fresh data
-            for e in data.get("epics", []):
-                if e.get("jira") == epic_jira_key or e.get("id") == epic_ruamel.get("id"):
-                    for s in e.get("stories", []):
-                        if s.get("id") == sid and not s.get("jira"):
-                            result = create_story_in_jira(
-                                epic_jira_key, sid, sprint_path=path
-                            )
-                            if result.get("success"):
-                                stories_created.append({
-                                    "id": sid,
-                                    "jira_key": result.get("jira_key"),
-                                })
-                            else:
-                                print(
-                                    f"  Error creating {sid}: {result.get('error')}",
-                                    file=sys.stderr,
-                                )
-                    break
-
-    print(f"\nDone. View epic: jira issue view {epic_jira_key}")
-
-    return {
-        "success": True,
-        "epic_key": epic_jira_key,
-        "stories": stories_created,
-    }

package/pennyfarthing_scripts/jira/epic.py

@@ -1,177 +0,0 @@
-"""
-Create Jira epics from Pennyfarthing sprint YAML definitions.
-
-Usage:
-    python -m pennyfarthing_scripts.jira create epic <epic_id> [options]
-
-Options:
-    --dry-run       Show what would be done without making changes
-
-Examples:
-    python -m pennyfarthing_scripts.jira create epic epic-63 --dry-run
-    python -m pennyfarthing_scripts.jira create epic 63
-"""
-
-import argparse
-import json
-import sys
-from typing import Any
-
-from pennyfarthing_scripts.jira.client import JIRA_PROJECT, JiraClient
-from pennyfarthing_scripts.sprint.loader import find_epic
-from pennyfarthing_scripts.sprint.loader import load_sprint as load_current_sprint
-
-
-def parse_args(args: list[str] | None = None) -> argparse.Namespace:
-    """Parse command line arguments.
-
-    Args:
-        args: Command line arguments (defaults to sys.argv[1:])
-
-    Returns:
-        Parsed arguments namespace
-    """
-    parser = argparse.ArgumentParser(
-        description="Create Jira epic from Pennyfarthing sprint YAML"
-    )
-    parser.add_argument("epic_id", help="Epic ID (e.g., epic-63 or 63)")
-    parser.add_argument("--dry-run", action="store_true", help="Show changes without applying")
-
-    return parser.parse_args(args)
-
-
-def build_epic_payload(epic_data: dict[str, Any]) -> dict[str, Any]:
-    """Build Jira API payload for creating an epic.
-
-    Args:
-        epic_data: Epic data from sprint YAML
-
-    Returns:
-        Jira API request payload
-    """
-    title = epic_data.get("title", "")
-    description = epic_data.get("description", "")
-
-    # Build ADF (Atlassian Document Format) for description
-    description_adf = {
-        "type": "doc",
-        "version": 1,
-        "content": [
-            {
-                "type": "paragraph",
-                "content": [{"type": "text", "text": description}] if description else [],
-            }
-        ],
-    }
-
-    return {
-        "fields": {
-            "project": {"key": JIRA_PROJECT},
-            "summary": title,
-            "description": description_adf,
-            "issuetype": {"name": "Epic"},
-        }
-    }
-
-
-def create_epic(
-    title: str,
-    description: str = "",
-    *,
-    dry_run: bool = False,
-) -> dict[str, Any]:
-    """Create a Jira epic.
-
-    Args:
-        title: Epic title/summary
-        description: Epic description
-        dry_run: If True, show changes without applying
-
-    Returns:
-        Result dict with success, key, error fields
-    """
-    epic_data = {"title": title, "description": description}
-    payload = build_epic_payload(epic_data)
-
-    if dry_run:
-        return {
-            "success": True,
-            "dry_run": True,
-            "payload": payload,
-        }
-
-    client = JiraClient()
-    response = client.create_issue_sync(payload)
-
-    if response and "key" in response:
-        return {
-            "success": True,
-            "key": response["key"],
-            "id": response.get("id"),
-        }
-    else:
-        return {
-            "success": False,
-            "error": "Failed to create epic",
-            "response": response,
-        }
-
-
-def create_epic_from_yaml(epic_id: str, *, dry_run: bool = False) -> dict[str, Any]:
-    """Create a Jira epic from sprint YAML definition.
-
-    Args:
-        epic_id: Epic ID (e.g., "epic-63" or "63")
-        dry_run: If True, show changes without applying
-
-    Returns:
-        Result dict with success, key, error fields
-    """
-    sprint_data = load_current_sprint()
-    if not sprint_data:
-        return {"success": False, "error": "Could not load sprint YAML"}
-
-    epic = find_epic(sprint_data, epic_id)
-    if not epic:
-        return {"success": False, "error": f"Epic '{epic_id}' not found in sprint YAML"}
-
-    # Check if epic already has a Jira key
-    if epic.get("jira"):
-        return {
-            "success": False,
-            "error": f"Epic already has Jira key: {epic['jira']}",
-        }
-
-    title = epic.get("title", f"Epic {epic_id}")
-    description = epic.get("description", "")
-
-    return create_epic(title, description, dry_run=dry_run)
-
-
-def main(args: list[str] | None = None) -> int:
-    """CLI entry point.
-
-    Args:
-        args: Command line arguments (defaults to sys.argv[1:])
-
-    Returns:
-        Exit code (0 for success, 1 for failure)
-    """
-    parsed_args = parse_args(args)
-
-    result = create_epic_from_yaml(parsed_args.epic_id, dry_run=parsed_args.dry_run)
-
-    if result["success"]:
-        if result.get("dry_run"):
-            print(f"[DRY-RUN] Would create epic for {parsed_args.epic_id}")
-            print(f"  Payload: {json.dumps(result.get('payload', {}), indent=2)}")
-        else:
-            print(f"Created epic: {result.get('key')}")
-        return 0
-    else:
-        print(f"Failed: {result.get('error', 'Unknown error')}", file=sys.stderr)
-        return 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/pennyfarthing_scripts/jira/operations.py

@@ -1,124 +0,0 @@
-"""
-Jira issue operations: move, assign, link.
-
-Replaces jira-lib.sh functions with REST API calls.
-No interactive prompts, no subprocess stdin issues.
-
-Usage:
-    pf jira move MSSCI-12345 "In Progress"
-    pf jira assign MSSCI-12345 keith.avery@1898andco.io
-    pf jira link MSSCI-12345 MSSCI-12346 "Blocks"
-"""
-
-from typing import Any
-
-from pennyfarthing_scripts.jira.client import (
-    get_client,
-    get_jira_field,
-    map_github_to_jira,
-)
-
-
-def move_issue(
-    issue_key: str,
-    target_status: str,
-    *,
-    dry_run: bool = False,
-) -> dict[str, Any]:
-    """Transition a Jira issue to a new status.
-
-    Checks current status first to avoid redundant transitions.
-
-    Args:
-        issue_key: Jira issue key (e.g., "MSSCI-12345")
-        target_status: Target status name (e.g., "In Progress", "Done")
-        dry_run: If True, preview without applying
-
-    Returns:
-        {success, error?, already_at_status?}
-    """
-    client = get_client()
-
-    # Check current status
-    issue = client.get_issue_sync(issue_key)
-    if issue:
-        current_status = get_jira_field(issue, "fields.status.name", "")
-        if current_status.lower() == target_status.lower():
-            return {"success": True, "already_at_status": True}
-
-    if dry_run:
-        print(f"[DRY RUN] Would move {issue_key} to '{target_status}'")
-        return {"success": True, "dry_run": True}
-
-    return client.transition_sync(issue_key, target_status)
-
-
-def assign_issue(
-    issue_key: str,
-    assignee: str | None,
-    *,
-    dry_run: bool = False,
-) -> dict[str, Any]:
-    """Assign a Jira issue to a user.
-
-    Accepts email address or GitHub username (will be mapped).
-    Checks current assignee to avoid redundant assignments.
-
-    Args:
-        issue_key: Jira issue key
-        assignee: Email, GitHub username, or None to unassign
-        dry_run: If True, preview without applying
-
-    Returns:
-        {success, error?, already_assigned?}
-    """
-    if not assignee or assignee in ("null", "x", "none"):
-        assignee_email = None
-    elif "@" in assignee:
-        assignee_email = assignee
-    else:
-        # Try GitHub username mapping
-        assignee_email = map_github_to_jira(assignee)
-
-    client = get_client()
-
-    # Check current assignee
-    if assignee_email:
-        issue = client.get_issue_sync(issue_key)
-        if issue:
-            current_email = get_jira_field(issue, "fields.assignee.emailAddress", "")
-            if current_email == assignee_email:
-                return {"success": True, "already_assigned": True}
-
-    if dry_run:
-        action = f"assign {issue_key} to {assignee_email}" if assignee_email else f"unassign {issue_key}"
-        print(f"[DRY RUN] Would {action}")
-        return {"success": True, "dry_run": True}
-
-    return client.assign_issue_sync(issue_key, assignee_email)
-
-
-def link_issues(
-    inward_key: str,
-    outward_key: str,
-    link_type: str = "Relates",
-    *,
-    dry_run: bool = False,
-) -> dict[str, Any]:
-    """Link two Jira issues.
-
-    Args:
-        inward_key: Inward issue key (parent/blocker)
-        outward_key: Outward issue key (child/blocked)
-        link_type: Link type (e.g., "Relates", "Blocks", "Parent-Child")
-        dry_run: If True, preview without applying
-
-    Returns:
-        {success, error?}
-    """
-    if dry_run:
-        print(f"[DRY RUN] Would link {inward_key} -> {outward_key} ({link_type})")
-        return {"success": True, "dry_run": True}
-
-    client = get_client()
-    return client.link_issues_sync(inward_key, outward_key, link_type)