@pennyfarthing/core 10.0.5 → 10.2.0

package/pennyfarthing_scripts/sprint/story_add.py

@@ -5,6 +5,7 @@ Story: MSSCI-14256 - Sprint story add command
 This module provides:
 - generate_story_id(sprint_data, epic) -> str
 - add_story(sprint_path, epic_id, title, points, ...) -> dict
+- add_initiative_story(initiative_slug, title, points, ...) -> dict
 - story_add_command (Click command for CLI registration)
 """
 
@@ -144,44 +145,218 @@ def add_story(
     }
 
 
+def _generate_initiative_story_id(init_data: dict[str, Any], slug: str) -> str:
+    """Generate the next standalone story ID for an initiative.
+
+    Uses the pattern {slug-prefix}-{N} where slug-prefix is derived from
+    the initiative slug (e.g., "technical-debt" -> "td", "quality-scale" -> "qs").
+    Only counts existing stories that share the same prefix.
+
+    Args:
+        init_data: Initiative YAML data
+        slug: Initiative slug (e.g., "technical-debt")
+
+    Returns:
+        Next story ID string (e.g., "td-2")
+    """
+    # Build prefix from initiative slug initials
+    parts = slug.split("-")
+    prefix = "".join(p[0] for p in parts if p)
+
+    stories = init_data.get("standalone_stories", [])
+    max_seq = 0
+    for story in stories:
+        story_id = str(story.get("id", ""))
+        # Only count stories with matching prefix
+        if not story_id.startswith(f"{prefix}-"):
+            continue
+        suffix = story_id[len(prefix) + 1:]
+        try:
+            seq = int(suffix)
+            if seq > max_seq:
+                max_seq = seq
+        except ValueError:
+            pass
+
+    return f"{prefix}-{max_seq + 1}"
+
+
+def add_initiative_story(
+    initiative_slug: str,
+    title: str,
+    points: int,
+    *,
+    story_type: str | None = None,
+    priority: str = "P1",
+    workflow: str = "tdd",
+    jira: str | None = None,
+    repos: str = "pennyfarthing",
+) -> dict[str, Any]:
+    """Add a standalone story to an initiative YAML file.
+
+    Args:
+        initiative_slug: Initiative slug (e.g., "technical-debt")
+        title: Story title
+        points: Story points
+        story_type: Optional story type (feature, bug, chore, refactor)
+        priority: Priority (default: P1)
+        workflow: Workflow (default: tdd)
+        jira: Optional Jira key
+        repos: Repos (default: pennyfarthing)
+
+    Returns:
+        Dict with success status and story_id or error
+    """
+    from pennyfarthing_scripts.common.config import get_project_root
+
+    root = get_project_root()
+    init_path = root / "sprint" / f"initiative-{initiative_slug}.yaml"
+
+    if not init_path.exists():
+        available = [
+            f.stem.replace("initiative-", "")
+            for f in (root / "sprint").glob("initiative-*.yaml")
+        ]
+        return {
+            "success": False,
+            "error": f"Initiative '{initiative_slug}' not found. Available: {', '.join(sorted(available))}",
+        }
+
+    # Use ruamel.yaml to preserve block scalars and formatting
+    from ruamel.yaml import YAML as RuamelYAML
+
+    ryml = RuamelYAML()
+    ryml.preserve_quotes = True
+    ryml.default_flow_style = False
+    ryml.indent(mapping=2, sequence=4, offset=2)
+    ryml.width = 4096
+
+    with open(init_path) as f:
+        init_data = ryml.load(f)
+
+    if not init_data:
+        return {"success": False, "error": f"Empty initiative file: {init_path}"}
+
+    story_id = _generate_initiative_story_id(init_data, initiative_slug)
+
+    story: dict[str, Any] = {
+        "id": story_id,
+        "title": title,
+        "points": points,
+        "priority": priority,
+        "status": "backlog",
+        "repos": repos,
+        "workflow": workflow,
+    }
+    if jira is not None:
+        story["jira"] = jira
+    if story_type is not None:
+        story["type"] = story_type
+
+    if "standalone_stories" not in init_data:
+        init_data["standalone_stories"] = []
+    init_data["standalone_stories"].append(story)
+
+    # Update total_points
+    current_total = init_data.get("total_points", 0) or 0
+    init_data["total_points"] = current_total + points
+
+    with open(init_path, "w") as f:
+        ryml.dump(init_data, f)
+
+    return {
+        "success": True,
+        "story_id": story_id,
+    }
+
+
 @click.command("add")
-@click.argument("epic_id", type=str)
-@click.argument("title", type=str)
-@click.argument("points", type=int)
+@click.argument("epic_id", type=str, required=False)
+@click.argument("title", type=str, required=False)
+@click.argument("points", type=int, required=False)
 @click.option("--type", "story_type", type=click.Choice(["feature", "bug", "chore", "refactor"]), default="feature")
 @click.option("--priority", type=click.Choice(["P0", "P1", "P2", "P3"]), default="P1")
 @click.option("--workflow", type=click.Choice(["tdd", "trivial", "bdd"]), default="tdd")
 @click.option("--jira", "jira_id", type=str, default=None)
 @click.option("--sprint-file", type=click.Path(), default=None, help="Path to sprint YAML file")
+@click.option("--initiative", type=str, default=None, help="Add as standalone story to initiative (e.g., technical-debt)")
+@click.option("--repos", type=str, default="pennyfarthing", help="Repos (default: pennyfarthing)")
 def story_add_command(
-    epic_id: str,
-    title: str,
-    points: int,
+    epic_id: str | None,
+    title: str | None,
+    points: int | None,
     story_type: str,
     priority: str,
     workflow: str,
     jira_id: str | None,
     sprint_file: str | None,
+    initiative: str | None,
+    repos: str,
 ) -> None:
-    """Add a new story to an epic."""
-    if sprint_file is None:
-        from pennyfarthing_scripts.common.config import get_project_root
-        path = get_project_root() / "sprint" / "current-sprint.yaml"
-    else:
-        path = Path(sprint_file)
-
-    result = add_story(
-        sprint_path=path,
-        epic_id=epic_id,
-        title=title,
-        points=points,
-        story_type=story_type if story_type != "feature" else None,
-        priority=priority,
-        workflow=workflow,
-        jira=jira_id,
-    )
-
-    if result["success"]:
-        click.echo(f"Added story {result['story_id']}: {title} [{points}pts]")
+    """Add a new story to an epic or initiative.
+
+    \b
+    Epic mode (default):
+      pf sprint story add <EPIC_ID> <TITLE> <POINTS>
+
+    Initiative mode (--initiative):
+      pf sprint story add --initiative <SLUG> <TITLE> <POINTS>
+    """
+    if initiative:
+        # Initiative mode: first positional arg is title, second is points
+        # epic_id absorbs the title, title absorbs points (as str)
+        if epic_id is None:
+            raise click.ClickException("TITLE is required")
+        init_title = epic_id
+        if title is None:
+            raise click.ClickException("POINTS is required")
+        try:
+            init_points = int(title)
+        except ValueError as err:
+            raise click.ClickException(f"POINTS must be an integer, got '{title}'") from err
+
+        result = add_initiative_story(
+            initiative_slug=initiative,
+            title=init_title,
+            points=init_points,
+            story_type=story_type if story_type != "feature" else None,
+            priority=priority,
+            workflow=workflow,
+            jira=jira_id,
+            repos=repos,
+        )
+
+        if result["success"]:
+            click.echo(f"Added story {result['story_id']}: {init_title} [{init_points}pts] to initiative {initiative}")
+        else:
+            raise click.ClickException(result["error"])
     else:
-        raise click.ClickException(result["error"])
+        # Epic mode: all three positional args required
+        if epic_id is None:
+            raise click.ClickException("EPIC_ID is required")
+        if title is None:
+            raise click.ClickException("TITLE is required")
+        if points is None:
+            raise click.ClickException("POINTS is required")
+
+        if sprint_file is None:
+            from pennyfarthing_scripts.common.config import get_project_root
+            path = get_project_root() / "sprint" / "current-sprint.yaml"
+        else:
+            path = Path(sprint_file)
+
+        result = add_story(
+            sprint_path=path,
+            epic_id=epic_id,
+            title=title,
+            points=points,
+            story_type=story_type if story_type != "feature" else None,
+            priority=priority,
+            workflow=workflow,
+            jira=jira_id,
+        )
+
+        if result["success"]:
+            click.echo(f"Added story {result['story_id']}: {title} [{points}pts]")
+        else:
+            raise click.ClickException(result["error"])

package/pennyfarthing_scripts/sprint/story_finish.py

@@ -0,0 +1,209 @@
+"""Finish a completed story: archive, merge PR, update Jira, update YAML.
+
+Replaces finish-story.sh with native Python that correctly handles
+sharded epic YAML files via read_sprint/write_sprint.
+
+Steps:
+  1. Archive session file to sprint/archive/{jira-key}-session.md
+  2. Squash merge PR via gh (handle already-merged)
+  3. Transition Jira to Done
+  4. Update sprint YAML (status: done, completed date)
+  5. Archive completed epics
+  6. Git cleanup (checkout develop, pull, delete local branch)
+  7. Remove session file
+"""
+
+import re
+import shutil
+import subprocess
+import sys
+from datetime import date
+from pathlib import Path
+from typing import Any
+
+from pennyfarthing_scripts.sprint.loader import find_epic, find_story
+from pennyfarthing_scripts.sprint.yaml_io import read_sprint, write_sprint
+
+SESSION_FIELD_RE = re.compile(r"\*\*(\w[\w\s]*):\*\*\s*(.*)")
+
+
+def _parse_session(session_path: Path) -> dict[str, str]:
+    """Extract metadata fields from a session markdown file.
+
+    Parses lines like ``**Jira:** MSSCI-14467`` and
+    ``**PR:** #748 - title`` into a dict.
+    """
+    fields: dict[str, str] = {}
+    if not session_path.exists():
+        return fields
+    for line in session_path.read_text().splitlines():
+        m = SESSION_FIELD_RE.search(line)
+        if m:
+            key = m.group(1).strip().lower()
+            value = m.group(2).strip()
+            fields[key] = value
+    return fields
+
+
+def _extract_jira_key(fields: dict[str, str]) -> str | None:
+    """Get Jira key from session fields, handling markdown link format."""
+    raw = fields.get("jira", "")
+    # Strip markdown link: [MSSCI-14467](https://...)
+    raw = re.sub(r"\[([^\]]+)\].*", r"\1", raw).strip()
+    if re.match(r"^MSSCI-\d+$", raw):
+        return raw
+    return None
+
+
+def _extract_pr_number(fields: dict[str, str]) -> str | None:
+    """Get PR number from session fields like ``#748 - title``."""
+    raw = fields.get("pr", "")
+    m = re.search(r"#(\d+)", raw)
+    return m.group(1) if m else None
+
+
+def _extract_branch(fields: dict[str, str]) -> str | None:
+    """Get branch name, stripping trailing annotations like ``(pushed)``."""
+    raw = fields.get("branch", "")
+    return re.sub(r"\s*\(.*\)\s*$", "", raw).strip() or None
+
+
+def _run(cmd: list[str], **kwargs: Any) -> subprocess.CompletedProcess[str]:
+    """Run a subprocess with sane defaults."""
+    return subprocess.run(cmd, capture_output=True, text=True, **kwargs)
+
+
+def finish_story(
+    project_root: Path,
+    story_id: str,
+    *,
+    dry_run: bool = False,
+) -> dict[str, Any]:
+    """Finish a story: archive, merge, update Jira, update YAML, clean up.
+
+    Args:
+        project_root: Project root directory.
+        story_id: Story ID (e.g., "83-2").
+        dry_run: If True, report what would happen without side-effects.
+
+    Returns:
+        Result dict ``{success, data?, error?, steps?}``.
+    """
+    session_path = project_root / ".session" / f"{story_id}-session.md"
+    sprint_path = project_root / "sprint" / "current-sprint.yaml"
+    archive_dir = project_root / "sprint" / "archive"
+    archive_dir.mkdir(parents=True, exist_ok=True)
+
+    # --- Validate session ---
+    if not session_path.exists():
+        return {"success": False, "error": f"Session file not found: {session_path}"}
+
+    fields = _parse_session(session_path)
+    jira_key = _extract_jira_key(fields)
+    branch = _extract_branch(fields)
+    pr_number = _extract_pr_number(fields)
+
+    # Fallback: resolve Jira key from sprint YAML
+    if not jira_key:
+        try:
+            data = read_sprint(sprint_path)
+            parts = story_id.split("-")
+            if len(parts) >= 2:
+                epic = find_epic(data, parts[0])
+                story = find_story(epic, story_id) if epic else None
+                if story:
+                    jira_key = story.get("jira")
+        except Exception:
+            pass
+
+    if not jira_key:
+        return {"success": False, "error": f"Could not determine Jira key for {story_id}"}
+
+    # Fallback: resolve PR from GitHub if not in session
+    if not pr_number and branch:
+        result = _run(["gh", "pr", "list", "--head", branch, "--json", "number", "--jq", ".[0].number"])
+        if result.returncode == 0 and result.stdout.strip():
+            pr_number = result.stdout.strip()
+
+    today = date.today().isoformat()
+    steps: list[dict[str, Any]] = []
+
+    if dry_run:
+        steps.append({"step": 1, "action": f"Archive session → {archive_dir / f'{jira_key}-session.md'}"})
+        if pr_number:
+            steps.append({"step": 2, "action": f"Merge PR #{pr_number} (squash, delete branch)"})
+        else:
+            steps.append({"step": 2, "action": "No PR to merge"})
+        steps.append({"step": 3, "action": f"Transition {jira_key} to Done"})
+        steps.append({"step": 4, "action": f"Update sprint YAML (status: done, completed: {today})"})
+        steps.append({"step": 5, "action": "Archive completed epics"})
+        steps.append({"step": 6, "action": f"Delete local branch: {branch}"})
+        steps.append({"step": 7, "action": "Remove session file"})
+        return {"success": True, "dry_run": True, "jira_key": jira_key, "steps": steps}
+
+    # --- Step 1: Archive session ---
+    archive_dest = archive_dir / f"{jira_key}-session.md"
+    shutil.copy2(session_path, archive_dest)
+    steps.append({"step": 1, "action": "archive_session", "dest": str(archive_dest)})
+
+    # --- Step 2: Merge PR ---
+    if pr_number:
+        result = _run(["gh", "pr", "merge", pr_number, "--squash", "--delete-branch"])
+        if result.returncode == 0:
+            steps.append({"step": 2, "action": "merge_pr", "pr": pr_number})
+        else:
+            steps.append({"step": 2, "action": "merge_pr", "pr": pr_number, "warning": "Already merged or failed"})
+    else:
+        steps.append({"step": 2, "action": "merge_pr", "skipped": True})
+
+    # --- Step 3: Transition Jira ---
+    result = _run(["jira", "issue", "move", jira_key, "Done"])
+    if result.returncode == 0:
+        steps.append({"step": 3, "action": "jira_done", "key": jira_key})
+    else:
+        steps.append({"step": 3, "action": "jira_done", "key": jira_key, "warning": "Already Done or failed"})
+
+    # --- Step 4: Update sprint YAML ---
+    try:
+        data = read_sprint(sprint_path)
+        parts = story_id.split("-")
+        if len(parts) < 2:
+            steps.append({"step": 4, "action": "yaml_update", "error": f"Invalid story ID: {story_id}"})
+        else:
+            epic = find_epic(data, parts[0])
+            story = find_story(epic, story_id) if epic else None
+            if story:
+                story["status"] = "done"
+                story["completed"] = today
+                write_sprint(sprint_path, data)
+                steps.append({"step": 4, "action": "yaml_update", "status": "done", "completed": today})
+            else:
+                steps.append({"step": 4, "action": "yaml_update", "warning": f"Story {story_id} not found in YAML"})
+    except Exception as exc:
+        steps.append({"step": 4, "action": "yaml_update", "error": str(exc)})
+
+    # --- Step 5: Archive completed epics ---
+    result = _run(
+        [sys.executable, "-m", "pennyfarthing_scripts.cli", "sprint", "epic", "archive"],
+        cwd=str(project_root),
+    )
+    steps.append({"step": 5, "action": "archive_epics", "ran": True})
+
+    # --- Step 6: Git cleanup ---
+    _run(["git", "checkout", "develop"], cwd=str(project_root))
+    _run(["git", "pull", "origin", "develop"], cwd=str(project_root))
+    if branch:
+        _run(["git", "branch", "-d", branch], cwd=str(project_root))
+    steps.append({"step": 6, "action": "git_cleanup", "branch": branch})
+
+    # --- Step 7: Remove session file ---
+    if session_path.exists():
+        session_path.unlink()
+    steps.append({"step": 7, "action": "remove_session"})
+
+    return {
+        "success": True,
+        "story_id": story_id,
+        "jira_key": jira_key,
+        "steps": steps,
+    }

package/pennyfarthing_scripts/sprint/story_update.py

@@ -7,6 +7,7 @@ This module provides:
 - story_update_command (Click command for CLI registration)
 """
 
+import subprocess
 from datetime import date
 from pathlib import Path
 from typing import Any
@@ -95,9 +96,6 @@ def update_story(
 
     # Auto-cleanup rules
     if status == "done":
-        # Remove assigned_to
-        if "assigned_to" in story:
-            del story["assigned_to"]
         # Auto-set completed if not explicitly provided
         if completed_date is None and "completed" not in story:
             story["completed"] = date.today().isoformat()
@@ -108,6 +106,16 @@ def update_story(
         # Auto-set started if not already present
         if "started" not in story:
             story["started"] = date.today().isoformat()
+        # Auto-set assignee from current Jira user if not already assigned
+        if "assigned_to" not in story and assigned_to is None:
+            try:
+                result = subprocess.run(
+                    ["jira", "me"], capture_output=True, text=True
+                )
+                if result.returncode == 0 and result.stdout.strip():
+                    story["assigned_to"] = result.stdout.strip()
+            except Exception:
+                pass
 
     # Validate after mutation
     result = validate_full_sprint(data)

package/pennyfarthing_scripts/sprint/validate_cmd.py

@@ -28,7 +28,6 @@ from pennyfarthing_scripts.sprint.yaml_io import (
     SPRINT_KEY_ORDER,
     STORY_KEY_ORDER,
     TOP_KEY_ORDER,
-    canonical_dump,
     read_sprint,
     write_sprint,
 )

package/pennyfarthing_scripts/sprint/validator.py

@@ -78,6 +78,10 @@ REQUIRED_STORY_FIELDS = {"id", "title", "status", "points"}
 # Required fields for epic
 REQUIRED_EPIC_FIELDS = {"id", "title"}
 
+# Required fields for epic shard files (write-time validation, ADR-0022)
+REQUIRED_EPIC_SHARD_FIELDS = {"id", "title", "status", "stories"}
+REQUIRED_SHARD_STORY_FIELDS = {"id", "title", "points", "status"}
+
 # Required fields for future.yaml initiative
 REQUIRED_INITIATIVE_FIELDS = {"name", "status"}
 
@@ -235,6 +239,15 @@ def validate_epic(epic: dict[str, Any], all_story_ids: set[str], epic_index: int
                 f"{base_path}.{field_name}",
             )
 
+    # Reject non-string IDs (YAML parses bare integers like `id: 87` as int,
+    # which crashes Cyclist's sprint-data.ts — epicId.match() fails on non-strings)
+    if "id" in epic and not isinstance(epic["id"], str):
+        result.add_error(
+            f"Epic ID must be a string, got {type(epic['id']).__name__} ({epic['id']!r}). "
+            "Quote it in YAML (e.g., id: \"87\" not id: 87)",
+            f"{base_path}.id",
+        )
+
     # Validate stories if present
     if "stories" in epic:
         seen_in_epic: set[str] = set()
@@ -262,6 +275,95 @@ def validate_epic(epic: dict[str, Any], all_story_ids: set[str], epic_index: int
     return result
 
 
+def validate_epic_shard(epic: dict[str, Any]) -> ValidationResult:
+    """Validate an epic shard dict before writing to disk.
+
+    Enforces stricter requirements than validate_epic() since shards
+    are standalone files that must be self-contained.
+
+    Validates:
+    - Required fields present (id, title, status, stories)
+    - stories is a list
+    - Each story has required fields (id, title, points, status)
+    - No duplicate story IDs within the epic
+    - jira key follows MSSCI-NNNNN pattern if present
+
+    Args:
+        epic: Epic shard dict to validate
+
+    Returns:
+        ValidationResult with any errors found
+    """
+    result = ValidationResult(valid=True)
+
+    # Check required shard fields
+    for field_name in REQUIRED_EPIC_SHARD_FIELDS:
+        if field_name not in epic:
+            result.add_error(
+                f"Missing required field: {field_name}",
+                f"epic.{field_name}",
+            )
+
+    # Reject non-string IDs (YAML parses bare integers like `id: 87` as int,
+    # which crashes Cyclist's sprint-data.ts checkEpicContext — epicId.match() fails)
+    if "id" in epic and not isinstance(epic["id"], str):
+        result.add_error(
+            f"Epic ID must be a string, got {type(epic['id']).__name__} ({epic['id']!r}). "
+            "Quote it in YAML (e.g., id: \"87\" not id: 87)",
+            "epic.id",
+        )
+
+    # Reject epic- prefix in ID (ADR-0022: reference prefix should not be baked into value)
+    if "id" in epic:
+        epic_id_val = str(epic["id"])
+        if epic_id_val.startswith("epic-"):
+            result.add_error(
+                f"Epic ID '{epic_id_val}' starts with 'epic-' prefix. "
+                "Use the numeric ID (e.g., '94' not 'epic-94')",
+                "epic.id",
+            )
+
+    # Validate jira key format if present
+    if "jira" in epic:
+        jira_key = str(epic["jira"])
+        if not JIRA_KEY_PATTERN.match(jira_key):
+            result.add_error(
+                f"Invalid Jira key format '{jira_key}'. Expected MSSCI-NNNNN",
+                "epic.jira",
+            )
+
+    # Validate stories field
+    if "stories" in epic:
+        stories = epic["stories"]
+        if not isinstance(stories, list):
+            result.add_error(
+                "'stories' must be a list",
+                "epic.stories",
+            )
+        else:
+            seen_ids: set[str] = set()
+            epic_id = epic.get("id", "epic")
+            for idx, story in enumerate(stories):
+                story_id = story.get("id")
+                if story_id:
+                    if story_id in seen_ids:
+                        result.add_error(
+                            f"Duplicate story ID '{story_id}' within epic",
+                            f"epic.stories[{idx}].id",
+                        )
+                    seen_ids.add(story_id)
+
+                # Check required story fields
+                for field_name in REQUIRED_SHARD_STORY_FIELDS:
+                    if field_name not in story:
+                        result.add_error(
+                            f"Missing required field: {field_name}",
+                            f"{epic_id}.stories[{idx}].{field_name}",
+                        )
+
+    return result
+
+
 def validate_full_sprint(data: dict[str, Any]) -> ValidationResult:
     """Validate complete sprint YAML including all epics and stories.
 
@@ -356,7 +458,7 @@ def validate_future(data: dict[str, Any]) -> ValidationResult:
         if isinstance(initiative, str):
             continue
         if not isinstance(initiative, dict):
-            result.add_error(f"Initiative must be a mapping", f"future.initiatives[{i}]")
+            result.add_error("Initiative must be a mapping", f"future.initiatives[{i}]")
             continue
 
         base_path = f"future.initiatives[{i}]"
@@ -433,13 +535,15 @@ def validate_future(data: dict[str, Any]) -> ValidationResult:
     return result
 
 
-def validate_sprint_file(file_path: Path) -> ValidationResult:
+def validate_sprint_file(file_path: Path, *, strict: bool = False) -> ValidationResult:
     """Validate a sprint YAML file from disk.
 
-    Loads the file and validates its contents.
+    Loads the file and validates its contents. In strict mode, loader
+    warnings (e.g., unresolvable shard refs) are promoted to errors.
 
     Args:
         file_path: Path to sprint YAML file
+        strict: If True, treat loader warnings as validation errors
 
     Returns:
         ValidationResult with any errors (including load errors)
@@ -509,12 +613,22 @@ def validate_sprint_file(file_path: Path) -> ValidationResult:
         )
         return result
 
-    # Merge sharded epic files if present
+    # Merge sharded epic files if present, capturing warnings in strict mode
     from pennyfarthing_scripts.sprint.loader import _merge_epic_shards
-    data = _merge_epic_shards(data, file_path.parent)
+    if strict:
+        import warnings as _warnings
+        with _warnings.catch_warnings(record=True) as caught:
+            _warnings.simplefilter("always")
+            data = _merge_epic_shards(data, file_path.parent)
+        for w in caught:
+            result.add_error(str(w.message), str(file_path))
+    else:
+        data = _merge_epic_shards(data, file_path.parent)
 
     # Validate loaded data
-    return validate_full_sprint(data)
+    full_result = validate_full_sprint(data)
+    result.merge(full_result)
+    return result
 
 
 def format_validation_errors(result: ValidationResult) -> str: