@pennyfarthing/core 11.4.0 → 12.0.0

package/pennyfarthing-dist/pf/sprint/story_finish.py

@@ -1,239 +0,0 @@
-"""Finish a completed story: archive, merge PR, update Jira, update YAML.
-
-Replaces finish-story.sh with native Python that correctly handles
-sharded epic YAML files via read_sprint/write_sprint.
-
-Steps:
-  1. Archive session file to sprint/archive/{jira-key}-session.md
-  2. Squash merge PR via gh (handle already-merged)
-  3. Transition Jira to Done
-  4. Update sprint YAML (status: done, completed date)
-  5. Archive completed epics
-  6. Git cleanup (checkout develop, pull, delete local branch)
-  7. Remove session file
-"""
-
-import re
-import shutil
-import subprocess
-import sys
-from datetime import date
-from pathlib import Path
-from typing import Any
-
-from pf.sprint.loader import find_epic, find_story
-from pf.sprint.yaml_io import read_sprint, write_sprint
-
-SESSION_FIELD_RE = re.compile(r"\*\*(\w[\w\s]*):\*\*\s*(.*)")
-
-
-def _parse_session(session_path: Path) -> dict[str, str]:
-    """Extract metadata fields from a session markdown file.
-
-    Parses lines like ``**Jira:** MSSCI-14467`` and
-    ``**PR:** #748 - title`` into a dict.
-    """
-    fields: dict[str, str] = {}
-    if not session_path.exists():
-        return fields
-    for line in session_path.read_text().splitlines():
-        m = SESSION_FIELD_RE.search(line)
-        if m:
-            key = m.group(1).strip().lower()
-            value = m.group(2).strip()
-            fields[key] = value
-    return fields
-
-
-def _extract_jira_key(fields: dict[str, str]) -> str | None:
-    """Get Jira key from session fields, handling markdown link format."""
-    raw = fields.get("jira", "")
-    # Strip markdown link: [MSSCI-14467](https://...)
-    raw = re.sub(r"\[([^\]]+)\].*", r"\1", raw).strip()
-    if re.match(r"^MSSCI-\d+$", raw):
-        return raw
-    return None
-
-
-def _extract_pr_number(fields: dict[str, str]) -> str | None:
-    """Get PR number from session fields like ``#748 - title``."""
-    raw = fields.get("pr", "")
-    m = re.search(r"#(\d+)", raw)
-    return m.group(1) if m else None
-
-
-def _extract_branch(fields: dict[str, str]) -> str | None:
-    """Get branch name, stripping trailing annotations like ``(pushed)``."""
-    raw = fields.get("branch", "")
-    return re.sub(r"\s*\(.*\)\s*$", "", raw).strip() or None
-
-
-def _run(cmd: list[str], **kwargs: Any) -> subprocess.CompletedProcess[str]:
-    """Run a subprocess with sane defaults."""
-    return subprocess.run(cmd, capture_output=True, text=True, **kwargs)
-
-
-def finish_story(
-    project_root: Path,
-    story_id: str,
-    *,
-    dry_run: bool = False,
-) -> dict[str, Any]:
-    """Finish a story: archive, merge, update Jira, update YAML, clean up.
-
-    Args:
-        project_root: Project root directory.
-        story_id: Story ID (e.g., "83-2").
-        dry_run: If True, report what would happen without side-effects.
-
-    Returns:
-        Result dict ``{success, data?, error?, steps?}``.
-    """
-    session_path = project_root / ".session" / f"{story_id}-session.md"
-    sprint_path = project_root / "sprint" / "current-sprint.yaml"
-    archive_dir = project_root / "sprint" / "archive"
-    archive_dir.mkdir(parents=True, exist_ok=True)
-
-    # --- Validate session ---
-    if not session_path.exists():
-        return {"success": False, "error": f"Session file not found: {session_path}"}
-
-    fields = _parse_session(session_path)
-    jira_key = _extract_jira_key(fields)
-    branch = _extract_branch(fields)
-    pr_number = _extract_pr_number(fields)
-
-    # Fallback: resolve Jira key from sprint YAML
-    if not jira_key:
-        try:
-            data = read_sprint(sprint_path)
-            parts = story_id.split("-")
-            if len(parts) >= 2:
-                epic = find_epic(data, parts[0])
-                story = find_story(epic, story_id) if epic else None
-                if story:
-                    jira_key = story.get("jira")
-        except Exception:
-            pass
-
-    # Fallback: resolve PR from GitHub if not in session
-    if not pr_number and branch:
-        result = _run(["gh", "pr", "list", "--head", branch, "--json", "number", "--jq", ".[0].number"])
-        if result.returncode == 0 and result.stdout.strip():
-            pr_number = result.stdout.strip()
-
-    today = date.today().isoformat()
-    steps: list[dict[str, Any]] = []
-    archive_name = f"{jira_key}-session.md" if jira_key else f"{story_id}-session.md"
-
-    # Check for dialogue file
-    dialogue_path = project_root / ".session" / f"{story_id}-dialogue.md"
-    dialogue_archive_name = (
-        f"{jira_key}-dialogue.md" if jira_key else f"{story_id}-dialogue.md"
-    )
-
-    if dry_run:
-        from pf.common.pr_config import get_pr_merge_mode
-
-        steps.append({"step": 1, "action": f"Archive session → {archive_dir / archive_name}"})
-        if dialogue_path.exists():
-            steps.append({"step": "1b", "action": f"Archive dialogue → {archive_dir / dialogue_archive_name}"})
-        if pr_number and get_pr_merge_mode() == "human":
-            steps.append({"step": 2, "action": f"PR #{pr_number} — waiting for human review and merge"})
-        elif pr_number:
-            steps.append({"step": 2, "action": f"Merge PR #{pr_number} (squash, delete branch)"})
-        else:
-            steps.append({"step": 2, "action": "No PR to merge"})
-        if jira_key:
-            steps.append({"step": 3, "action": f"Transition {jira_key} to Done"})
-        else:
-            steps.append({"step": 3, "action": "Skip Jira transition (no key)"})
-        steps.append({"step": 4, "action": f"Update sprint YAML (status: done, completed: {today})"})
-        steps.append({"step": 5, "action": "Archive completed epics"})
-        steps.append({"step": 6, "action": f"Delete local branch: {branch}"})
-        steps.append({"step": 7, "action": "Remove session file"})
-        return {"success": True, "dry_run": True, "jira_key": jira_key, "steps": steps}
-
-    # --- Step 1: Archive session ---
-    archive_dest = archive_dir / archive_name
-    shutil.copy2(session_path, archive_dest)
-    steps.append({"step": 1, "action": "archive_session", "dest": str(archive_dest)})
-
-    # --- Step 1b: Archive dialogue (if exists) ---
-    if dialogue_path.exists():
-        dialogue_dest = archive_dir / dialogue_archive_name
-        shutil.copy2(dialogue_path, dialogue_dest)
-        steps.append({"step": "1b", "action": "archive_dialogue", "dest": str(dialogue_dest)})
-
-    # --- Step 2: Merge PR ---
-    from pf.common.pr_config import get_pr_merge_mode
-
-    pr_merge_mode = get_pr_merge_mode()
-    if pr_number and pr_merge_mode == "human":
-        steps.append({
-            "step": 2, "action": "merge_pr", "pr": pr_number,
-            "mode": "human", "message": f"PR #{pr_number} ready for human review and merge",
-        })
-    elif pr_number:
-        result = _run(["gh", "pr", "merge", pr_number, "--squash", "--delete-branch"])
-        if result.returncode == 0:
-            steps.append({"step": 2, "action": "merge_pr", "pr": pr_number})
-        else:
-            steps.append({"step": 2, "action": "merge_pr", "pr": pr_number, "warning": "Already merged or failed"})
-    else:
-        steps.append({"step": 2, "action": "merge_pr", "skipped": True})
-
-    # --- Step 3: Transition Jira ---
-    if jira_key:
-        result = _run(["jira", "issue", "move", jira_key, "Done"])
-        if result.returncode == 0:
-            steps.append({"step": 3, "action": "jira_done", "key": jira_key})
-        else:
-            steps.append({"step": 3, "action": "jira_done", "key": jira_key, "warning": "Already Done or failed"})
-    else:
-        steps.append({"step": 3, "action": "jira_done", "skipped": True, "warning": "No Jira key available"})
-
-    # --- Step 4: Update sprint YAML ---
-    try:
-        data = read_sprint(sprint_path)
-        parts = story_id.split("-")
-        if len(parts) < 2:
-            steps.append({"step": 4, "action": "yaml_update", "error": f"Invalid story ID: {story_id}"})
-        else:
-            epic = find_epic(data, parts[0])
-            story = find_story(epic, story_id) if epic else None
-            if story:
-                story["status"] = "done"
-                story["completed"] = today
-                write_sprint(sprint_path, data)
-                steps.append({"step": 4, "action": "yaml_update", "status": "done", "completed": today})
-            else:
-                steps.append({"step": 4, "action": "yaml_update", "warning": f"Story {story_id} not found in YAML"})
-    except Exception as exc:
-        steps.append({"step": 4, "action": "yaml_update", "error": str(exc)})
-
-    # --- Step 5: Archive completed epics ---
-    result = _run(
-        [sys.executable, "-m", "pf.cli", "sprint", "epic", "archive"],
-        cwd=str(project_root),
-    )
-    steps.append({"step": 5, "action": "archive_epics", "ran": True})
-
-    # --- Step 6: Git cleanup ---
-    _run(["git", "checkout", "develop"], cwd=str(project_root))
-    _run(["git", "pull", "origin", "develop"], cwd=str(project_root))
-    if branch:
-        _run(["git", "branch", "-d", branch], cwd=str(project_root))
-    steps.append({"step": 6, "action": "git_cleanup", "branch": branch})
-
-    # --- Step 7: Remove session file ---
-    if session_path.exists():
-        session_path.unlink()
-    steps.append({"step": 7, "action": "remove_session"})
-
-    return {
-        "success": True,
-        "story_id": story_id,
-        "jira_key": jira_key,
-        "steps": steps,
-    }

package/pennyfarthing-dist/pf/sprint/story_update.py

@@ -1,222 +0,0 @@
-"""Sprint story update command.
-
-Story: MSSCI-14257 - Sprint story update command
-
-This module provides:
-- update_story(sprint_path, story_id, ...) -> dict
-- story_update_command (Click command for CLI registration)
-"""
-
-import subprocess
-from datetime import date
-from pathlib import Path
-from typing import Any
-
-import click
-
-from pf.sprint.loader import find_epic, find_story
-from pf.sprint.validator import VALID_STORY_STATUSES, validate_full_sprint
-from pf.sprint.yaml_io import read_sprint, write_sprint
-
-
-def update_story(
-    sprint_path: Path,
-    story_id: str,
-    *,
-    status: str | None = None,
-    points: int | None = None,
-    priority: str | None = None,
-    assigned_to: str | None = None,
-    completed_date: str | None = None,
-    started_date: str | None = None,
-    workflow: str | None = None,
-    description: str | None = None,
-    review_findings: str | None = None,
-    review_verdict: str | None = None,
-    dry_run: bool = False,
-) -> dict[str, Any]:
-    """Update fields on a story in the sprint YAML.
-
-    Args:
-        sprint_path: Path to sprint YAML file
-        story_id: Story ID (e.g., "76-4")
-        status: New status value
-        points: New points value
-        priority: New priority value
-        assigned_to: New assignee
-        completed_date: Completed date (ISO format)
-        started_date: Started date (ISO format)
-        workflow: Workflow type (tdd, trivial, bdd, agent-docs)
-        description: Story description text
-        review_findings: Reviewer findings text
-        review_verdict: Review verdict (approved, rejected, pending)
-        dry_run: If True, report changes without writing
-
-    Returns:
-        Dict with success status and optional error
-    """
-    # Validate status before reading file
-    if status is not None and status not in VALID_STORY_STATUSES:
-        return {
-            "success": False,
-            "error": f"Invalid status '{status}'. Must be one of: {', '.join(sorted(VALID_STORY_STATUSES))}",
-        }
-
-    # Parse story ID to find epic
-    parts = story_id.split("-")
-    if len(parts) < 2:
-        return {
-            "success": False,
-            "error": f"Invalid story ID format '{story_id}'. Expected format: <epic>-<seq> (e.g., '76-4')",
-        }
-
-    epic_num = parts[0]
-
-    data = read_sprint(sprint_path)
-
-    epic = find_epic(data, epic_num)
-    if epic is None:
-        return {
-            "success": False,
-            "error": f"Epic '{epic_num}' not found for story '{story_id}'",
-        }
-
-    story = find_story(epic, story_id)
-    if story is None:
-        return {
-            "success": False,
-            "error": f"Story '{story_id}' not found in epic '{epic_num}'",
-        }
-
-    # Apply field updates
-    if status is not None:
-        story["status"] = status
-    if points is not None:
-        story["points"] = points
-    if priority is not None:
-        story["priority"] = priority
-    if assigned_to is not None:
-        story["assigned_to"] = assigned_to
-    if completed_date is not None:
-        story["completed"] = completed_date
-    if started_date is not None:
-        story["started"] = started_date
-    if workflow is not None:
-        story["workflow"] = workflow
-    if description is not None:
-        story["description"] = description
-    if review_findings is not None:
-        story["review_findings"] = review_findings
-    if review_verdict is not None:
-        if review_verdict not in ("approved", "rejected", "pending"):
-            return {
-                "success": False,
-                "error": f"Invalid review_verdict '{review_verdict}'. Must be one of: approved, rejected, pending",
-            }
-        story["review_verdict"] = review_verdict
-
-    # Auto-cleanup rules
-    if status == "done":
-        # Auto-set completed if not explicitly provided
-        if completed_date is None and "completed" not in story:
-            story["completed"] = date.today().isoformat()
-        elif completed_date is not None:
-            story["completed"] = completed_date
-
-    if status == "in_progress":
-        # Auto-set started if not already present
-        if "started" not in story:
-            story["started"] = date.today().isoformat()
-        # Auto-set assignee from current Jira user if not already assigned
-        if "assigned_to" not in story and assigned_to is None:
-            try:
-                result = subprocess.run(
-                    ["jira", "me"], capture_output=True, text=True
-                )
-                if result.returncode == 0 and result.stdout.strip():
-                    story["assigned_to"] = result.stdout.strip()
-            except Exception:
-                pass
-
-    # Validate after mutation
-    result = validate_full_sprint(data)
-    if not result.valid:
-        return {
-            "success": False,
-            "error": f"Validation failed after update: {result.errors}",
-        }
-
-    if dry_run:
-        return {
-            "success": True,
-            "dry_run": True,
-            "story_id": story_id,
-        }
-
-    write_sprint(sprint_path, data)
-
-    return {
-        "success": True,
-        "story_id": story_id,
-    }
-
-
-@click.command("update")
-@click.argument("story_id")
-@click.option("--status", type=click.Choice(["backlog", "ready", "in_progress", "done", "canceled"]))
-@click.option("--completed", "completed_date", default=None)
-@click.option("--assigned-to", default=None)
-@click.option("--points", type=int, default=None)
-@click.option("--priority", default=None)
-@click.option("--started", "started_date", default=None)
-@click.option("--workflow", default=None)
-@click.option("--description", default=None, help="Story description text")
-@click.option("--review-findings", default=None, help="Reviewer findings text")
-@click.option("--review-verdict", type=click.Choice(["approved", "rejected", "pending"]), default=None)
-@click.option("--dry-run", is_flag=True)
-@click.option("--sprint-file", type=click.Path(), default=None, help="Path to sprint YAML file")
-def story_update_command(
-    story_id: str,
-    status: str | None,
-    completed_date: str | None,
-    assigned_to: str | None,
-    points: int | None,
-    priority: str | None,
-    started_date: str | None,
-    workflow: str | None,
-    description: str | None,
-    review_findings: str | None,
-    review_verdict: str | None,
-    dry_run: bool,
-    sprint_file: str | None,
-) -> None:
-    """Update a story's fields by ID."""
-    if sprint_file is None:
-        from pf.common.config import get_project_root
-        path = get_project_root() / "sprint" / "current-sprint.yaml"
-    else:
-        path = Path(sprint_file)
-
-    result = update_story(
-        sprint_path=path,
-        story_id=story_id,
-        status=status,
-        points=points,
-        priority=priority,
-        assigned_to=assigned_to,
-        completed_date=completed_date,
-        started_date=started_date,
-        workflow=workflow,
-        description=description,
-        review_findings=review_findings,
-        review_verdict=review_verdict,
-        dry_run=dry_run,
-    )
-
-    if result["success"]:
-        if result.get("dry_run"):
-            click.echo(f"[DRY-RUN] Would update story {result['story_id']}")
-        else:
-            click.echo(f"Updated story {result['story_id']}")
-    else:
-        raise click.ClickException(result["error"])