@pennyfarthing/core 9.2.0 → 9.3.0

package/pennyfarthing_scripts/output.py

@@ -1,37 +0,0 @@
-"""
-Console output utilities for Pennyfarthing scripts.
-
-This module re-exports from pennyfarthing_scripts.common.output for
-backwards compatibility. New code should import from common.output directly.
-"""
-
-# Re-export everything from the new location
-from pennyfarthing_scripts.common.output import (
-    Colors,
-    _colorize,
-    _supports_color,
-    bold,
-    debug,
-    dim,
-    divider,
-    error,
-    header,
-    info,
-    success,
-    warn,
-)
-
-__all__ = [
-    "Colors",
-    "_colorize",
-    "_supports_color",
-    "bold",
-    "debug",
-    "dim",
-    "divider",
-    "error",
-    "header",
-    "info",
-    "success",
-    "warn",
-]

package/pennyfarthing_scripts/patch_mode.py

@@ -1,449 +0,0 @@
-"""Patch Mode - Interrupt-Driven Bug Fix Workflow.
-
-Story: 74-1 - Implement Patch Mode
-Epic: epic-74 (Patch Mode Workflow)
-
-This module provides the core functionality for Patch Mode, allowing developers
-to interrupt their current workflow to fix blocking bugs and then resume work
-with full context preserved.
-"""
-
-from __future__ import annotations
-
-import re
-import subprocess
-import time
-from dataclasses import dataclass, asdict
-from datetime import datetime
-from pathlib import Path
-from typing import Any
-
-import yaml
-
-from pennyfarthing_scripts.common.config import get_project_root
-
-
-@dataclass
-class PatchState:
-    """State preserved when entering patch mode."""
-
-    story_id: str
-    workflow: str
-    phase: str
-    agent: str
-    feature_branch: str
-
-    def to_yaml(self) -> str:
-        """Serialize state to YAML string."""
-        return yaml.dump(asdict(self), default_flow_style=False)
-
-    @classmethod
-    def from_yaml(cls, yaml_str: str) -> "PatchState":
-        """Deserialize state from YAML string."""
-        data = yaml.safe_load(yaml_str)
-        return cls(**data)
-
-
-class PatchStack:
-    """Stack of patch states for nested patch support."""
-
-    def __init__(self, stack_file: Path | None = None) -> None:
-        """Initialize patch stack.
-
-        Args:
-            stack_file: Path to patch-stack.yaml file
-        """
-        if stack_file is None:
-            root = get_project_root()
-            stack_file = root / ".session" / "patch-stack.yaml"
-
-        self.stack_file = stack_file
-        self._stack: list[PatchState] = []
-
-        # Load existing stack from file if it exists
-        if self.stack_file.exists():
-            self._load()
-
-    def _load(self) -> None:
-        """Load stack from file."""
-        content = yaml.safe_load(self.stack_file.read_text())
-        if content and "stack" in content:
-            self._stack = [
-                PatchState(**item) for item in content["stack"]
-            ]
-
-    def _save(self) -> None:
-        """Save stack to file."""
-        # Ensure parent directory exists
-        self.stack_file.parent.mkdir(parents=True, exist_ok=True)
-
-        content = {
-            "stack": [asdict(state) for state in self._stack]
-        }
-        self.stack_file.write_text(yaml.dump(content, default_flow_style=False))
-
-    def push(self, state: PatchState) -> None:
-        """Push state onto stack."""
-        self._stack.append(state)
-        self._save()
-
-    def pop(self) -> PatchState:
-        """Pop state from stack."""
-        if not self._stack:
-            raise IndexError("Cannot pop from empty patch stack")
-        state = self._stack.pop()
-        self._save()
-        return state
-
-    def depth(self) -> int:
-        """Return current stack depth."""
-        return len(self._stack)
-
-    def peek(self) -> PatchState | None:
-        """Peek at top of stack without popping."""
-        return self._stack[-1] if self._stack else None
-
-
-def get_patch_stack(stack_file: Path | None = None) -> PatchStack:
-    """Get the patch stack instance.
-
-    Args:
-        stack_file: Optional path to stack file
-
-    Returns:
-        PatchStack instance
-    """
-    return PatchStack(stack_file=stack_file)
-
-
-def _sanitize_branch_name(description: str) -> str:
-    """Sanitize description for use in branch name.
-
-    Args:
-        description: Raw description string
-
-    Returns:
-        Sanitized string safe for git branch names
-    """
-    # Replace special characters with dashes
-    sanitized = re.sub(r'[^a-zA-Z0-9\s-]', '', description)
-    # Replace spaces with dashes
-    sanitized = re.sub(r'\s+', '-', sanitized)
-    # Remove multiple consecutive dashes
-    sanitized = re.sub(r'-+', '-', sanitized)
-    # Lowercase and strip
-    sanitized = sanitized.lower().strip('-')
-    # Truncate if too long
-    return sanitized[:50]
-
-
-def create_patch_branch(
-    description: str,
-    feature_branch: str,
-    repo_path: Path | None = None,
-) -> str:
-    """Create a patch branch from the current feature branch.
-
-    Args:
-        description: Description for branch name
-        feature_branch: Current feature branch
-        repo_path: Path to git repository
-
-    Returns:
-        Name of created patch branch
-
-    Raises:
-        ValueError: If description is empty or produces empty branch name
-    """
-    if not description or not description.strip():
-        raise ValueError("Patch description cannot be empty")
-
-    timestamp = int(time.time())
-    sanitized_desc = _sanitize_branch_name(description)
-
-    if not sanitized_desc:
-        raise ValueError(
-            f"Patch description '{description}' produces empty branch name after sanitization"
-        )
-
-    branch_name = f"patch/{sanitized_desc}-{timestamp}"
-
-    cwd = str(repo_path) if repo_path else None
-
-    # Create and checkout the new branch from current HEAD (feature branch)
-    result = subprocess.run(
-        ["git", "checkout", "-b", branch_name],
-        capture_output=True,
-        text=True,
-        cwd=cwd,
-    )
-
-    if result.returncode != 0:
-        raise RuntimeError(f"Git branch creation failed: {result.stderr}")
-
-    return branch_name
-
-
-def merge_patch_branch(
-    patch_branch: str,
-    feature_branch: str,
-    repo_path: Path | None = None,
-) -> None:
-    """Merge patch branch back to feature branch and delete it.
-
-    Args:
-        patch_branch: Name of patch branch
-        feature_branch: Target feature branch
-        repo_path: Path to git repository
-    """
-    cwd = str(repo_path) if repo_path else None
-
-    # Checkout feature branch
-    result = subprocess.run(
-        ["git", "checkout", feature_branch],
-        capture_output=True,
-        text=True,
-        cwd=cwd,
-    )
-    if result.returncode != 0:
-        raise RuntimeError(f"Git checkout failed: {result.stderr}")
-
-    # Merge patch branch
-    result = subprocess.run(
-        ["git", "merge", patch_branch],
-        capture_output=True,
-        text=True,
-        cwd=cwd,
-    )
-    if result.returncode != 0:
-        raise RuntimeError(f"Git merge failed: {result.stderr}")
-
-    # Delete patch branch
-    result = subprocess.run(
-        ["git", "branch", "-d", patch_branch],
-        capture_output=True,
-        text=True,
-        cwd=cwd,
-    )
-    if result.returncode != 0:
-        raise RuntimeError(f"Git branch delete failed: {result.stderr}")
-
-
-def enter_patch_mode(
-    description: str,
-    story_id: str,
-    workflow: str,
-    phase: str,
-    agent: str,
-    feature_branch: str,
-    repo_path: Path | None = None,
-    stack_file: Path | None = None,
-) -> dict[str, Any]:
-    """Enter patch mode by saving state and creating patch branch.
-
-    Args:
-        description: Description of the patch/fix
-        story_id: Current story ID
-        workflow: Current workflow type
-        phase: Current workflow phase
-        agent: Current agent
-        feature_branch: Current feature branch name
-        repo_path: Path to git repository
-        stack_file: Path to patch-stack.yaml
-
-    Returns:
-        Dict with patch_branch and other metadata
-    """
-    # Save current state to stack
-    state = PatchState(
-        story_id=story_id,
-        workflow=workflow,
-        phase=phase,
-        agent=agent,
-        feature_branch=feature_branch,
-    )
-
-    stack = get_patch_stack(stack_file)
-    stack.push(state)
-
-    # Create patch branch
-    try:
-        patch_branch = create_patch_branch(
-            description=description,
-            feature_branch=feature_branch,
-            repo_path=repo_path,
-        )
-    except Exception as e:
-        # Rollback stack on failure
-        stack.pop()
-        raise RuntimeError(f"Git error: {e}") from e
-
-    return {
-        "patch_branch": patch_branch,
-        "agent": "dev",  # Patch mode is always dev
-        "story_id": story_id,
-        "description": description,
-    }
-
-
-def exit_patch_mode(
-    patch_branch: str | None = None,
-    repo_path: Path | None = None,
-    stack_file: Path | None = None,
-) -> dict[str, Any]:
-    """Exit patch mode by merging and restoring state.
-
-    Args:
-        patch_branch: Name of patch branch to merge
-        repo_path: Path to git repository
-        stack_file: Path to patch-stack.yaml
-
-    Returns:
-        Dict with restored state and handoff_marker
-    """
-    stack = get_patch_stack(stack_file)
-
-    # Peek at state first - don't pop until operations succeed
-    state = stack.peek()
-    if state is None:
-        raise RuntimeError("Cannot exit patch mode: stack is empty")
-
-    # Merge patch branch back to feature branch if provided
-    # Do this BEFORE popping state so we can recover on failure
-    if patch_branch:
-        merge_patch_branch(
-            patch_branch=patch_branch,
-            feature_branch=state.feature_branch,
-            repo_path=repo_path,
-        )
-
-    # Only pop after successful merge
-    stack.pop()
-
-    # Build handoff marker for original agent
-    handoff_marker = f"<!-- CYCLIST:HANDOFF:/{state.agent} -->"
-
-    return {
-        "story_id": state.story_id,
-        "workflow": state.workflow,
-        "phase": state.phase,
-        "agent": state.agent,
-        "feature_branch": state.feature_branch,
-        "handoff_marker": handoff_marker,
-        "relay_mode_disabled": False,
-    }
-
-
-def restore_workflow_state(
-    repo_path: Path | None = None,
-    stack_file: Path | None = None,
-) -> dict[str, Any]:
-    """Restore workflow state from patch stack.
-
-    Args:
-        repo_path: Path to git repository
-        stack_file: Path to patch-stack.yaml
-
-    Returns:
-        Dict with restored state
-    """
-    stack = get_patch_stack(stack_file)
-
-    # Peek at state first - don't pop until checkout succeeds
-    state = stack.peek()
-    if state is None:
-        raise RuntimeError("Cannot restore workflow state: stack is empty")
-
-    cwd = str(repo_path) if repo_path else None
-
-    # Checkout the original feature branch
-    result = subprocess.run(
-        ["git", "checkout", state.feature_branch],
-        capture_output=True,
-        text=True,
-        cwd=cwd,
-    )
-
-    if result.returncode != 0:
-        raise RuntimeError(f"Git checkout failed: {result.stderr}")
-
-    # Only pop after successful checkout
-    stack.pop()
-
-    return {
-        "story_id": state.story_id,
-        "workflow": state.workflow,
-        "phase": state.phase,
-        "agent": state.agent,
-        "feature_branch": state.feature_branch,
-    }
-
-
-def log_patch_to_session(
-    session_file: Path,
-    description: str,
-    commit_sha: str,
-) -> None:
-    """Log completed patch to session file.
-
-    Args:
-        session_file: Path to session markdown file
-        description: Patch description
-        commit_sha: Git commit SHA
-    """
-    content = session_file.read_text()
-
-    # Find the Patches section and add entry
-    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    patch_entry = f"- **{timestamp}**: {description} (`{commit_sha}`)\n"
-
-    # Look for the marker comment or Patches header
-    if "<!-- Patches applied during this story will be logged here -->" in content:
-        content = content.replace(
-            "<!-- Patches applied during this story will be logged here -->",
-            f"<!-- Patches applied during this story will be logged here -->\n{patch_entry}"
-        )
-    elif "## Patches" in content:
-        # Insert after the Patches header
-        idx = content.find("## Patches")
-        next_newline = content.find("\n", idx)
-        content = content[:next_newline + 1] + "\n" + patch_entry + content[next_newline + 1:]
-    else:
-        # Append at end
-        content += f"\n## Patches\n\n{patch_entry}"
-
-    session_file.write_text(content)
-
-
-def generate_patch_commit_message(
-    description: str,
-    story_id: str,
-) -> str:
-    """Generate commit message for patch.
-
-    Format: fix(patch): description [from:STORY-ID]
-
-    Args:
-        description: Patch description
-        story_id: Story ID the patch is from
-
-    Returns:
-        Formatted commit message
-    """
-    return f"""fix(patch): {description} [from:{story_id}]
-
-Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
-"""
-
-
-def is_in_patch_mode(stack_file: Path | None = None) -> bool:
-    """Check if currently in patch mode.
-
-    Args:
-        stack_file: Path to patch-stack.yaml
-
-    Returns:
-        True if patch stack is non-empty
-    """
-    stack = get_patch_stack(stack_file)
-    return stack.depth() > 0

package/pennyfarthing_scripts/preflight/__init__.py

@@ -1,17 +0,0 @@
-"""Preflight checks for Pennyfarthing workflows.
-
-This package provides async preflight checks that run in parallel
-to validate story completion before finishing.
-"""
-
-from pennyfarthing_scripts.preflight.finish import (
-    PreflightResult,
-    PreflightIssue,
-    run_finish_preflight,
-)
-
-__all__ = [
-    "PreflightResult",
-    "PreflightIssue",
-    "run_finish_preflight",
-]

package/pennyfarthing_scripts/preflight/__main__.py

@@ -1,10 +0,0 @@
-"""
-Entry point for python -m pennyfarthing_scripts.preflight
-"""
-
-import sys
-
-from pennyfarthing_scripts.preflight.cli import cli
-
-if __name__ == "__main__":
-    sys.exit(cli())

package/pennyfarthing_scripts/preflight/cli.py

@@ -1,141 +0,0 @@
-"""
-Preflight CLI - Fan-out CLI for preflight checks.
-
-Usage:
-    python -m pennyfarthing_scripts.preflight <subcommand> [args]
-
-Subcommands:
-    finish      Run finish preflight checks
-"""
-
-import argparse
-import asyncio
-import json
-import sys
-from pathlib import Path
-
-from pennyfarthing_scripts.preflight.finish import run_finish_preflight
-
-
-def finish(args: list[str]) -> int:
-    """Run finish preflight checks."""
-    parser = argparse.ArgumentParser(
-        prog="preflight finish",
-        description="Run finish preflight checks in parallel",
-    )
-    parser.add_argument(
-        "story_id",
-        help="Story identifier (e.g., 31-10)",
-    )
-    parser.add_argument(
-        "--branch", "-b",
-        required=True,
-        help="Feature branch name",
-    )
-    parser.add_argument(
-        "--jira", "-j",
-        help="Jira issue key (optional, skips Jira checks if absent)",
-    )
-    parser.add_argument(
-        "--repo", "-r",
-        help="Repository name for PR lookup (optional)",
-    )
-    parser.add_argument(
-        "--project-root", "-p",
-        type=Path,
-        help="Project root path (defaults to cwd)",
-    )
-    parser.add_argument(
-        "--format", "-f",
-        choices=["json", "yaml"],
-        default="json",
-        help="Output format (default: json)",
-    )
-
-    parsed = parser.parse_args(args)
-
-    # Run async preflight
-    result = asyncio.run(run_finish_preflight(
-        story_id=parsed.story_id,
-        branch=parsed.branch,
-        jira_key=parsed.jira,
-        repo=parsed.repo,
-        project_root=parsed.project_root,
-    ))
-
-    # Output result
-    result_dict = result.to_dict()
-
-    if parsed.format == "yaml":
-        try:
-            import yaml
-            print(yaml.dump(result_dict, default_flow_style=False, sort_keys=False))
-        except ImportError:
-            print("YAML output requires PyYAML. Falling back to JSON.", file=sys.stderr)
-            print(json.dumps(result_dict, indent=2))
-    else:
-        print(json.dumps(result_dict, indent=2))
-
-    # Return non-zero if not ready to finish
-    return 0 if result.ready_to_finish else 1
-
-
-# Subcommand registry
-SUBCOMMANDS = {
-    "finish": finish,
-}
-
-
-def cli(args: list[str] | None = None) -> int:
-    """Main CLI entry point."""
-    if args is None:
-        args = sys.argv[1:]
-
-    parser = argparse.ArgumentParser(
-        prog="preflight",
-        description="Preflight checks for Pennyfarthing workflows",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Subcommands:
-    finish <story_id> --branch <branch> [--jira <key>]
-        Run finish preflight checks in parallel
-
-Examples:
-    preflight finish 31-10 --branch feat/31-10-feature --jira MSSCI-12345
-    preflight finish 63-9 -b feat/63-9-fanout -j MSSCI-12413 -f yaml
-""",
-    )
-
-    parser.add_argument(
-        "subcommand",
-        nargs="?",
-        choices=list(SUBCOMMANDS.keys()),
-        help="Subcommand to run",
-    )
-    parser.add_argument(
-        "args",
-        nargs=argparse.REMAINDER,
-        help="Arguments for subcommand",
-    )
-
-    parsed = parser.parse_args(args)
-
-    if not parsed.subcommand:
-        parser.print_help()
-        return 0
-
-    handler = SUBCOMMANDS.get(parsed.subcommand)
-    if handler:
-        return handler(parsed.args)
-    else:
-        print(f"Unknown subcommand: {parsed.subcommand}", file=sys.stderr)
-        return 1
-
-
-def main(args: list[str] | None = None) -> int:
-    """Alias for cli()."""
-    return cli(args)
-
-
-if __name__ == "__main__":
-    sys.exit(cli())