@pennyfarthing/core 9.2.0 → 9.3.0

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())

package/pennyfarthing_scripts/swebench.py

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

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

package/pennyfarthing_scripts/tests/conftest.py

@@ -1,106 +0,0 @@
-"""Pytest configuration for pennyfarthing_scripts tests.
-
-Story 63-9: Reorganize pennyfarthing_scripts into fan-out CLI pattern.
-"""
-
-import os
-import sys
-from pathlib import Path
-from typing import Generator
-
-import pytest
-
-# Ensure the package is importable
-PROJECT_ROOT = Path(__file__).parent.parent.parent
-if str(PROJECT_ROOT) not in sys.path:
-    sys.path.insert(0, str(PROJECT_ROOT))
-
-
-@pytest.fixture
-def project_root() -> Path:
-    """Return the project root path."""
-    return PROJECT_ROOT
-
-
-@pytest.fixture
-def sprint_yaml_path(project_root: Path) -> Path:
-    """Return path to current-sprint.yaml."""
-    return project_root / "sprint" / "current-sprint.yaml"
-
-
-@pytest.fixture
-def mock_jira_client() -> Generator:
-    """Mock JiraClient for tests that don't need real API calls."""
-    from unittest.mock import MagicMock, patch
-
-    mock_client = MagicMock()
-    mock_client.get_issue_sync.return_value = {
-        "key": "MSSCI-12345",
-        "fields": {
-            "summary": "Test Issue",
-            "status": {"name": "To Do"},
-            "customfield_10031": 3,
-        },
-    }
-    mock_client.get_issue_async.return_value = mock_client.get_issue_sync.return_value
-    mock_client.create_issue_sync.return_value = {"key": "MSSCI-12346", "id": "10001"}
-
-    with patch("pennyfarthing_scripts.jira.client.JiraClient", return_value=mock_client):
-        yield mock_client
-
-
-@pytest.fixture
-def sample_sprint_data() -> dict:
-    """Return sample sprint data for testing."""
-    return {
-        "sprint": {
-            "name": "TO Sprint 2604",
-            "jira_sprint_id": 276,
-            "status": "active",
-            "start_date": "2026-01-20",
-            "end_date": "2026-02-02",
-        },
-        "epics": [
-            {
-                "id": "epic-63",
-                "title": "Test Epic",
-                "jira": "MSSCI-12000",
-                "stories": [
-                    {
-                        "id": "63-1",
-                        "title": "First Story",
-                        "status": "backlog",
-                        "points": 3,
-                        "jira": "MSSCI-12001",
-                    },
-                    {
-                        "id": "63-2",
-                        "title": "Second Story",
-                        "status": "in_progress",
-                        "points": 5,
-                        "jira": "MSSCI-12002",
-                    },
-                ],
-            },
-        ],
-    }
-
-
-@pytest.fixture
-def sample_jira_issue() -> dict:
-    """Return sample Jira issue data for testing."""
-    return {
-        "key": "MSSCI-12345",
-        "id": "10001",
-        "fields": {
-            "summary": "Test Story",
-            "description": {"type": "doc", "content": []},
-            "status": {"name": "To Do"},
-            "issuetype": {"name": "Story"},
-            "priority": {"name": "Medium"},
-            "customfield_10031": 3,  # Story points
-            "customfield_10020": [  # Sprint
-                {"id": 276, "name": "TO Sprint 2604", "state": "active"}
-            ],
-        },
-    }