prizmkit 1.0.147 → 1.0.148

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

@@ -0,0 +1,446 @@
+"""Tests for auto-skip and unskip functionality in update-feature-status.py."""
+
+import json
+import os
+
+from update_feature_status import (
+    auto_skip_blocked_features,
+    TERMINAL_STATUSES,
+    load_feature_status,
+)
+
+from utils import load_json_file, write_json_file
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_feature(fid, title="Feature", deps=None, status="pending"):
+    return {
+        "id": fid,
+        "title": title,
+        "description": "desc",
+        "priority": "medium",
+        "dependencies": deps or [],
+        "acceptance_criteria": ["ok"],
+        "status": status,
+    }
+
+
+def _make_feature_list(features):
+    return {
+        "$schema": "dev-pipeline-feature-list-v1",
+        "app_name": "test-app",
+        "features": features,
+    }
+
+
+def _init_state(tmp_path, feature_ids):
+    """Create state dir with status.json for each feature."""
+    state_dir = str(tmp_path / "state")
+    for fid in feature_ids:
+        feature_dir = os.path.join(state_dir, "features", fid, "sessions")
+        os.makedirs(feature_dir, exist_ok=True)
+        status_path = os.path.join(state_dir, "features", fid, "status.json")
+        write_json_file(status_path, {
+            "feature_id": fid,
+            "status": "pending",
+            "retry_count": 0,
+            "max_retries": 3,
+            "sessions": [],
+            "last_session_id": None,
+            "resume_from_phase": None,
+            "created_at": "2026-01-01T00:00:00Z",
+            "updated_at": "2026-01-01T00:00:00Z",
+        })
+    return state_dir
+
+
+def _write_fl(tmp_path, features):
+    """Write feature-list.json and return its path."""
+    fl_path = str(tmp_path / "feature-list.json")
+    write_json_file(fl_path, _make_feature_list(features))
+    return fl_path
+
+
+def _read_statuses(fl_path):
+    """Return {feature_id: status} from feature-list.json."""
+    data, _ = load_json_file(fl_path)
+    return {f["id"]: f["status"] for f in data["features"]}
+
+
+# ---------------------------------------------------------------------------
+# TERMINAL_STATUSES
+# ---------------------------------------------------------------------------
+
+class TestTerminalStatuses:
+    def test_auto_skipped_is_terminal(self):
+        assert "auto_skipped" in TERMINAL_STATUSES
+
+    def test_split_is_terminal(self):
+        assert "split" in TERMINAL_STATUSES
+
+    def test_all_expected_statuses(self):
+        assert TERMINAL_STATUSES == {"completed", "failed", "skipped", "auto_skipped", "split"}
+
+
+# ---------------------------------------------------------------------------
+# auto_skip_blocked_features — linear chain
+# ---------------------------------------------------------------------------
+
+class TestAutoSkipLinearChain:
+    """F-001 → F-002 → F-003 linear dependency chain."""
+
+    def test_failing_root_skips_all_downstream(self, tmp_path):
+        features = [
+            _make_feature("F-001", "Root", status="failed"),
+            _make_feature("F-002", "Mid", deps=["F-001"]),
+            _make_feature("F-003", "Leaf", deps=["F-002"]),
+        ]
+        fl_path = _write_fl(tmp_path, features)
+        state_dir = _init_state(tmp_path, ["F-001", "F-002", "F-003"])
+
+        result = auto_skip_blocked_features(fl_path, state_dir, "F-001")
+
+        assert len(result) == 2
+        skipped_ids = {r["feature_id"] for r in result}
+        assert skipped_ids == {"F-002", "F-003"}
+
+        statuses = _read_statuses(fl_path)
+        assert statuses["F-001"] == "failed"
+        assert statuses["F-002"] == "auto_skipped"
+        assert statuses["F-003"] == "auto_skipped"
+
+    def test_status_json_also_updated(self, tmp_path):
+        features = [
+            _make_feature("F-001", "Root", status="failed"),
+            _make_feature("F-002", "Mid", deps=["F-001"]),
+        ]
+        fl_path = _write_fl(tmp_path, features)
+        state_dir = _init_state(tmp_path, ["F-001", "F-002"])
+
+        auto_skip_blocked_features(fl_path, state_dir, "F-001")
+
+        fs = load_feature_status(state_dir, "F-002")
+        assert fs["status"] == "auto_skipped"
+
+    def test_failing_mid_skips_only_downstream(self, tmp_path):
+        features = [
+            _make_feature("F-001", "Root", status="completed"),
+            _make_feature("F-002", "Mid", deps=["F-001"], status="failed"),
+            _make_feature("F-003", "Leaf", deps=["F-002"]),
+        ]
+        fl_path = _write_fl(tmp_path, features)
+        state_dir = _init_state(tmp_path, ["F-001", "F-002", "F-003"])
+
+        result = auto_skip_blocked_features(fl_path, state_dir, "F-002")
+
+        assert len(result) == 1
+        assert result[0]["feature_id"] == "F-003"
+
+        statuses = _read_statuses(fl_path)
+        assert statuses["F-001"] == "completed"
+        assert statuses["F-003"] == "auto_skipped"
+
+
+# ---------------------------------------------------------------------------
+# auto_skip_blocked_features — diamond dependency
+# ---------------------------------------------------------------------------
+
+class TestAutoSkipDiamond:
+    """A → C, B → C diamond where only A fails."""
+
+    def test_diamond_skips_downstream(self, tmp_path):
+        features = [
+            _make_feature("F-001", "A", status="failed"),
+            _make_feature("F-002", "B", status="completed"),
+            _make_feature("F-003", "C", deps=["F-001", "F-002"]),
+        ]
+        fl_path = _write_fl(tmp_path, features)
+        state_dir = _init_state(tmp_path, ["F-001", "F-002", "F-003"])
+
+        result = auto_skip_blocked_features(fl_path, state_dir, "F-001")
+
+        assert len(result) == 1
+        assert result[0]["feature_id"] == "F-003"
+
+    def test_no_skip_when_all_deps_ok(self, tmp_path):
+        features = [
+            _make_feature("F-001", "A", status="completed"),
+            _make_feature("F-002", "B", status="completed"),
+            _make_feature("F-003", "C", deps=["F-001", "F-002"]),
+        ]
+        fl_path = _write_fl(tmp_path, features)
+        state_dir = _init_state(tmp_path, ["F-001", "F-002", "F-003"])
+
+        result = auto_skip_blocked_features(fl_path, state_dir, "F-001")
+
+        assert len(result) == 0
+        assert _read_statuses(fl_path)["F-003"] == "pending"
+
+
+# ---------------------------------------------------------------------------
+# auto_skip_blocked_features — edge cases
+# ---------------------------------------------------------------------------
+
+class TestAutoSkipEdgeCases:
+    def test_no_dependencies_no_skip(self, tmp_path):
+        features = [
+            _make_feature("F-001", "A", status="failed"),
+            _make_feature("F-002", "B"),  # independent
+        ]
+        fl_path = _write_fl(tmp_path, features)
+        state_dir = _init_state(tmp_path, ["F-001", "F-002"])
+
+        result = auto_skip_blocked_features(fl_path, state_dir, "F-001")
+
+        assert len(result) == 0
+        assert _read_statuses(fl_path)["F-002"] == "pending"
+
+    def test_already_completed_not_skipped(self, tmp_path):
+        features = [
+            _make_feature("F-001", "A", status="failed"),
+            _make_feature("F-002", "B", deps=["F-001"], status="completed"),
+        ]
+        fl_path = _write_fl(tmp_path, features)
+        state_dir = _init_state(tmp_path, ["F-001", "F-002"])
+
+        result = auto_skip_blocked_features(fl_path, state_dir, "F-001")
+
+        assert len(result) == 0
+        assert _read_statuses(fl_path)["F-002"] == "completed"
+
+    def test_already_auto_skipped_dep_propagates(self, tmp_path):
+        """If a dep is already auto_skipped (from a previous failure),
+        new downstream features depending on it should also be skipped."""
+        features = [
+            _make_feature("F-001", "A", status="failed"),
+            _make_feature("F-002", "B", deps=["F-001"], status="auto_skipped"),
+            _make_feature("F-003", "C", deps=["F-002"]),  # pending
+        ]
+        fl_path = _write_fl(tmp_path, features)
+        state_dir = _init_state(tmp_path, ["F-001", "F-002", "F-003"])
+
+        result = auto_skip_blocked_features(fl_path, state_dir, "F-001")
+
+        # F-002 is already terminal (auto_skipped), so not re-processed
+        # F-003 should be auto_skipped because its dep F-002 is auto_skipped
+        skipped_ids = {r["feature_id"] for r in result}
+        assert "F-003" in skipped_ids
+        assert _read_statuses(fl_path)["F-003"] == "auto_skipped"
+
+    def test_split_feature_not_skipped(self, tmp_path):
+        features = [
+            _make_feature("F-001", "A", status="failed"),
+            _make_feature("F-002", "B", deps=["F-001"], status="split"),
+        ]
+        fl_path = _write_fl(tmp_path, features)
+        state_dir = _init_state(tmp_path, ["F-001", "F-002"])
+
+        result = auto_skip_blocked_features(fl_path, state_dir, "F-001")
+
+        assert len(result) == 0
+        assert _read_statuses(fl_path)["F-002"] == "split"
+
+    def test_skipped_dep_triggers_auto_skip(self, tmp_path):
+        """When a dependency is manually skipped, downstream should be auto_skipped."""
+        features = [
+            _make_feature("F-001", "A", status="skipped"),
+            _make_feature("F-002", "B", deps=["F-001"]),
+            _make_feature("F-003", "C", deps=["F-002"]),
+        ]
+        fl_path = _write_fl(tmp_path, features)
+        state_dir = _init_state(tmp_path, ["F-001", "F-002", "F-003"])
+
+        result = auto_skip_blocked_features(fl_path, state_dir, "F-001")
+
+        assert len(result) == 2
+        statuses = _read_statuses(fl_path)
+        assert statuses["F-001"] == "skipped"
+        assert statuses["F-002"] == "auto_skipped"
+        assert statuses["F-003"] == "auto_skipped"
+
+
+# ---------------------------------------------------------------------------
+# action_unskip — via subprocess (tests the full CLI interface)
+# ---------------------------------------------------------------------------
+
+import subprocess
+
+_SCRIPT = os.path.join(
+    os.path.dirname(__file__), "..", "scripts", "update-feature-status.py"
+)
+
+
+def _run_unskip(fl_path, state_dir, feature_id=None):
+    cmd = [
+        "python3", _SCRIPT,
+        "--feature-list", fl_path,
+        "--state-dir", state_dir,
+        "--action", "unskip",
+    ]
+    if feature_id:
+        cmd += ["--feature-id", feature_id]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    assert result.returncode == 0, result.stderr
+    return json.loads(result.stdout)
+
+
+def _run_get_next(fl_path, state_dir):
+    cmd = [
+        "python3", _SCRIPT,
+        "--feature-list", fl_path,
+        "--state-dir", state_dir,
+        "--action", "get_next",
+    ]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    return result.stdout.strip()
+
+
+class TestUnskipByFeatureId:
+    """Unskip with --feature-id targets a specific failed feature + downstream."""
+
+    def test_unskip_failed_root_resets_all(self, tmp_path):
+        features = [
+            _make_feature("F-001", "Root", status="failed"),
+            _make_feature("F-002", "Mid", deps=["F-001"], status="auto_skipped"),
+            _make_feature("F-003", "Leaf", deps=["F-002"], status="auto_skipped"),
+        ]
+        fl_path = _write_fl(tmp_path, features)
+        state_dir = _init_state(tmp_path, ["F-001", "F-002", "F-003"])
+
+        result = _run_unskip(fl_path, state_dir, "F-001")
+
+        assert result["reset_count"] == 3
+        statuses = _read_statuses(fl_path)
+        assert all(s == "pending" for s in statuses.values())
+
+    def test_unskip_auto_skipped_leaf_resets_upstream(self, tmp_path):
+        """C2 fix: unskip F-003 must also find and reset F-001 (failed root)."""
+        features = [
+            _make_feature("F-001", "Root", status="failed"),
+            _make_feature("F-002", "Mid", deps=["F-001"], status="auto_skipped"),
+            _make_feature("F-003", "Leaf", deps=["F-002"], status="auto_skipped"),
+        ]
+        fl_path = _write_fl(tmp_path, features)
+        state_dir = _init_state(tmp_path, ["F-001", "F-002", "F-003"])
+
+        result = _run_unskip(fl_path, state_dir, "F-003")
+
+        assert result["reset_count"] == 3
+        reset_ids = {f["feature_id"] for f in result["features"]}
+        assert "F-001" in reset_ids  # transitive upstream reset
+        assert all(s == "pending" for s in _read_statuses(fl_path).values())
+
+    def test_unskip_preserves_completed_features(self, tmp_path):
+        features = [
+            _make_feature("F-001", "Done", status="completed"),
+            _make_feature("F-002", "Failed", deps=["F-001"], status="failed"),
+            _make_feature("F-003", "Skipped", deps=["F-002"], status="auto_skipped"),
+        ]
+        fl_path = _write_fl(tmp_path, features)
+        state_dir = _init_state(tmp_path, ["F-001", "F-002", "F-003"])
+
+        result = _run_unskip(fl_path, state_dir, "F-002")
+
+        assert result["reset_count"] == 2
+        statuses = _read_statuses(fl_path)
+        assert statuses["F-001"] == "completed"  # not touched
+        assert statuses["F-002"] == "pending"
+        assert statuses["F-003"] == "pending"
+
+    def test_unskip_skipped_feature_resets_downstream(self, tmp_path):
+        """Unskip a manually-skipped feature should also reset its auto_skipped downstream."""
+        features = [
+            _make_feature("F-001", "Skipped", status="skipped"),
+            _make_feature("F-002", "Child", deps=["F-001"], status="auto_skipped"),
+        ]
+        fl_path = _write_fl(tmp_path, features)
+        state_dir = _init_state(tmp_path, ["F-001", "F-002"])
+
+        result = _run_unskip(fl_path, state_dir, "F-001")
+
+        assert result["reset_count"] == 2
+        statuses = _read_statuses(fl_path)
+        assert statuses["F-001"] == "pending"
+        assert statuses["F-002"] == "pending"
+
+
+class TestUnskipAll:
+    """Unskip without --feature-id resets all failed + auto_skipped."""
+
+    def test_resets_all_failed_and_auto_skipped(self, tmp_path):
+        features = [
+            _make_feature("F-001", "OK", status="completed"),
+            _make_feature("F-002", "Failed", status="failed"),
+            _make_feature("F-003", "Skipped", deps=["F-002"], status="auto_skipped"),
+            _make_feature("F-004", "Pending", status="pending"),
+        ]
+        fl_path = _write_fl(tmp_path, features)
+        state_dir = _init_state(tmp_path, ["F-001", "F-002", "F-003", "F-004"])
+
+        result = _run_unskip(fl_path, state_dir)
+
+        assert result["reset_count"] == 2
+        statuses = _read_statuses(fl_path)
+        assert statuses["F-001"] == "completed"
+        assert statuses["F-002"] == "pending"
+        assert statuses["F-003"] == "pending"
+        assert statuses["F-004"] == "pending"
+
+
+# ---------------------------------------------------------------------------
+# Integration: auto-skip → get_next → unskip → get_next
+# ---------------------------------------------------------------------------
+
+class TestAutoSkipIntegration:
+    """Full lifecycle: fail → auto-skip → pipeline complete → unskip → resume."""
+
+    def test_full_lifecycle(self, tmp_path):
+        features = [
+            _make_feature("F-001", "Root", status="failed"),
+            _make_feature("F-002", "Child", deps=["F-001"]),
+        ]
+        fl_path = _write_fl(tmp_path, features)
+        state_dir = _init_state(tmp_path, ["F-001", "F-002"])
+
+        # 1. Auto-skip cascades
+        auto_skip_blocked_features(fl_path, state_dir, "F-001")
+        assert _read_statuses(fl_path)["F-002"] == "auto_skipped"
+
+        # 2. get_next should return PIPELINE_COMPLETE
+        assert _run_get_next(fl_path, state_dir) == "PIPELINE_COMPLETE"
+
+        # 3. Unskip recovers everything
+        _run_unskip(fl_path, state_dir, "F-001")
+        statuses = _read_statuses(fl_path)
+        assert statuses["F-001"] == "pending"
+        assert statuses["F-002"] == "pending"
+
+        # 4. get_next should now return F-001
+        output = _run_get_next(fl_path, state_dir)
+        data = json.loads(output)
+        assert data["feature_id"] == "F-001"
+
+    def test_retry_count_reset_after_unskip(self, tmp_path):
+        features = [
+            _make_feature("F-001", "Root", status="failed"),
+        ]
+        fl_path = _write_fl(tmp_path, features)
+        state_dir = _init_state(tmp_path, ["F-001"])
+        # Simulate retry_count = 3
+        fs_path = os.path.join(state_dir, "features", "F-001", "status.json")
+        with open(fs_path) as f:
+            fs = json.load(f)
+        fs["retry_count"] = 3
+        fs["status"] = "failed"
+        with open(fs_path, "w") as f:
+            json.dump(fs, f)
+
+        _run_unskip(fl_path, state_dir, "F-001")
+
+        with open(fs_path) as f:
+            fs = json.load(f)
+        assert fs["retry_count"] == 0
+        assert fs["status"] == "pending"

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.0.147",
+  "version": "1.0.148",
   "skills": {
     "prizm-kit": {
       "description": "Full-lifecycle dev toolkit. Covers spec-driven development, Prizm context docs, code quality, debugging, deployment, and knowledge management.",
@@ -78,6 +78,13 @@
       "hasAssets": true,
       "hasScripts": false
     },
+    "prizmkit-deploy": {
+      "description": "Generate or update deployment documentation (DEPLOY.md) by scanning project state and deploy strategy. Fully autonomous.",
+      "tier": "1",
+      "category": "prizmkit-skill",
+      "hasAssets": true,
+      "hasScripts": false
+    },
     "prizmkit-tool-tech-debt-tracker": {
       "description": "Identify and track technical debt via code pattern analysis.",
       "tier": "1",
@@ -252,6 +259,7 @@
         "prizmkit-code-review",
         "prizmkit-committer",
         "prizmkit-retrospective",
+        "prizmkit-deploy",
         "feature-workflow",
         "refactor-workflow",
         "app-planner",