@pennyfarthing/core 10.0.5 → 10.1.0

package/pennyfarthing_scripts/sprint/story_add.py

@@ -5,6 +5,7 @@ Story: MSSCI-14256 - Sprint story add command
 This module provides:
 - generate_story_id(sprint_data, epic) -> str
 - add_story(sprint_path, epic_id, title, points, ...) -> dict
+- add_initiative_story(initiative_slug, title, points, ...) -> dict
 - story_add_command (Click command for CLI registration)
 """
 
@@ -144,44 +145,218 @@ def add_story(
     }
 
 
+def _generate_initiative_story_id(init_data: dict[str, Any], slug: str) -> str:
+    """Generate the next standalone story ID for an initiative.
+
+    Uses the pattern {slug-prefix}-{N} where slug-prefix is derived from
+    the initiative slug (e.g., "technical-debt" -> "td", "quality-scale" -> "qs").
+    Only counts existing stories that share the same prefix.
+
+    Args:
+        init_data: Initiative YAML data
+        slug: Initiative slug (e.g., "technical-debt")
+
+    Returns:
+        Next story ID string (e.g., "td-2")
+    """
+    # Build prefix from initiative slug initials
+    parts = slug.split("-")
+    prefix = "".join(p[0] for p in parts if p)
+
+    stories = init_data.get("standalone_stories", [])
+    max_seq = 0
+    for story in stories:
+        story_id = str(story.get("id", ""))
+        # Only count stories with matching prefix
+        if not story_id.startswith(f"{prefix}-"):
+            continue
+        suffix = story_id[len(prefix) + 1:]
+        try:
+            seq = int(suffix)
+            if seq > max_seq:
+                max_seq = seq
+        except ValueError:
+            pass
+
+    return f"{prefix}-{max_seq + 1}"
+
+
+def add_initiative_story(
+    initiative_slug: str,
+    title: str,
+    points: int,
+    *,
+    story_type: str | None = None,
+    priority: str = "P1",
+    workflow: str = "tdd",
+    jira: str | None = None,
+    repos: str = "pennyfarthing",
+) -> dict[str, Any]:
+    """Add a standalone story to an initiative YAML file.
+
+    Args:
+        initiative_slug: Initiative slug (e.g., "technical-debt")
+        title: Story title
+        points: Story points
+        story_type: Optional story type (feature, bug, chore, refactor)
+        priority: Priority (default: P1)
+        workflow: Workflow (default: tdd)
+        jira: Optional Jira key
+        repos: Repos (default: pennyfarthing)
+
+    Returns:
+        Dict with success status and story_id or error
+    """
+    from pennyfarthing_scripts.common.config import get_project_root
+
+    root = get_project_root()
+    init_path = root / "sprint" / f"initiative-{initiative_slug}.yaml"
+
+    if not init_path.exists():
+        available = [
+            f.stem.replace("initiative-", "")
+            for f in (root / "sprint").glob("initiative-*.yaml")
+        ]
+        return {
+            "success": False,
+            "error": f"Initiative '{initiative_slug}' not found. Available: {', '.join(sorted(available))}",
+        }
+
+    # Use ruamel.yaml to preserve block scalars and formatting
+    from ruamel.yaml import YAML as RuamelYAML
+
+    ryml = RuamelYAML()
+    ryml.preserve_quotes = True
+    ryml.default_flow_style = False
+    ryml.indent(mapping=2, sequence=4, offset=2)
+    ryml.width = 4096
+
+    with open(init_path) as f:
+        init_data = ryml.load(f)
+
+    if not init_data:
+        return {"success": False, "error": f"Empty initiative file: {init_path}"}
+
+    story_id = _generate_initiative_story_id(init_data, initiative_slug)
+
+    story: dict[str, Any] = {
+        "id": story_id,
+        "title": title,
+        "points": points,
+        "priority": priority,
+        "status": "backlog",
+        "repos": repos,
+        "workflow": workflow,
+    }
+    if jira is not None:
+        story["jira"] = jira
+    if story_type is not None:
+        story["type"] = story_type
+
+    if "standalone_stories" not in init_data:
+        init_data["standalone_stories"] = []
+    init_data["standalone_stories"].append(story)
+
+    # Update total_points
+    current_total = init_data.get("total_points", 0) or 0
+    init_data["total_points"] = current_total + points
+
+    with open(init_path, "w") as f:
+        ryml.dump(init_data, f)
+
+    return {
+        "success": True,
+        "story_id": story_id,
+    }
+
+
 @click.command("add")
-@click.argument("epic_id", type=str)
-@click.argument("title", type=str)
-@click.argument("points", type=int)
+@click.argument("epic_id", type=str, required=False)
+@click.argument("title", type=str, required=False)
+@click.argument("points", type=int, required=False)
 @click.option("--type", "story_type", type=click.Choice(["feature", "bug", "chore", "refactor"]), default="feature")
 @click.option("--priority", type=click.Choice(["P0", "P1", "P2", "P3"]), default="P1")
 @click.option("--workflow", type=click.Choice(["tdd", "trivial", "bdd"]), default="tdd")
 @click.option("--jira", "jira_id", type=str, default=None)
 @click.option("--sprint-file", type=click.Path(), default=None, help="Path to sprint YAML file")
+@click.option("--initiative", type=str, default=None, help="Add as standalone story to initiative (e.g., technical-debt)")
+@click.option("--repos", type=str, default="pennyfarthing", help="Repos (default: pennyfarthing)")
 def story_add_command(
-    epic_id: str,
-    title: str,
-    points: int,
+    epic_id: str | None,
+    title: str | None,
+    points: int | None,
     story_type: str,
     priority: str,
     workflow: str,
     jira_id: str | None,
     sprint_file: str | None,
+    initiative: str | None,
+    repos: str,
 ) -> None:
-    """Add a new story to an epic."""
-    if sprint_file is None:
-        from pennyfarthing_scripts.common.config import get_project_root
-        path = get_project_root() / "sprint" / "current-sprint.yaml"
-    else:
-        path = Path(sprint_file)
-
-    result = add_story(
-        sprint_path=path,
-        epic_id=epic_id,
-        title=title,
-        points=points,
-        story_type=story_type if story_type != "feature" else None,
-        priority=priority,
-        workflow=workflow,
-        jira=jira_id,
-    )
-
-    if result["success"]:
-        click.echo(f"Added story {result['story_id']}: {title} [{points}pts]")
+    """Add a new story to an epic or initiative.
+
+    \b
+    Epic mode (default):
+      pf sprint story add <EPIC_ID> <TITLE> <POINTS>
+
+    Initiative mode (--initiative):
+      pf sprint story add --initiative <SLUG> <TITLE> <POINTS>
+    """
+    if initiative:
+        # Initiative mode: first positional arg is title, second is points
+        # epic_id absorbs the title, title absorbs points (as str)
+        if epic_id is None:
+            raise click.ClickException("TITLE is required")
+        init_title = epic_id
+        if title is None:
+            raise click.ClickException("POINTS is required")
+        try:
+            init_points = int(title)
+        except ValueError:
+            raise click.ClickException(f"POINTS must be an integer, got '{title}'")
+
+        result = add_initiative_story(
+            initiative_slug=initiative,
+            title=init_title,
+            points=init_points,
+            story_type=story_type if story_type != "feature" else None,
+            priority=priority,
+            workflow=workflow,
+            jira=jira_id,
+            repos=repos,
+        )
+
+        if result["success"]:
+            click.echo(f"Added story {result['story_id']}: {init_title} [{init_points}pts] to initiative {initiative}")
+        else:
+            raise click.ClickException(result["error"])
     else:
-        raise click.ClickException(result["error"])
+        # Epic mode: all three positional args required
+        if epic_id is None:
+            raise click.ClickException("EPIC_ID is required")
+        if title is None:
+            raise click.ClickException("TITLE is required")
+        if points is None:
+            raise click.ClickException("POINTS is required")
+
+        if sprint_file is None:
+            from pennyfarthing_scripts.common.config import get_project_root
+            path = get_project_root() / "sprint" / "current-sprint.yaml"
+        else:
+            path = Path(sprint_file)
+
+        result = add_story(
+            sprint_path=path,
+            epic_id=epic_id,
+            title=title,
+            points=points,
+            story_type=story_type if story_type != "feature" else None,
+            priority=priority,
+            workflow=workflow,
+            jira=jira_id,
+        )
+
+        if result["success"]:
+            click.echo(f"Added story {result['story_id']}: {title} [{points}pts]")
+        else:
+            raise click.ClickException(result["error"])

package/pennyfarthing_scripts/sprint/story_finish.py

@@ -0,0 +1,211 @@
+"""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, remove assigned_to)
+  5. Archive completed epics
+  6. Git cleanup (checkout develop, pull, delete local branch)
+  7. Remove session file
+"""
+
+import re
+import shutil
+import subprocess
+from datetime import date
+from pathlib import Path
+from typing import Any
+
+from pennyfarthing_scripts.sprint.loader import find_epic, find_story
+from pennyfarthing_scripts.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
+
+    if not jira_key:
+        return {"success": False, "error": f"Could not determine Jira key for {story_id}"}
+
+    # 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]] = []
+
+    if dry_run:
+        steps.append({"step": 1, "action": f"Archive session → {archive_dir / f'{jira_key}-session.md'}"})
+        if 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"})
+        steps.append({"step": 3, "action": f"Transition {jira_key} to Done"})
+        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 / f"{jira_key}-session.md"
+    shutil.copy2(session_path, archive_dest)
+    steps.append({"step": 1, "action": "archive_session", "dest": str(archive_dest)})
+
+    # --- Step 2: Merge PR ---
+    if 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 ---
+    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"})
+
+    # --- 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
+                if "assigned_to" in story:
+                    del story["assigned_to"]
+                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(
+        ["python", "-m", "pennyfarthing_scripts.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_scripts/sprint/work.py

@@ -35,6 +35,20 @@ def check_story(story_id: str) -> dict[str, Any]:
     status = story.get("status", "backlog")
     assigned = story.get("assigned_to")
 
+    # Check if assigned to someone else
+    if assigned:
+        from pennyfarthing_scripts.jira.client import get_current_user_email
+
+        current_user = get_current_user_email()
+        if assigned != current_user:
+            return {
+                "available": False,
+                "type": "story",
+                "story": story,
+                "reason": f"Assigned to {assigned}",
+                "assigned_to": assigned,
+            }
+
     # Check if already in progress
     if status == "in_progress":
         return {
@@ -78,15 +92,22 @@ def get_next_story() -> dict[str, Any]:
     """Get the highest priority available story.
 
     Considers stories with backlog, ready, or planning status.
+    Excludes stories assigned to other users.
 
     Returns:
         Dict with next story details or error
     """
+    from pennyfarthing_scripts.jira.client import get_current_user_email
     from pennyfarthing_scripts.sprint.loader import get_all_stories
 
+    current_user = get_current_user_email()
     all_stories = get_all_stories()
     available_statuses = {"backlog", "ready", "planning"}
-    backlog = [s for s in all_stories if s.get("status") in available_statuses]
+    backlog = [
+        s for s in all_stories
+        if s.get("status") in available_statuses
+        and (not s.get("assigned_to") or s.get("assigned_to") == current_user)
+    ]
 
     if not backlog:
         return {
@@ -94,11 +115,14 @@ def get_next_story() -> dict[str, Any]:
             "error": "No stories in backlog",
         }
 
-    # Sort by priority (P0 > P1 > P2 > P3)
+    # Sort by priority (P0 > P1 > P2 > P3), preferring own assignments
     priority_order = {"P0": 0, "P1": 1, "P2": 2, "P3": 3}
     sorted_stories = sorted(
         backlog,
-        key=lambda s: priority_order.get(s.get("priority", "P2"), 2),
+        key=lambda s: (
+            0 if s.get("assigned_to") == current_user else 1,
+            priority_order.get(s.get("priority", "P2"), 2),
+        ),
     )
 
     next_story = sorted_stories[0]