prizmkit 1.0.13 → 1.0.14

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

@@ -0,0 +1,241 @@
+"""Tests for init-pipeline.py."""
+
+import json
+import os
+import sys
+import importlib
+import pytest
+
+
+# The module has a hyphen in the name, so we need importlib
+def _import_init_pipeline():
+    import importlib.util
+    path = os.path.join(
+        os.path.dirname(__file__), "..", "scripts", "init-pipeline.py"
+    )
+    spec = importlib.util.spec_from_file_location("init_pipeline", path)
+    mod = importlib.util.module_from_spec(spec)
+    # Prevent main() from running on import
+    sys.modules["init_pipeline"] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+init_pipeline = _import_init_pipeline()
+validate_schema = init_pipeline.validate_schema
+validate_features = init_pipeline.validate_features
+check_dag = init_pipeline.check_dag
+create_state_directory = init_pipeline.create_state_directory
+
+
+class TestValidateSchema:
+    def test_valid_schema(self, sample_feature_list):
+        errors = validate_schema(sample_feature_list)
+        assert errors == []
+
+    def test_wrong_schema_value(self):
+        data = {
+            "$schema": "wrong-schema",
+            "app_name": "Test",
+            "features": [],
+        }
+        errors = validate_schema(data)
+        assert len(errors) == 1
+        assert "Invalid $schema" in errors[0]
+
+    def test_missing_schema(self):
+        data = {"app_name": "Test", "features": []}
+        errors = validate_schema(data)
+        assert any("$schema" in e for e in errors)
+
+    def test_missing_app_name(self):
+        data = {
+            "$schema": "dev-pipeline-feature-list-v1",
+            "features": [],
+        }
+        errors = validate_schema(data)
+        assert any("app_name" in e for e in errors)
+
+    def test_empty_app_name(self):
+        data = {
+            "$schema": "dev-pipeline-feature-list-v1",
+            "app_name": "   ",
+            "features": [],
+        }
+        errors = validate_schema(data)
+        assert any("app_name" in e for e in errors)
+
+    def test_missing_features(self):
+        data = {
+            "$schema": "dev-pipeline-feature-list-v1",
+            "app_name": "Test",
+        }
+        errors = validate_schema(data)
+        assert any("features" in e for e in errors)
+
+    def test_features_not_array(self):
+        data = {
+            "$schema": "dev-pipeline-feature-list-v1",
+            "app_name": "Test",
+            "features": "not an array",
+        }
+        errors = validate_schema(data)
+        assert any("features must be an array" in e for e in errors)
+
+
+class TestValidateFeatures:
+    def test_valid_features(self, sample_feature_list):
+        errors, ids = validate_features(sample_feature_list["features"])
+        assert errors == []
+        assert ids == {"F-001", "F-002", "F-003"}
+
+    def test_duplicate_ids(self):
+        features = [
+            {"id": "F-001", "title": "A", "description": "D", "priority": 1,
+             "dependencies": [], "acceptance_criteria": [], "status": "pending"},
+            {"id": "F-001", "title": "B", "description": "D", "priority": 2,
+             "dependencies": [], "acceptance_criteria": [], "status": "pending"},
+        ]
+        errors, ids = validate_features(features)
+        assert any("Duplicate" in e for e in errors)
+
+    def test_invalid_id_format(self):
+        features = [
+            {"id": "X-001", "title": "A", "description": "D", "priority": 1,
+             "dependencies": [], "acceptance_criteria": [], "status": "pending"},
+        ]
+        errors, ids = validate_features(features)
+        assert any("invalid id" in e for e in errors)
+
+    def test_missing_required_fields(self):
+        features = [{"id": "F-001"}]
+        errors, ids = validate_features(features)
+        # Should have errors for missing title, description, etc.
+        assert len(errors) > 0
+        assert any("missing required field" in e for e in errors)
+
+    def test_non_object_feature(self):
+        features = ["not a dict"]
+        errors, ids = validate_features(features)
+        assert any("not an object" in e for e in errors)
+
+    def test_unknown_dependency(self):
+        features = [
+            {"id": "F-001", "title": "A", "description": "D", "priority": 1,
+             "dependencies": ["F-999"], "acceptance_criteria": [], "status": "pending"},
+        ]
+        errors, ids = validate_features(features)
+        assert any("unknown feature" in e for e in errors)
+
+    def test_dependencies_not_array(self):
+        features = [
+            {"id": "F-001", "title": "A", "description": "D", "priority": 1,
+             "dependencies": "not-a-list", "acceptance_criteria": [], "status": "pending"},
+        ]
+        errors, ids = validate_features(features)
+        assert any("dependencies must be an array" in e for e in errors)
+
+
+class TestCheckDag:
+    def test_simple_chain(self):
+        features = [
+            {"id": "F-001", "dependencies": []},
+            {"id": "F-002", "dependencies": ["F-001"]},
+            {"id": "F-003", "dependencies": ["F-002"]},
+        ]
+        errors = check_dag(features)
+        assert errors == []
+
+    def test_diamond_dependency(self):
+        features = [
+            {"id": "F-001", "dependencies": []},
+            {"id": "F-002", "dependencies": ["F-001"]},
+            {"id": "F-003", "dependencies": ["F-001"]},
+            {"id": "F-004", "dependencies": ["F-002", "F-003"]},
+        ]
+        errors = check_dag(features)
+        assert errors == []
+
+    def test_circular_dependency(self):
+        features = [
+            {"id": "F-001", "dependencies": ["F-003"]},
+            {"id": "F-002", "dependencies": ["F-001"]},
+            {"id": "F-003", "dependencies": ["F-002"]},
+        ]
+        errors = check_dag(features)
+        assert len(errors) == 1
+        assert "cycle" in errors[0].lower()
+
+    def test_self_dependency(self):
+        features = [
+            {"id": "F-001", "dependencies": ["F-001"]},
+        ]
+        errors = check_dag(features)
+        assert len(errors) == 1
+        assert "cycle" in errors[0].lower()
+
+    def test_no_features(self):
+        errors = check_dag([])
+        assert errors == []
+
+    def test_independent_features(self):
+        features = [
+            {"id": "F-001", "dependencies": []},
+            {"id": "F-002", "dependencies": []},
+        ]
+        errors = check_dag(features)
+        assert errors == []
+
+
+class TestCreateStateDirectory:
+    def test_creates_expected_structure(self, tmp_path, sample_feature_list):
+        state_dir = str(tmp_path / "state")
+        fl_path = str(tmp_path / "feature-list.json")
+        with open(fl_path, "w") as f:
+            json.dump(sample_feature_list, f)
+
+        result = create_state_directory(
+            state_dir, fl_path, sample_feature_list["features"]
+        )
+
+        assert os.path.isdir(result)
+        assert os.path.isfile(os.path.join(result, "pipeline.json"))
+
+        # Check per-feature dirs
+        for feature in sample_feature_list["features"]:
+            fid = feature["id"]
+            fdir = os.path.join(result, "features", fid)
+            assert os.path.isdir(fdir)
+            assert os.path.isfile(os.path.join(fdir, "status.json"))
+            assert os.path.isdir(os.path.join(fdir, "sessions"))
+
+    def test_pipeline_json_contents(self, tmp_path, sample_feature_list):
+        state_dir = str(tmp_path / "state")
+        fl_path = str(tmp_path / "fl.json")
+        with open(fl_path, "w") as f:
+            json.dump(sample_feature_list, f)
+
+        create_state_directory(state_dir, fl_path, sample_feature_list["features"])
+
+        with open(os.path.join(state_dir, "pipeline.json")) as f:
+            pipeline = json.load(f)
+
+        assert pipeline["status"] == "initialized"
+        assert pipeline["total_features"] == 3
+        assert pipeline["completed_features"] == 0
+        assert pipeline["run_id"].startswith("run-")
+
+    def test_feature_status_contents(self, tmp_path, sample_feature_list):
+        state_dir = str(tmp_path / "state")
+        fl_path = str(tmp_path / "fl.json")
+        with open(fl_path, "w") as f:
+            json.dump(sample_feature_list, f)
+
+        create_state_directory(state_dir, fl_path, sample_feature_list["features"])
+
+        with open(os.path.join(state_dir, "features", "F-001", "status.json")) as f:
+            status = json.load(f)
+
+        assert status["feature_id"] == "F-001"
+        assert status["status"] == "pending"
+        assert status["retry_count"] == 0

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

@@ -0,0 +1,142 @@
+"""Tests for update-bug-status.py."""
+
+import json
+import os
+import re
+import sys
+import pytest
+
+
+def _import_update_bug_status():
+    import importlib.util
+    path = os.path.join(
+        os.path.dirname(__file__), "..", "scripts", "update-bug-status.py"
+    )
+    spec = importlib.util.spec_from_file_location("update_bug_status", path)
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules["update_bug_status"] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+ubs = _import_update_bug_status()
+now_iso = ubs.now_iso
+load_bug_status = ubs.load_bug_status
+save_bug_status = ubs.save_bug_status
+action_get_next = ubs.action_get_next
+SEVERITY_PRIORITY = ubs.SEVERITY_PRIORITY
+
+
+class TestNowIso:
+    def test_valid_format(self):
+        result = now_iso()
+        pattern = r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$"
+        assert re.match(pattern, result) is not None
+
+
+class TestLoadAndSaveBugStatus:
+    def test_round_trip(self, bugfix_state_dir):
+        bid = "B-001"
+        bdir = os.path.join(bugfix_state_dir, "bugs", bid)
+        os.makedirs(bdir, exist_ok=True)
+
+        data = {
+            "bug_id": bid,
+            "status": "in_progress",
+            "retry_count": 2,
+            "max_retries": 3,
+            "sessions": ["s-001"],
+            "last_session_id": "s-001",
+            "resume_from_phase": None,
+            "created_at": "2024-01-01T00:00:00Z",
+            "updated_at": "2024-01-01T01:00:00Z",
+        }
+        err = save_bug_status(bugfix_state_dir, bid, data)
+        assert err is None
+
+        loaded = load_bug_status(bugfix_state_dir, bid)
+        assert loaded["bug_id"] == bid
+        assert loaded["status"] == "in_progress"
+        assert loaded["retry_count"] == 2
+
+    def test_load_missing_returns_default(self, bugfix_state_dir):
+        result = load_bug_status(bugfix_state_dir, "B-999")
+        assert result["bug_id"] == "B-999"
+        assert result["status"] == "pending"
+        assert result["retry_count"] == 0
+
+    def test_load_invalid_json_returns_default(self, bugfix_state_dir):
+        bid = "B-BAD"
+        bdir = os.path.join(bugfix_state_dir, "bugs", bid)
+        os.makedirs(bdir, exist_ok=True)
+        with open(os.path.join(bdir, "status.json"), "w") as f:
+            f.write("not json!")
+        result = load_bug_status(bugfix_state_dir, bid)
+        assert result["status"] == "pending"
+
+
+class TestActionGetNext:
+    def test_selects_critical_before_medium(self, bugfix_state_dir, capsys):
+        bug_list = {
+            "bugs": [
+                {"id": "B-001", "title": "Low", "severity": "medium", "priority": 1},
+                {"id": "B-002", "title": "High", "severity": "critical", "priority": 2},
+            ]
+        }
+        action_get_next(bug_list, bugfix_state_dir)
+        captured = capsys.readouterr()
+        result = json.loads(captured.out)
+        assert result["bug_id"] == "B-002"
+        assert result["severity"] == "critical"
+
+    def test_same_severity_sorted_by_priority(self, bugfix_state_dir, capsys):
+        bug_list = {
+            "bugs": [
+                {"id": "B-001", "title": "P3", "severity": "high", "priority": 3},
+                {"id": "B-002", "title": "P1", "severity": "high", "priority": 1},
+            ]
+        }
+        action_get_next(bug_list, bugfix_state_dir)
+        captured = capsys.readouterr()
+        result = json.loads(captured.out)
+        assert result["bug_id"] == "B-002"
+
+    def test_all_completed_prints_pipeline_complete(self, bugfix_state_dir, capsys):
+        bug_list = {"bugs": [{"id": "B-001", "title": "Done", "severity": "low"}]}
+        # Mark as completed
+        bdir = os.path.join(bugfix_state_dir, "bugs", "B-001")
+        os.makedirs(bdir, exist_ok=True)
+        with open(os.path.join(bdir, "status.json"), "w") as f:
+            json.dump({"status": "completed"}, f)
+        action_get_next(bug_list, bugfix_state_dir)
+        captured = capsys.readouterr()
+        assert "PIPELINE_COMPLETE" in captured.out
+
+    def test_empty_bugs_prints_pipeline_complete(self, bugfix_state_dir, capsys):
+        action_get_next({"bugs": []}, bugfix_state_dir)
+        captured = capsys.readouterr()
+        assert "PIPELINE_COMPLETE" in captured.out
+
+    def test_prefers_in_progress_over_pending(self, bugfix_state_dir, capsys):
+        bug_list = {
+            "bugs": [
+                {"id": "B-001", "title": "Pending", "severity": "critical", "priority": 1},
+                {"id": "B-002", "title": "In Progress", "severity": "low", "priority": 2},
+            ]
+        }
+        # Mark B-002 as in_progress
+        bdir = os.path.join(bugfix_state_dir, "bugs", "B-002")
+        os.makedirs(bdir, exist_ok=True)
+        with open(os.path.join(bdir, "status.json"), "w") as f:
+            json.dump({"status": "in_progress", "retry_count": 0}, f)
+        action_get_next(bug_list, bugfix_state_dir)
+        captured = capsys.readouterr()
+        result = json.loads(captured.out)
+        assert result["bug_id"] == "B-002"
+
+
+class TestSeverityPriority:
+    def test_order(self):
+        assert SEVERITY_PRIORITY["critical"] < SEVERITY_PRIORITY["high"]
+        assert SEVERITY_PRIORITY["high"] < SEVERITY_PRIORITY["medium"]
+        assert SEVERITY_PRIORITY["medium"] < SEVERITY_PRIORITY["low"]

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

@@ -0,0 +1,277 @@
+"""Tests for update-feature-status.py."""
+
+import json
+import os
+import re
+import sys
+import pytest
+from types import SimpleNamespace
+
+
+def _import_update_feature_status():
+    import importlib.util
+    path = os.path.join(
+        os.path.dirname(__file__), "..", "scripts", "update-feature-status.py"
+    )
+    spec = importlib.util.spec_from_file_location("update_feature_status", path)
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules["update_feature_status"] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+ufs = _import_update_feature_status()
+now_iso = ufs.now_iso
+load_feature_status = ufs.load_feature_status
+save_feature_status = ufs.save_feature_status
+_build_feature_slug = ufs._build_feature_slug
+_format_duration = ufs._format_duration
+_calc_feature_duration = ufs._calc_feature_duration
+
+
+class TestSessionStatusValues:
+    def test_contains_commit_missing(self):
+        assert "commit_missing" in ufs.SESSION_STATUS_VALUES
+
+    def test_contains_docs_missing(self):
+        assert "docs_missing" in ufs.SESSION_STATUS_VALUES
+
+
+class TestNowIso:
+    def test_returns_valid_iso_format(self):
+        result = now_iso()
+        # Should match YYYY-MM-DDTHH:MM:SSZ
+        pattern = r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$"
+        assert re.match(pattern, result) is not None
+
+    def test_returns_string(self):
+        assert isinstance(now_iso(), str)
+
+
+class TestLoadAndSaveFeatureStatus:
+    def test_round_trip(self, state_dir):
+        fid = "F-001"
+        # Create the feature directory
+        fdir = os.path.join(state_dir, "features", fid)
+        os.makedirs(fdir, exist_ok=True)
+
+        status_data = {
+            "feature_id": fid,
+            "status": "in_progress",
+            "retry_count": 1,
+            "max_retries": 3,
+            "sessions": ["s-001"],
+            "last_session_id": "s-001",
+            "resume_from_phase": "3",
+            "created_at": "2024-01-01T00:00:00Z",
+            "updated_at": "2024-01-01T01:00:00Z",
+        }
+        err = save_feature_status(state_dir, fid, status_data)
+        assert err is None
+
+        loaded = load_feature_status(state_dir, fid)
+        assert loaded["feature_id"] == fid
+        assert loaded["status"] == "in_progress"
+        assert loaded["retry_count"] == 1
+
+    def test_load_missing_returns_default(self, state_dir):
+        result = load_feature_status(state_dir, "F-999")
+        assert result["feature_id"] == "F-999"
+        assert result["status"] == "pending"
+        assert result["retry_count"] == 0
+
+    def test_load_invalid_json_returns_default(self, state_dir):
+        fid = "F-BAD"
+        fdir = os.path.join(state_dir, "features", fid)
+        os.makedirs(fdir, exist_ok=True)
+        with open(os.path.join(fdir, "status.json"), "w") as f:
+            f.write("{invalid json")
+        result = load_feature_status(state_dir, fid)
+        assert result["status"] == "pending"
+
+
+class TestBuildFeatureSlug:
+    def test_basic(self):
+        assert _build_feature_slug("F-001", "Project Setup") == "001-project-setup"
+
+    def test_special_chars(self):
+        result = _build_feature_slug("F-002", "Auth (OAuth2.0)")
+        assert result == "002-auth-oauth20"
+
+    def test_empty_title(self):
+        result = _build_feature_slug("F-003", "")
+        assert result == "003-feature"
+
+    def test_none_title(self):
+        result = _build_feature_slug("F-003", None)
+        assert result == "003-feature"
+
+    def test_lowercase_f(self):
+        result = _build_feature_slug("f-5", "Test")
+        assert result == "005-test"
+
+    def test_numeric_padding(self):
+        result = _build_feature_slug("F-1", "A")
+        assert result.startswith("001-")
+
+
+class TestFormatDuration:
+    def test_none(self):
+        assert _format_duration(None) == "N/A"
+
+    def test_seconds(self):
+        assert _format_duration(45) == "45s"
+
+    def test_minutes(self):
+        assert _format_duration(125) == "2m5s"
+
+    def test_hours(self):
+        assert _format_duration(3661) == "1h1m"
+
+    def test_zero(self):
+        assert _format_duration(0) == "0s"
+
+    def test_exact_minute(self):
+        assert _format_duration(60) == "1m0s"
+
+    def test_exact_hour(self):
+        assert _format_duration(3600) == "1h0m"
+
+
+class TestCalcFeatureDuration:
+    def test_valid_duration(self, state_dir):
+        fid = "F-001"
+        fdir = os.path.join(state_dir, "features", fid)
+        os.makedirs(fdir, exist_ok=True)
+        status = {
+            "created_at": "2024-01-01T00:00:00Z",
+            "updated_at": "2024-01-01T00:05:00Z",  # 300 seconds
+        }
+        with open(os.path.join(fdir, "status.json"), "w") as f:
+            json.dump(status, f)
+        result = _calc_feature_duration(state_dir, fid)
+        assert result == 300.0
+
+    def test_too_short_duration(self, state_dir):
+        fid = "F-002"
+        fdir = os.path.join(state_dir, "features", fid)
+        os.makedirs(fdir, exist_ok=True)
+        status = {
+            "created_at": "2024-01-01T00:00:00Z",
+            "updated_at": "2024-01-01T00:00:05Z",  # 5 seconds - below 10s threshold
+        }
+        with open(os.path.join(fdir, "status.json"), "w") as f:
+            json.dump(status, f)
+        result = _calc_feature_duration(state_dir, fid)
+        assert result is None
+
+    def test_missing_file(self, state_dir):
+        result = _calc_feature_duration(state_dir, "F-MISSING")
+        assert result is None
+
+    def test_missing_timestamps(self, state_dir):
+        fid = "F-003"
+        fdir = os.path.join(state_dir, "features", fid)
+        os.makedirs(fdir, exist_ok=True)
+        with open(os.path.join(fdir, "status.json"), "w") as f:
+            json.dump({"status": "pending"}, f)
+        result = _calc_feature_duration(state_dir, fid)
+        assert result is None
+
+
+class TestActionUpdateDegradedStatuses:
+    def test_commit_missing_updates_feature_state_without_cleanup(
+        self, feature_list_file, state_dir, monkeypatch, capsys
+    ):
+        called = {"cleanup": 0}
+
+        def _fake_cleanup(**_kwargs):
+            called["cleanup"] += 1
+            return []
+
+        monkeypatch.setattr(ufs, "cleanup_feature_artifacts", _fake_cleanup)
+
+        args = SimpleNamespace(
+            feature_id="F-001",
+            session_status="commit_missing",
+            session_id="s-commit-missing",
+            max_retries=3,
+            project_root=None,
+        )
+
+        ufs.action_update(args, feature_list_file, state_dir)
+        out = capsys.readouterr().out
+        summary = json.loads(out)
+
+        fs = ufs.load_feature_status(state_dir, "F-001")
+        assert fs["status"] == "commit_missing"
+        assert fs["retry_count"] == 1
+        assert summary["new_status"] == "commit_missing"
+        assert summary["degraded_reason"] == "commit_missing"
+        assert summary["restart_policy"] == "finalization_retry"
+        assert called["cleanup"] == 0
+
+        with open(feature_list_file, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        f1 = next(x for x in data["features"] if x["id"] == "F-001")
+        assert f1["status"] == "commit_missing"
+
+    def test_docs_missing_reaches_failed_when_retry_exhausted(
+        self, feature_list_file, state_dir, monkeypatch, capsys
+    ):
+        called = {"cleanup": 0}
+
+        def _fake_cleanup(**_kwargs):
+            called["cleanup"] += 1
+            return []
+
+        monkeypatch.setattr(ufs, "cleanup_feature_artifacts", _fake_cleanup)
+
+        args = SimpleNamespace(
+            feature_id="F-001",
+            session_status="docs_missing",
+            session_id="s-docs-missing",
+            max_retries=1,
+            project_root=None,
+        )
+
+        ufs.action_update(args, feature_list_file, state_dir)
+        out = capsys.readouterr().out
+        summary = json.loads(out)
+
+        fs = ufs.load_feature_status(state_dir, "F-001")
+        assert fs["status"] == "failed"
+        assert fs["retry_count"] == 1
+        assert summary["new_status"] == "failed"
+        assert summary["degraded_reason"] == "docs_missing"
+        assert summary["restart_policy"] == "finalization_retry"
+        assert called["cleanup"] == 0
+
+        with open(feature_list_file, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        f1 = next(x for x in data["features"] if x["id"] == "F-001")
+        assert f1["status"] == "failed"
+
+
+class TestActionStatusForDegradedStates:
+    def test_status_output_contains_degraded_counters(self, feature_list_file, state_dir, capsys):
+        # Prepare commit_missing and docs_missing statuses
+        f1_dir = os.path.join(state_dir, "features", "F-001")
+        f2_dir = os.path.join(state_dir, "features", "F-002")
+        os.makedirs(f1_dir, exist_ok=True)
+        os.makedirs(f2_dir, exist_ok=True)
+
+        with open(os.path.join(f1_dir, "status.json"), "w", encoding="utf-8") as f:
+            json.dump({"status": "commit_missing", "retry_count": 1, "max_retries": 3}, f)
+        with open(os.path.join(f2_dir, "status.json"), "w", encoding="utf-8") as f:
+            json.dump({"status": "docs_missing", "retry_count": 2, "max_retries": 3}, f)
+
+        with open(feature_list_file, "r", encoding="utf-8") as f:
+            feature_list_data = json.load(f)
+
+        ufs.action_status(feature_list_data, state_dir)
+        out = capsys.readouterr().out
+
+        assert "Commit Missing: 1 | Docs Missing: 1" in out
+        assert "commit missing, retry 1/3" in out
+        assert "docs missing, retry 2/3" in out