@pennyfarthing/core 10.0.2 → 10.0.3

package/pennyfarthing_scripts/story/create.py

@@ -0,0 +1,167 @@
+"""
+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

@@ -0,0 +1,113 @@
+"""
+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

@@ -0,0 +1,151 @@
+"""
+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())

package/pennyfarthing_scripts/swebench.py

@@ -0,0 +1,216 @@
+"""
+SWE-bench utilities for Pennyfarthing scripts.
+
+Provides shared functionality for SWE-bench scenario evaluation:
+- Patch parsing and analysis
+- Ground truth data loading
+- Scenario lookup
+
+Consolidates duplicate code from:
+- pennyfarthing-dist/scripts/test/ground-truth-judge.py
+- pennyfarthing-dist/scripts/test/swebench-judge.py
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+# Default cache location for SWE-bench data
+DEFAULT_CACHE_PATH = "/tmp/swebench_all.json"
+
+
+@dataclass
+class PatchInfo:
+    """Structured information extracted from a git diff patch."""
+
+    files: list[str] = field(default_factory=list)
+    """Files modified in the patch (e.g., 'src/flask/app.py')"""
+
+    functions: list[str] = field(default_factory=list)
+    """Function/class context from @@ headers (e.g., 'def create_app')"""
+
+    additions: list[str] = field(default_factory=list)
+    """Lines added (without leading +), excluding comments"""
+
+    deletions: list[str] = field(default_factory=list)
+    """Lines deleted (without leading -), excluding comments"""
+
+    key_patterns: list[str] = field(default_factory=list)
+    """Unique identifier patterns extracted from additions"""
+
+
+def extract_patch_info(patch_text: str) -> PatchInfo:
+    """Extract structured information from a git diff patch.
+
+    Parses unified diff format to extract:
+    - Modified files from 'diff --git' lines
+    - Function/class context from @@ headers
+    - Added and deleted lines (excluding diff markers and comments)
+    - Key code patterns (identifiers) from additions
+
+    Args:
+        patch_text: Raw patch text in unified diff format
+
+    Returns:
+        PatchInfo dataclass with extracted elements
+    """
+    info = PatchInfo()
+
+    for line in patch_text.split("\n"):
+        # File changes: diff --git a/path b/path
+        if line.startswith("diff --git"):
+            match = re.search(r"b/(.+)$", line)
+            if match:
+                info.files.append(match.group(1))
+
+        # Function/class context: @@ -10,5 +10,7 @@ def some_function
+        elif line.startswith("@@"):
+            match = re.search(r"@@.*@@\s*(.+)$", line)
+            if match:
+                info.functions.append(match.group(1).strip())
+
+        # Additions (skip +++ header lines and comments)
+        elif line.startswith("+") and not line.startswith("+++"):
+            clean_line = line[1:].strip()
+            if clean_line and not clean_line.startswith("#"):
+                info.additions.append(clean_line)
+                # Extract identifier patterns
+                patterns = re.findall(r"\b\w+\b", clean_line)
+                info.key_patterns.extend(patterns)
+
+        # Deletions (skip --- header lines and comments)
+        elif line.startswith("-") and not line.startswith("---"):
+            clean_line = line[1:].strip()
+            if clean_line and not clean_line.startswith("#"):
+                info.deletions.append(clean_line)
+
+    # Deduplicate key patterns
+    info.key_patterns = list(set(info.key_patterns))
+
+    return info
+
+
+def load_swebench_data(cache_path: str | Path = DEFAULT_CACHE_PATH) -> list[dict[str, Any]]:
+    """Load SWE-bench dataset from cache file.
+
+    Args:
+        cache_path: Path to the cached JSON file
+
+    Returns:
+        List of SWE-bench scenario dicts
+
+    Raises:
+        FileNotFoundError: If cache file doesn't exist
+        json.JSONDecodeError: If cache file is invalid JSON
+    """
+    with open(cache_path, "r") as f:
+        return json.load(f)
+
+
+def find_scenario(
+    data: list[dict[str, Any]],
+    scenario_name: str,
+) -> dict[str, Any] | None:
+    """Find a scenario in SWE-bench data by name.
+
+    Handles various naming formats:
+    - 'flask-5014' matches 'pallets__flask-5014'
+    - 'pallets__flask-5014' matches directly
+
+    Args:
+        data: List of SWE-bench scenario dicts
+        scenario_name: Scenario name to find (flexible matching)
+
+    Returns:
+        Scenario dict if found, None otherwise
+    """
+    for item in data:
+        instance_id = item.get("instance_id", "")
+
+        # Try various matching strategies
+        # Match against normalized ID (pallets__flask-5014 -> pallets-flask-5014)
+        if scenario_name in instance_id.replace("__", "-"):
+            return item
+
+        # Match with __ separator (flask-5014 -> flask__5014)
+        if scenario_name.replace("-", "__") in instance_id:
+            return item
+
+        # Direct match
+        if scenario_name == instance_id:
+            return item
+
+    return None
+
+
+def extract_problem_keywords(problem_statement: str) -> list[str]:
+    """Extract key technical terms from a problem statement.
+
+    Finds:
+    - Quoted strings (backticks, single/double quotes)
+    - CamelCase identifiers
+    - snake_case identifiers
+    - Error/Exception class names
+
+    Args:
+        problem_statement: The problem description text
+
+    Returns:
+        List of unique keywords (max 10)
+    """
+    if not problem_statement:
+        return []
+
+    keywords = []
+
+    # Find quoted terms
+    quoted = re.findall(r"[`'\"]([^`'\"]+)[`'\"]", problem_statement)
+    keywords.extend(quoted)
+
+    # Find CamelCase identifiers (e.g., TypeError, RequestContext)
+    camel_case = re.findall(r"\b[A-Z][a-z]+[A-Z]\w*\b", problem_statement)
+    keywords.extend(camel_case)
+
+    # Find snake_case identifiers (e.g., request_context, app_config)
+    snake_case = re.findall(r"\b\w+_\w+\b", problem_statement)
+    keywords.extend(snake_case)
+
+    # Find Error/Exception class names
+    errors = re.findall(r"\b\w+Error\b|\b\w+Exception\b", problem_statement)
+    keywords.extend(errors)
+
+    # Deduplicate and limit
+    return list(set(keywords))[:10]
+
+
+def get_meaningful_patterns(
+    key_patterns: list[str],
+    exclude_common: bool = True,
+) -> list[str]:
+    """Filter key patterns to meaningful identifiers.
+
+    Removes common Python keywords and short tokens that aren't
+    useful for matching.
+
+    Args:
+        key_patterns: Raw patterns from patch analysis
+        exclude_common: Whether to exclude common words (default True)
+
+    Returns:
+        Filtered list of meaningful patterns
+    """
+    common_words = {
+        "if", "else", "elif", "return", "self", "def", "class",
+        "for", "in", "not", "and", "or", "is", "none", "true",
+        "false", "import", "from", "as", "with", "try", "except",
+        "finally", "raise", "pass", "break", "continue", "while",
+    }
+
+    if exclude_common:
+        return [p for p in key_patterns if p.lower() not in common_words and len(p) > 2]
+    return key_patterns

package/pennyfarthing_scripts/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests for pennyfarthing_scripts package reorganization."""