@pennyfarthing/core 10.0.3 → 10.1.0

package/pennyfarthing_scripts/healthscore/models.py

@@ -0,0 +1,44 @@
+"""
+Data models for health score analysis results.
+
+Follows ADR-0008 result pattern — structured dataclasses with success/error fields.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+# Default weights for each dimension (must sum to 1.0)
+DEFAULT_WEIGHTS: dict[str, float] = {
+    "churn": 0.15,
+    "todo_density": 0.15,
+    "complexity": 0.15,
+    "test_gaps": 0.15,
+    "dead_code": 0.10,
+    "deprecation_debt": 0.10,
+    "dependency_freshness": 0.10,
+    "agent_context_efficiency": 0.10,
+}
+
+
+@dataclass
+class DimensionScore:
+    """Score for a single health dimension."""
+
+    name: str
+    score: float | None = None  # 0-100, None if unavailable
+    weight: float = 0.0
+    error: str | None = None
+
+
+@dataclass
+class HealthscoreResult:
+    """Composite health score following ADR-0008 pattern."""
+
+    success: bool
+    composite_score: float = 0.0  # 0-100 weighted average
+    target_path: str = ""
+    dimensions: list[DimensionScore] = field(default_factory=list)
+    cached: bool = False
+    error: str | None = None

package/pennyfarthing_scripts/hotspots/analyze.py

@@ -39,6 +39,26 @@ DEFAULT_EXCLUDES = [
     "*.map",
     "package-lock.json",
     "pnpm-lock.yaml",
+    # Dotfiles
+    ".*",
+    # Images
+    "*.png",
+    "*.jpg",
+    "*.jpeg",
+    "*.gif",
+    "*.svg",
+    "*.ico",
+    # Fonts
+    "*.woff",
+    "*.woff2",
+    "*.ttf",
+    "*.eot",
+    # Generated files
+    "*.d.ts",
+    "*.snap",
+    "*.d.ts.map",
+    # CI config
+    ".github/*",
 ]
 
 # Regex for identifying bug-fix commits
@@ -422,6 +442,7 @@ async def analyze_all_repos(
     days: int = 90,
     excludes: list[str] | None = None,
     branch: str = "--all",
+    skip_types: list[str] | None = None,
 ) -> MultiRepoHotspotResult:
     """Analyze all repos found under project root in parallel.
 
@@ -432,13 +453,14 @@ async def analyze_all_repos(
         days: Time window in days
         excludes: Additional file patterns to exclude
         branch: Branch spec
+        skip_types: Repo types to exclude (e.g. ["orchestrator"])
 
     Returns:
         MultiRepoHotspotResult with per-repo results
     """
     from pennyfarthing_scripts.common.config import load_yaml_config
 
-    repos_yaml = load_yaml_config(project_root / "repos.yaml")
+    repos_yaml = load_yaml_config(project_root / ".pennyfarthing" / "repos.yaml")
 
     repos: list[tuple[str, Path]] = []
 
@@ -446,6 +468,11 @@ async def analyze_all_repos(
         # Extract repos from repos.yaml
         for repo_name, repo_config in repos_yaml.items():
             if isinstance(repo_config, dict):
+                # Filter by type if skip_types is provided
+                if skip_types:
+                    repo_type = repo_config.get("type")
+                    if repo_type and repo_type in skip_types:
+                        continue
                 repo_path = repo_config.get("path", repo_name)
             else:
                 repo_path = str(repo_config)

package/pennyfarthing_scripts/hotspots/cli.py

@@ -38,15 +38,17 @@ def _common_options(fn):
     fn = click.option("--output", "output_file", type=click.Path(), help="Write output to file")(fn)
     fn = click.option("--exclude", multiple=True, help="Additional exclude patterns (repeatable)")(fn)
     fn = click.option("--branch", default="--all", show_default=True, help="Branch spec for git log")(fn)
+    fn = click.option("--skip-type", "skip_type", multiple=True, help="Skip repos by type (repeatable, e.g. --skip-type orchestrator)")(fn)
     return fn
 
 
-def _run_analysis(repo: str | None, repo_path: str | None, days: int, exclude: tuple, branch: str):
+def _run_analysis(repo: str | None, repo_path: str | None, days: int, exclude: tuple, branch: str, skip_type: tuple = ()):
     """Run analysis and return result."""
     from pennyfarthing_scripts.hotspots.analyze import analyze_all_repos, analyze_repo
     from pennyfarthing_scripts.common.config import get_project_root
 
     excludes = list(exclude) if exclude else None
+    skip_types = list(skip_type) if skip_type else None
 
     if repo_path:
         # Standalone analysis of a specific path
@@ -56,7 +58,7 @@ def _run_analysis(repo: str | None, repo_path: str | None, days: int, exclude: t
         # Single named repo from project
         project_root = get_project_root()
         from pennyfarthing_scripts.common.config import load_yaml_config
-        repos_yaml = load_yaml_config(project_root / "repos.yaml")
+        repos_yaml = load_yaml_config(project_root / ".pennyfarthing" / "repos.yaml")
         if repos_yaml and repo in repos_yaml:
             cfg = repos_yaml[repo]
             rpath = cfg.get("path", repo) if isinstance(cfg, dict) else str(cfg)
@@ -75,7 +77,7 @@ def _run_analysis(repo: str | None, repo_path: str | None, days: int, exclude: t
         # All repos
         project_root = get_project_root()
         return asyncio.run(
-            analyze_all_repos(project_root, days, excludes, branch)
+            analyze_all_repos(project_root, days, excludes, branch, skip_types)
         )
 
 
@@ -130,23 +132,23 @@ def _output_result(result, fmt: str, output_file: str | None, top: int, mode: st
 
 @hotspots.command()
 @_common_options
-def analyze(repo, repo_path, days, top, fmt, output_file, exclude, branch):
+def analyze(repo, repo_path, days, top, fmt, output_file, exclude, branch, skip_type):
     """Full hotspot analysis — files and directories."""
-    result = _run_analysis(repo, repo_path, days, exclude, branch)
+    result = _run_analysis(repo, repo_path, days, exclude, branch, skip_type)
     _output_result(result, fmt, output_file, top, "analyze")
 
 
 @hotspots.command()
 @_common_options
-def files(repo, repo_path, days, top, fmt, output_file, exclude, branch):
+def files(repo, repo_path, days, top, fmt, output_file, exclude, branch, skip_type):
     """File-level hotspot report."""
-    result = _run_analysis(repo, repo_path, days, exclude, branch)
+    result = _run_analysis(repo, repo_path, days, exclude, branch, skip_type)
     _output_result(result, fmt, output_file, top, "files")
 
 
 @hotspots.command()
 @_common_options
-def dirs(repo, repo_path, days, top, fmt, output_file, exclude, branch):
+def dirs(repo, repo_path, days, top, fmt, output_file, exclude, branch, skip_type):
     """Directory-level hotspot report."""
-    result = _run_analysis(repo, repo_path, days, exclude, branch)
+    result = _run_analysis(repo, repo_path, days, exclude, branch, skip_type)
     _output_result(result, fmt, output_file, top, "dirs")

package/pennyfarthing_scripts/jira/bidirectional.py

@@ -43,7 +43,7 @@ class SyncChange:
     """Represents a single sync change to apply."""
 
     key: str
-    field: Literal["status", "points"]
+    field: Literal["status", "points", "assigned_to"]
     action: Literal["update-yaml", "update-jira"]
     yaml_value: Any
     jira_value: Any
@@ -123,10 +123,15 @@ Examples:
         action="store_true",
         help="Sync story points",
     )
+    parser.add_argument(
+        "--assignee",
+        action="store_true",
+        help="Sync assignee field (Jira -> YAML only)",
+    )
     parser.add_argument(
         "--all",
         action="store_true",
-        help="Sync all fields (status + points)",
+        help="Sync all fields (status + points + assignee)",
     )
     parser.add_argument(
         "--sprint",
@@ -137,10 +142,11 @@ Examples:
 
     args = parser.parse_args(argv)
 
-    # --all implies both --status and --points
+    # --all implies --status, --points, and --assignee
     if args.all:
         args.status = True
         args.points = True
+        args.assignee = True
 
     return args
 
@@ -156,6 +162,7 @@ def generate_sync_plan(
     *,
     sync_status: bool = False,
     sync_points: bool = False,
+    sync_assignee: bool = False,
     yaml_wins: bool = False,
 ) -> SyncPlan:
     """Generate a sync plan comparing YAML and Jira stories.
@@ -165,6 +172,7 @@ def generate_sync_plan(
         jira_stories: Stories from Jira [{key, fields: {status: {name}, customfield_10031, ...}}]
         sync_status: Whether to sync status field
         sync_points: Whether to sync points field
+        sync_assignee: Whether to sync assignee field (always Jira -> YAML)
         yaml_wins: If True, YAML wins conflicts (default: Jira wins)
 
     Returns:
@@ -248,6 +256,26 @@ def generate_sync_plan(
                 )
             )
 
+        # Check assignee differences (always Jira -> YAML, ignores yaml_wins)
+        if sync_assignee:
+            yaml_assignee = yaml_story.get("assigned_to")
+            jira_assignee_obj = jira_story.get("fields", {}).get("assignee")
+            jira_assignee_email = (
+                jira_assignee_obj.get("emailAddress") if jira_assignee_obj else None
+            )
+
+            if yaml_assignee != jira_assignee_email:
+                plan.changes.append(
+                    SyncChange(
+                        key=key,
+                        field="assigned_to",
+                        action="update-yaml",
+                        yaml_value=yaml_assignee,
+                        jira_value=jira_assignee_email,
+                        target_value=jira_assignee_email,
+                    )
+                )
+
     return plan
 
 
@@ -326,21 +354,17 @@ async def execute_sync_plan(
 
     # Execute YAML updates (sequential, file-based)
     if yaml_updates:
-        # Load current sprint data
         from pennyfarthing_scripts.common.config import get_project_root
+        from pennyfarthing_scripts.sprint.yaml_io import read_sprint, write_sprint
 
         root = get_project_root()
         sprint_file = sprint_path or (root / "sprint" / "current-sprint.yaml")
 
         if sprint_file.exists():
-            import yaml
-
-            with open(sprint_file) as f:
-                sprint_data = yaml.safe_load(f)
+            sprint_data = read_sprint(sprint_file)
 
             # Apply YAML updates
             for change in yaml_updates:
-                # Find and update the story in sprint data
                 updated = _update_story_in_sprint(
                     sprint_data, change.key, change.field, change.target_value
                 )
@@ -348,10 +372,9 @@ async def execute_sync_plan(
                     result.changes_applied += 1
                     result.yaml_modified = True
 
-            # Write back if modified
+            # Write back if modified (handles shards automatically)
             if result.yaml_modified:
-                with open(sprint_file, "w") as f:
-                    yaml.dump(sprint_data, f, default_flow_style=False, sort_keys=False)
+                write_sprint(sprint_file, sprint_data)
 
     return result
 
@@ -379,7 +402,10 @@ def _update_story_in_sprint(
     for epic in sprint_data.get("epics", []):
         for story in epic.get("stories", []):
             if story.get("jira") == jira_key:
-                story[field] = value
+                if value is None and field in story:
+                    del story[field]
+                elif value is not None:
+                    story[field] = value
                 return True
 
     return False
@@ -465,8 +491,8 @@ async def async_main(args: argparse.Namespace) -> int:
         Exit code (0 for success, 1 for error)
     """
     # Validate at least one field is selected
-    if not args.status and not args.points:
-        error("Must specify at least one field to sync: --status, --points, or --all")
+    if not args.status and not args.points and not args.assignee:
+        error("Must specify at least one field to sync: --status, --points, --assignee, or --all")
         return 1
 
     # Load sprint data
@@ -510,6 +536,7 @@ async def async_main(args: argparse.Namespace) -> int:
         jira_stories,
         sync_status=args.status,
         sync_points=args.points,
+        sync_assignee=args.assignee,
         yaml_wins=args.yaml_wins,
     )
 

package/pennyfarthing_scripts/jira/cli.py

@@ -175,6 +175,80 @@ def create_story(epic_jira_key, story_id, dry_run):
         raise SystemExit(1)
 
 
+@create.command("standalone")
+@click.argument("title")
+@click.option("--points", default=2, type=int, help="Story points (default: 2)")
+@click.option("--description", "-d", default="", help="Story description")
+@click.option("--dry-run", is_flag=True, help="Preview without creating")
+def create_standalone(title, points, description, dry_run):
+    """Create a standalone Jira story, add to sprint, mark Done.
+
+    Uses REST API directly — no interactive prompts, no stdin issues.
+
+    \b
+    Arguments:
+      TITLE  - Story summary
+
+    \b
+    Examples:
+      pf jira create standalone "Fix sprint script shard support" --points 3
+      pf jira create standalone "Add drift detection" -d "Detects YAML drift"
+      pf jira create standalone "Quick fix" --dry-run
+    """
+    from pennyfarthing_scripts.jira.client import JIRA_PROJECT, get_client
+    from pennyfarthing_scripts.jira.create import _build_adf_description
+    from pennyfarthing_scripts.sprint.loader import get_sprint_info
+
+    sprint_info = get_sprint_info()
+    sprint_id = sprint_info.get("jira_sprint_id")
+
+    if dry_run:
+        click.echo(f"[DRY-RUN] Would create: {title}")
+        click.echo(f"  Points: {points}")
+        click.echo(f"  Sprint: {sprint_id}")
+        click.echo(f"  Actions: create -> add to sprint -> transition to Done")
+        return
+
+    client = get_client()
+
+    # 1. Create the story
+    payload = {
+        "fields": {
+            "project": {"key": JIRA_PROJECT},
+            "summary": title,
+            "description": _build_adf_description(description),
+            "issuetype": {"name": "Story"},
+            "labels": ["pennyfarthing"],
+        }
+    }
+
+    response = client.create_issue_sync(payload)
+    if not response or "key" not in response:
+        raise click.ClickException(f"Failed to create story: {response}")
+
+    jira_key = response["key"]
+    click.echo(f"Created: {jira_key}")
+
+    # 2. Set story points
+    if points > 0:
+        client.update_issue_sync(jira_key, {"customfield_10031": points})
+
+    # 3. Add to sprint
+    if sprint_id:
+        client.add_to_sprint_sync(sprint_id, jira_key)
+        click.echo(f"Added to sprint {sprint_id}")
+
+    # 4. Transition to Done
+    result = client.transition_sync(jira_key, "Done")
+    if result.get("success"):
+        click.echo(f"Transitioned to Done")
+    else:
+        click.echo(f"Warning: could not transition to Done: {result.get('reason')}")
+
+    click.echo(f"\n{jira_key}: {title}")
+    click.echo(f"https://1898andco.atlassian.net/browse/{jira_key}")
+
+
 @jira.command()
 @click.argument("epic")
 @click.option("--dry-run", is_flag=True, help="Preview without applying")
@@ -200,9 +274,10 @@ def sync(epic, dry_run, transition, points, sync_all):
 @click.option("--yaml-wins", is_flag=True, help="Prefer YAML values on conflict")
 @click.option("--status", is_flag=True, help="Sync status field")
 @click.option("--points", is_flag=True, help="Sync story points")
+@click.option("--assignee", is_flag=True, help="Sync assignee field (Jira -> YAML only)")
 @click.option("--all", "sync_all", is_flag=True, help="Sync all fields")
 @click.option("--sprint", "sprint_id", help="Target specific sprint")
-def bidirectional(dry_run, yaml_wins, status, points, sync_all, sprint_id):
+def bidirectional(dry_run, yaml_wins, status, points, assignee, sync_all, sprint_id):
     """Bidirectional sync between YAML and Jira."""
     from pennyfarthing_scripts.jira.bidirectional import main as bidirectional_main
 
@@ -215,6 +290,8 @@ def bidirectional(dry_run, yaml_wins, status, points, sync_all, sprint_id):
         args.append("--status")
     if points or sync_all:
         args.append("--points")
+    if assignee or sync_all:
+        args.append("--assignee")
     if sync_all:
         args.append("--all")
     if sprint_id:

package/pennyfarthing_scripts/jira/client.py

@@ -301,6 +301,34 @@ def map_github_to_jira(github_user: str | None) -> str | None:
     return GITHUB_TO_JIRA_MAP.get(github_user, f"{github_user}@1898andco.io")
 
 
+def get_current_user_email() -> str:
+    """Get the current user's Jira email address.
+
+    Resolution order:
+    1. JIRA_USER environment variable
+    2. git config user.email
+    3. Default fallback
+
+    Returns:
+        Email address string
+    """
+    jira_user = os.environ.get("JIRA_USER")
+    if jira_user:
+        return jira_user
+
+    try:
+        result = subprocess.run(
+            ["git", "config", "user.email"],
+            capture_output=True, text=True, timeout=5,
+        )
+        if result.returncode == 0 and result.stdout.strip():
+            return result.stdout.strip()
+    except Exception:
+        pass
+
+    return "keith.avery@1898andco.io"
+
+
 # =============================================================================
 # JiraClient - Unified REST API client
 # =============================================================================

package/pennyfarthing_scripts/prime/workflow.py

@@ -154,13 +154,13 @@ def get_phase_owner(workflow: str, phase: str, project_root: Path) -> str | None
 
 
 def get_backlog_count(project_root: Path) -> int:
-    """Count stories in backlog or ready status.
+    """Count stories in backlog, ready, or planning status.
 
     Args:
         project_root: Project root path
 
     Returns:
-        Number of stories with status backlog or ready
+        Number of stories available for work
     """
     # Import here to avoid circular imports
     from pennyfarthing_scripts.sprint.loader import load_sprint
@@ -171,9 +171,11 @@ def get_backlog_count(project_root: Path) -> int:
 
     count = 0
     for epic in sprint["epics"]:
+        if not isinstance(epic, dict):
+            continue  # Skip string refs (defensive)
         for story in epic.get("stories", []):
             status = story.get("status", "").lower()
-            if status in ("backlog", "ready"):
+            if status in ("backlog", "ready", "planning"):
                 count += 1
 
     return count

package/pennyfarthing_scripts/sprint/archive.py

@@ -18,7 +18,7 @@ def archive_story(
     dry_run: bool = False,
     apply: bool = False,
 ) -> dict[str, Any]:
-    """Archive a completed story.
+    """Archive a completed story to the sprint archive file.
 
     Args:
         story_id: Story ID to archive
@@ -29,6 +29,11 @@ def archive_story(
     Returns:
         Dict with success status and details
     """
+    import re
+    from datetime import date
+
+    import yaml
+
     # Find the story
     story = get_story_by_id(story_id)
     if not story:
@@ -45,23 +50,75 @@ def archive_story(
             "error": f"Story status is '{status}', expected 'done' or 'completed'",
         }
 
+    root = get_project_root()
+    sprint_file = root / "sprint" / "current-sprint.yaml"
+
+    if not sprint_file.exists():
+        return {"success": False, "error": f"Sprint file not found: {sprint_file}"}
+
+    # Get sprint name for archive file
+    with open(sprint_file) as f:
+        sprint_data = yaml.safe_load(f.read())
+
+    sprint_name = sprint_data.get("sprint", {}).get("jira_sprint_name", "")
+    match = re.search(r"(\d{4})", sprint_name)
+    sprint_num = match.group(1) if match else "unknown"
+    archive_file = root / "sprint" / "archive" / f"sprint-{sprint_num}-completed.yaml"
+
+    # Find parent epic
+    epic_id = ""
+    for epic in sprint_data.get("epics", []):
+        if isinstance(epic, dict):
+            for s in epic.get("stories", []):
+                if s.get("id") == story_id:
+                    epic_id = str(epic.get("id", ""))
+                    break
+
+    completed_date = str(date.today())
+
     if dry_run:
         return {
             "success": True,
             "dry_run": True,
             "story": story,
             "pr_number": pr_number,
-            "message": f"Would archive {story_id}",
+            "message": f"Would archive {story_id} to {archive_file}",
         }
 
-    # In a real implementation, this would:
-    # 1. Write to archive file
-    # 2. Optionally remove from current-sprint.yaml
+    # Append to archive file
+    if not archive_file.exists():
+        return {"success": False, "error": f"Archive file not found: {archive_file}"}
+
+    entry_lines = [
+        f"  - id: {story_id}",
+        f"    epic: {epic_id}",
+        f'    title: "{story.get("title", "Unknown")}"',
+        f"    points: {story.get('points', 0)}",
+        f"    completed: {completed_date}",
+    ]
+    if pr_number:
+        entry_lines.append(f"    pr: {pr_number}")
+
+    with open(archive_file, "a") as f:
+        f.write("\n".join(entry_lines) + "\n")
+
+    msg = f"Archived {story_id} to {archive_file.name}"
+
+    # Remove from current sprint if --apply
+    if apply:
+        for epic in sprint_data.get("epics", []):
+            if isinstance(epic, dict):
+                epic["stories"] = [s for s in epic.get("stories", []) if s.get("id") != story_id]
+
+        from pennyfarthing_scripts.sprint.yaml_io import write_sprint
+        write_sprint(sprint_file, sprint_data)
+        msg += f" and removed from {sprint_file.name}"
+
     return {
         "success": True,
         "story": story,
         "pr_number": pr_number,
-        "message": f"Archived {story_id}",
+        "message": msg,
     }