prizmkit 1.1.153 → 1.1.155

package/bundled/dev-pipeline/tests/test_recovery_workflow.py

@@ -0,0 +1,322 @@
+"""Behavior tests for the canonical detector-only Recovery Workflow."""
+
+from __future__ import annotations
+
+import importlib.util
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+DETECTOR_PATH = (
+    REPO_ROOT
+    / "core"
+    / "skills"
+    / "orchestration-skill"
+    / "workflows"
+    / "recovery-workflow"
+    / "scripts"
+    / "detect-recovery-state.py"
+)
+STATE_DIRS = {
+    "feature": "features",
+    "bugfix": "bugfix",
+    "refactor": "refactor",
+}
+
+
+def _load_detector(name: str):
+    spec = importlib.util.spec_from_file_location(name, DETECTOR_PATH)
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def _git(project: Path, *args: str) -> str:
+    result = subprocess.run(
+        ["git", *args],
+        cwd=project,
+        check=True,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    return result.stdout.strip()
+
+
+def _init_repository(project: Path) -> None:
+    project.mkdir()
+    _git(project, "init", "-b", "main")
+    _git(project, "config", "user.email", "detector@example.com")
+    _git(project, "config", "user.name", "Detector Test")
+    (project / "README.md").write_text("detector fixture\n", encoding="utf-8")
+    _git(project, "add", "README.md")
+    _git(project, "commit", "-m", "fixture")
+
+
+def _write_checkout(
+    project: Path,
+    family: str,
+    task_id: str,
+    branch: str,
+    *,
+    state: str = "active",
+    worktree_path: str | None = None,
+) -> Path:
+    checkout = project / ".prizmkit" / "state" / STATE_DIRS[family] / task_id / "checkout.json"
+    checkout.parent.mkdir(parents=True, exist_ok=True)
+    checkout.write_text(
+        json.dumps(
+            {
+                "task_type": family,
+                "task_id": task_id,
+                "state": state,
+                "active_dev_branch": branch,
+                "base_branch": "main",
+                "checkout_mode": "worktree" if worktree_path else "branch",
+                "worktree_path": worktree_path,
+            }
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+    return checkout
+
+
+def _write_raw_checkout(
+    project: Path,
+    family: str,
+    directory_id: str,
+    payload: dict[str, object],
+) -> Path:
+    checkout = (
+        project
+        / ".prizmkit"
+        / "state"
+        / STATE_DIRS[family]
+        / directory_id
+        / "checkout.json"
+    )
+    checkout.parent.mkdir(parents=True, exist_ok=True)
+    checkout.write_text(json.dumps(payload) + "\n", encoding="utf-8")
+    return checkout
+
+
+def _repository_snapshot(project: Path) -> tuple[str, str, str]:
+    return (
+        _git(project, "branch", "--show-current"),
+        _git(project, "for-each-ref", "--format=%(refname):%(objectname)", "refs/heads"),
+        _git(project, "status", "--porcelain=v1", "--untracked-files=all"),
+    )
+
+
+def _historical_snapshot(historical: Path) -> dict[str, bytes]:
+    return {
+        path.relative_to(historical).as_posix(): path.read_bytes()
+        for path in historical.rglob("*")
+        if path.is_file()
+    }
+
+
+def test_single_active_checkout_reports_operation_first_command_without_mutation(tmp_path):
+    project = tmp_path / "project"
+    _init_repository(project)
+    branch = "dev/F-061-resume"
+    _git(project, "branch", branch)
+    checkout = _write_checkout(project, "feature", "F-061", branch)
+    before = _repository_snapshot(project)
+
+    result = subprocess.run(
+        [sys.executable, str(DETECTOR_PATH), "--project-root", str(project)],
+        cwd=project,
+        check=False,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    report = json.loads(result.stdout)
+
+    assert result.returncode == 0
+    assert result.stderr == ""
+    assert report["detected"] is True
+    assert report["selection_required"] is False
+    assert report["current_branch"] == "main"
+    assert len(report["candidates"]) == 1
+    candidate = report["candidates"][0]
+    assert candidate["family"] == "feature"
+    assert candidate["task_id"] == "F-061"
+    assert candidate["branch"] == branch
+    assert candidate["checkout_path"] == checkout.relative_to(project).as_posix()
+    assert candidate["worktree_path"] is None
+    assert candidate["continue_command"] == (
+        "python3 ./.prizmkit/dev-pipeline/cli.py run feature F-061"
+    )
+    assert _repository_snapshot(project) == before
+    assert not (project / ".prizmkit" / "state" / "recovery").exists()
+
+
+def test_multiple_candidates_remain_skill_owned_and_ignore_historical_recovery_data(tmp_path):
+    project = tmp_path / "project"
+    _init_repository(project)
+    branches = {
+        "feature": ("F-002", "dev/F-002-resume"),
+        "bugfix": ("B-007", "fix/B-007-resume"),
+    }
+    for task_id, branch in branches.values():
+        _git(project, "branch", branch)
+    for family, (task_id, branch) in branches.items():
+        _write_checkout(project, family, task_id, branch)
+
+    historical = project / ".prizmkit" / "state" / "recovery" / "old-session"
+    historical.mkdir(parents=True)
+    (historical / "detection.json").write_text(
+        '{"detected": true, "legacy": true}\n', encoding="utf-8"
+    )
+    history_before = _historical_snapshot(historical)
+    repository_before = _repository_snapshot(project)
+    detector = _load_detector("recovery_workflow_multiple")
+
+    report = detector.build_report(project)
+
+    assert report["detected"] is True
+    assert report["selection_required"] is True
+    assert [candidate["task_id"] for candidate in report["candidates"]] == ["F-002", "B-007"]
+    assert [candidate["continue_command"] for candidate in report["candidates"]] == [
+        "python3 ./.prizmkit/dev-pipeline/cli.py run feature F-002",
+        "python3 ./.prizmkit/dev-pipeline/cli.py run bugfix B-007",
+    ]
+    assert _repository_snapshot(project) == repository_before
+    assert _historical_snapshot(historical) == history_before
+    assert sorted(path.name for path in historical.parent.iterdir()) == ["old-session"]
+
+
+def test_zero_candidates_filters_invalid_records_without_history_fallback_or_session_creation(tmp_path):
+    project = tmp_path / "project"
+    _init_repository(project)
+    completed_branch = "fix/B-003-complete"
+    wrong_family_branch = "dev/B-999-wrong-family"
+    _git(project, "branch", completed_branch)
+    _git(project, "branch", wrong_family_branch)
+    _write_checkout(
+        project,
+        "bugfix",
+        "B-003",
+        completed_branch,
+        state="completed",
+    )
+    _write_checkout(project, "feature", "B-999", wrong_family_branch)
+    _write_checkout(project, "refactor", "R-008", "refactor/R-008-missing")
+
+    historical = project / ".prizmkit" / "state" / "recovery" / "historical-only"
+    historical.mkdir(parents=True)
+    (historical / "bootstrap-prompt.md").write_text("do not read or delete\n", encoding="utf-8")
+    history_before = _historical_snapshot(historical)
+    repository_before = _repository_snapshot(project)
+    detector = _load_detector("recovery_workflow_empty")
+
+    report = detector.build_report(project)
+
+    assert report == {
+        "detected": False,
+        "current_branch": "main",
+        "candidates": [],
+        "message": "No active interrupted pipeline task branch was found.",
+    }
+    assert _repository_snapshot(project) == repository_before
+    assert _historical_snapshot(historical) == history_before
+    assert sorted(path.name for path in historical.parent.iterdir()) == ["historical-only"]
+
+
+def test_detector_rejects_malformed_or_mismatched_checkout_identity(tmp_path):
+    project = tmp_path / "project"
+    _init_repository(project)
+    invalid_records = (
+        (
+            "feature",
+            "F-not-an-id",
+            "dev/F-not-an-id",
+            {
+                "task_type": "feature",
+                "task_id": "F-not-an-id",
+                "state": "active",
+                "active_dev_branch": "dev/F-not-an-id",
+                "base_branch": "main",
+                "checkout_mode": "branch",
+            },
+        ),
+        (
+            "bugfix",
+            "B-004",
+            "bugfix/B-004-missing-id",
+            {
+                "task_type": "bugfix",
+                "state": "active",
+                "active_dev_branch": "bugfix/B-004-missing-id",
+                "base_branch": "main",
+                "checkout_mode": "branch",
+            },
+        ),
+        (
+            "refactor",
+            "R-005",
+            "refactor/R-005-wrong-type",
+            {
+                "task_type": "feature",
+                "task_id": "R-005",
+                "state": "active",
+                "active_dev_branch": "refactor/R-005-wrong-type",
+                "base_branch": "main",
+                "checkout_mode": "branch",
+            },
+        ),
+        (
+            "feature",
+            "F-006",
+            "dev/F-006-path-mismatch",
+            {
+                "task_type": "feature",
+                "task_id": "F-007",
+                "state": "active",
+                "active_dev_branch": "dev/F-006-path-mismatch",
+                "base_branch": "main",
+                "checkout_mode": "branch",
+            },
+        ),
+    )
+    for family, directory_id, branch, payload in invalid_records:
+        _git(project, "branch", branch)
+        _write_raw_checkout(project, family, directory_id, payload)
+
+    detector = _load_detector("recovery_workflow_invalid_identity")
+
+    assert detector.detect_candidates(project) == []
+
+
+def test_recovery_workflow_metadata_matches_detector_only_contract():
+    metadata = json.loads((REPO_ROOT / "core" / "skills" / "_metadata.json").read_text())
+    recovery = metadata["skills"]["recovery-workflow"]
+    description = recovery["description"].lower()
+
+    assert recovery["hasScripts"] is True
+    assert "active feature, bugfix, or refactor checkout records" in description
+    assert "operation-first" in description
+    assert "direct requirement" not in description
+
+
+def test_canonical_recovery_and_cli_guidance_has_no_retired_contracts():
+    env_example = (REPO_ROOT / "dev-pipeline" / ".env.example").read_text(encoding="utf-8")
+    readme = (REPO_ROOT / "README.md").read_text(encoding="utf-8")
+    readme_en = (REPO_ROOT / "README_EN.md").read_text(encoding="utf-8")
+
+    assert "cli.py feature run" not in env_example
+    assert "cli.py run feature" in env_example
+    assert "从断点继续" not in readme
+    assert "reset/clean/unskip/complete" not in readme
+    assert "reset/clean/reset_state/complete" in readme
+    assert "Auto-detect + resume from breakpoint" not in readme_en
+    assert "interrupted at Phase 4" not in readme_en
+    assert "Resumes from Phase 5" not in readme_en
+    assert "Does not execute the command or infer a lifecycle phase" in readme_en