@pennyfarthing/core 7.9.0 → 7.9.2

package/pennyfarthing_scripts/story/cli.py

@@ -1,105 +0,0 @@
-"""
-Story CLI - Fan-out CLI for story operations.
-
-Usage:
-    python -m pennyfarthing_scripts.story <subcommand> [args]
-
-Subcommands:
-    size        Show sizing guidelines
-    template    Show story templates
-    create      Create a new story
-"""
-
-import argparse
-import sys
-
-
-def size(args: list[str]) -> int:
-    """Show sizing guidelines."""
-    from pennyfarthing_scripts.story.size import main as size_main
-    return size_main(args)
-
-
-def template(args: list[str]) -> int:
-    """Show story templates."""
-    from pennyfarthing_scripts.story.template import main as template_main
-    return template_main(args)
-
-
-def create(args: list[str]) -> int:
-    """Create a new story."""
-    from pennyfarthing_scripts.story.create import main as create_main
-    return create_main(args)
-
-
-# Subcommand registry
-SUBCOMMANDS = {
-    "size": size,
-    "template": template,
-    "create": create,
-}
-
-
-def cli(args: list[str] | None = None) -> int:
-    """Main CLI entry point.
-
-    Args:
-        args: Command line arguments (defaults to sys.argv[1:])
-
-    Returns:
-        Exit code
-    """
-    if args is None:
-        args = sys.argv[1:]
-
-    parser = argparse.ArgumentParser(
-        prog="story",
-        description="Story CLI for Pennyfarthing",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Subcommands:
-    size [points]       Show sizing guidelines (optionally for specific points)
-    template [type]     Show story templates (optionally for specific type)
-    create              Create a new story
-
-Examples:
-    story size
-    story size 3
-    story template feature
-    story create MSSCI-12000 "Add feature" 3 --type feature
-""",
-    )
-
-    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())

package/pennyfarthing_scripts/story/create.py

@@ -1,167 +0,0 @@
-"""
-Story creation utilities.
-
-Provides functions for creating new stories.
-"""
-
-from typing import Any
-
-from pennyfarthing_scripts.story.size import SIZING_GUIDELINES
-from pennyfarthing_scripts.story.template import format_template
-
-
-def generate_story_yaml(
-    epic_id: str,
-    title: str,
-    points: int,
-    story_type: str = "feature",
-    priority: str = "P2",
-    workflow: str | None = None,
-) -> str:
-    """Generate YAML block for a new story.
-
-    Args:
-        epic_id: Parent epic ID
-        title: Story title
-        points: Story points
-        story_type: Story type (feature, bug, refactor, chore)
-        priority: Priority (P0, P1, P2, P3)
-        workflow: Workflow override (defaults based on points)
-
-    Returns:
-        YAML block string
-    """
-    # Determine workflow based on points if not specified
-    if workflow is None:
-        sizing = SIZING_GUIDELINES.get(points, {})
-        workflow = sizing.get("workflow", "tdd")
-
-    # Generate story ID placeholder
-    story_id = f"{epic_id}-NEW"
-
-    return format_template(
-        story_type,
-        id=story_id,
-        title=title,
-        points=points,
-        priority=priority,
-        workflow=workflow,
-    )
-
-
-def validate_points(points: int) -> dict[str, Any]:
-    """Validate story points.
-
-    Args:
-        points: Story points value
-
-    Returns:
-        Dict with valid status and message
-    """
-    valid_points = [1, 2, 3, 5, 8, 13]
-
-    if points not in valid_points:
-        return {
-            "valid": False,
-            "warning": f"Points {points} not in standard sequence: {valid_points}",
-        }
-
-    if points >= 13:
-        return {
-            "valid": True,
-            "warning": "Consider splitting: 13+ point stories are typically too large",
-        }
-
-    return {"valid": True}
-
-
-def create_story(
-    epic_id: str,
-    title: str,
-    points: int,
-    story_type: str = "feature",
-    priority: str = "P2",
-    workflow: str | None = None,
-    *,
-    dry_run: bool = False,
-) -> dict[str, Any]:
-    """Create a new story.
-
-    Args:
-        epic_id: Parent epic ID
-        title: Story title
-        points: Story points
-        story_type: Story type
-        priority: Priority
-        workflow: Workflow override
-        dry_run: If True, don't write to file
-
-    Returns:
-        Dict with success status and story YAML
-    """
-    # Validate points
-    validation = validate_points(points)
-
-    yaml_block = generate_story_yaml(
-        epic_id=epic_id,
-        title=title,
-        points=points,
-        story_type=story_type,
-        priority=priority,
-        workflow=workflow,
-    )
-
-    return {
-        "success": True,
-        "dry_run": dry_run,
-        "yaml": yaml_block,
-        "warning": validation.get("warning"),
-    }
-
-
-def main(args: list[str] | None = None) -> int:
-    """CLI entry point for story create.
-
-    Args:
-        args: Command line arguments
-
-    Returns:
-        Exit code
-    """
-    import argparse
-
-    parser = argparse.ArgumentParser(description="Create a new story")
-    parser.add_argument("epic_id", help="Parent epic ID")
-    parser.add_argument("title", help="Story title")
-    parser.add_argument("points", type=int, help="Story points")
-    parser.add_argument("--type", choices=["feature", "bug", "refactor", "chore"], default="feature")
-    parser.add_argument("--priority", choices=["P0", "P1", "P2", "P3"], default="P2")
-    parser.add_argument("--workflow", help="Override workflow")
-    parser.add_argument("--dry-run", action="store_true", help="Show what would be created")
-
-    parsed = parser.parse_args(args)
-
-    result = create_story(
-        epic_id=parsed.epic_id,
-        title=parsed.title,
-        points=parsed.points,
-        story_type=parsed.type,
-        priority=parsed.priority,
-        workflow=parsed.workflow,
-        dry_run=parsed.dry_run,
-    )
-
-    if result.get("warning"):
-        print(f"Warning: {result['warning']}")
-        print("")
-
-    print("Add this to sprint/current-sprint.yaml under the epic's stories:")
-    print("")
-    print(result["yaml"])
-
-    return 0
-
-
-if __name__ == "__main__":
-    import sys
-    sys.exit(main())

package/pennyfarthing_scripts/story/size.py

@@ -1,113 +0,0 @@
-"""
-Story sizing utilities.
-
-Provides guidelines and helpers for sizing stories.
-"""
-
-from typing import Any
-
-
-# Sizing guidelines
-SIZING_GUIDELINES = {
-    1: {
-        "scale": "Trivial",
-        "complexity": "Single file, minimal testing",
-        "examples": ["Config change", "Typo fix", "Simple bug fix"],
-        "workflow": "trivial",
-    },
-    2: {
-        "scale": "Trivial",
-        "complexity": "Few files, some testing",
-        "examples": ["Small fix", "Minor enhancement"],
-        "workflow": "trivial",
-    },
-    3: {
-        "scale": "Small",
-        "complexity": "Few files, some testing",
-        "examples": ["Validation", "Single component"],
-        "workflow": "tdd",
-    },
-    5: {
-        "scale": "Medium",
-        "complexity": "Multiple files, comprehensive testing",
-        "examples": ["New page", "API endpoint"],
-        "workflow": "tdd",
-    },
-    8: {
-        "scale": "Large",
-        "complexity": "Significant scope, extensive testing",
-        "examples": ["Integration", "Major refactor"],
-        "workflow": "tdd",
-    },
-    13: {
-        "scale": "SPLIT",
-        "complexity": "Too complex for single story",
-        "examples": ["Break into smaller stories"],
-        "workflow": None,
-    },
-}
-
-
-def get_sizing_guidelines(points: int | None = None) -> dict[int, dict[str, Any]]:
-    """Get sizing guidelines.
-
-    Args:
-        points: Optional specific point value to get
-
-    Returns:
-        Dict of sizing guidelines
-    """
-    if points is not None:
-        if points in SIZING_GUIDELINES:
-            return {points: SIZING_GUIDELINES[points]}
-        return {}
-    return SIZING_GUIDELINES
-
-
-def format_size_info(size_info: dict[int, dict[str, Any]]) -> str:
-    """Format sizing info as human-readable string.
-
-    Args:
-        size_info: Sizing info dict
-
-    Returns:
-        Formatted string
-    """
-    lines = []
-
-    for points, info in sorted(size_info.items()):
-        lines.append(f"{points} points - {info['scale']}")
-        lines.append(f"  Complexity: {info['complexity']}")
-        lines.append(f"  Examples: {', '.join(info['examples'])}")
-        if info.get('workflow'):
-            lines.append(f"  Workflow: {info['workflow']}")
-        lines.append("")
-
-    return "\n".join(lines)
-
-
-def main(args: list[str] | None = None) -> int:
-    """CLI entry point for story size.
-
-    Args:
-        args: Command line arguments
-
-    Returns:
-        Exit code
-    """
-    import argparse
-
-    parser = argparse.ArgumentParser(description="Story sizing guidelines")
-    parser.add_argument("points", nargs="?", type=int, help="Specific point value")
-
-    parsed = parser.parse_args(args)
-
-    guidelines = get_sizing_guidelines(parsed.points)
-    print(format_size_info(guidelines))
-
-    return 0
-
-
-if __name__ == "__main__":
-    import sys
-    sys.exit(main())

package/pennyfarthing_scripts/story/template.py

@@ -1,151 +0,0 @@
-"""
-Story templates.
-
-Provides templates for different story types.
-"""
-
-from typing import Any
-
-
-# Story templates
-TEMPLATES = {
-    "feature": {
-        "type": "feature",
-        "template": """- id: {id}
-  title: "{title}"
-  status: backlog
-  points: {points}
-  priority: {priority}
-  workflow: {workflow}
-  acceptance_criteria:
-    - [ ] Feature is implemented
-    - [ ] Tests pass
-    - [ ] Documentation updated
-""",
-        "description": "New feature implementation",
-    },
-    "bug": {
-        "type": "bug",
-        "template": """- id: {id}
-  title: "[BUG] {title}"
-  status: backlog
-  points: {points}
-  priority: {priority}
-  workflow: {workflow}
-  acceptance_criteria:
-    - [ ] Bug is fixed
-    - [ ] Root cause identified
-    - [ ] Regression test added
-""",
-        "description": "Bug fix",
-    },
-    "refactor": {
-        "type": "refactor",
-        "template": """- id: {id}
-  title: "[REFACTOR] {title}"
-  status: backlog
-  points: {points}
-  priority: {priority}
-  workflow: {workflow}
-  acceptance_criteria:
-    - [ ] Code is refactored
-    - [ ] Tests still pass
-    - [ ] No behavior change
-""",
-        "description": "Code refactoring",
-    },
-    "chore": {
-        "type": "chore",
-        "template": """- id: {id}
-  title: "[CHORE] {title}"
-  status: backlog
-  points: {points}
-  priority: {priority}
-  workflow: trivial
-  acceptance_criteria:
-    - [ ] Task completed
-""",
-        "description": "Maintenance task",
-    },
-}
-
-
-def get_template(template_type: str) -> dict[str, Any] | None:
-    """Get a specific template.
-
-    Args:
-        template_type: Template type (feature, bug, refactor, chore)
-
-    Returns:
-        Template dict or None if not found
-    """
-    return TEMPLATES.get(template_type)
-
-
-def get_all_templates() -> dict[str, dict[str, Any]]:
-    """Get all available templates.
-
-    Returns:
-        Dict of all templates
-    """
-    return TEMPLATES
-
-
-def format_template(template_type: str, **kwargs: Any) -> str:
-    """Format a template with provided values.
-
-    Args:
-        template_type: Template type
-        **kwargs: Values to fill in template
-
-    Returns:
-        Formatted template string
-    """
-    template = get_template(template_type)
-    if not template:
-        template = get_template("feature")  # Default
-
-    template_str = template["template"]
-    return template_str.format(**kwargs)
-
-
-def main(args: list[str] | None = None) -> int:
-    """CLI entry point for story template.
-
-    Args:
-        args: Command line arguments
-
-    Returns:
-        Exit code
-    """
-    import argparse
-
-    parser = argparse.ArgumentParser(description="Story templates")
-    parser.add_argument(
-        "type",
-        nargs="?",
-        choices=list(TEMPLATES.keys()),
-        help="Template type",
-    )
-
-    parsed = parser.parse_args(args)
-
-    if parsed.type:
-        template = get_template(parsed.type)
-        if template:
-            print(f"Type: {template['type']}")
-            print(f"Description: {template['description']}")
-            print("")
-            print("Template:")
-            print(template["template"])
-    else:
-        print("Available templates:")
-        for name, template in TEMPLATES.items():
-            print(f"  {name}: {template['description']}")
-
-    return 0
-
-
-if __name__ == "__main__":
-    import sys
-    sys.exit(main())