prizmkit 1.0.12 → 1.0.14

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

@@ -0,0 +1,207 @@
+"""Tests for detect-stuck.py."""
+
+import json
+import os
+import sys
+import pytest
+from datetime import datetime, timezone, timedelta
+
+
+def _import_detect_stuck():
+    import importlib.util
+    path = os.path.join(
+        os.path.dirname(__file__), "..", "scripts", "detect-stuck.py"
+    )
+    spec = importlib.util.spec_from_file_location("detect_stuck", path)
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules["detect_stuck"] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+ds = _import_detect_stuck()
+parse_iso_timestamp = ds.parse_iso_timestamp
+check_max_retries = ds.check_max_retries
+check_stuck_checkpoint = ds.check_stuck_checkpoint
+check_dependency_deadlock = ds.check_dependency_deadlock
+
+
+class TestParseIsoTimestamp:
+    def test_standard_z_format(self):
+        result = parse_iso_timestamp("2024-01-15T10:30:00Z")
+        assert result is not None
+        assert result.year == 2024
+        assert result.month == 1
+        assert result.day == 15
+        assert result.hour == 10
+        assert result.minute == 30
+
+    def test_plus_zero_offset(self):
+        result = parse_iso_timestamp("2024-01-15T10:30:00+00:00")
+        assert result is not None
+        assert result.year == 2024
+
+    def test_with_microseconds_z(self):
+        result = parse_iso_timestamp("2024-01-15T10:30:00.123456Z")
+        assert result is not None
+
+    def test_with_microseconds_offset(self):
+        result = parse_iso_timestamp("2024-01-15T10:30:00.123456+00:00")
+        assert result is not None
+
+    def test_invalid_string(self):
+        result = parse_iso_timestamp("not a timestamp")
+        assert result is None
+
+    def test_none_input(self):
+        result = parse_iso_timestamp(None)
+        assert result is None
+
+    def test_integer_input(self):
+        result = parse_iso_timestamp(12345)
+        assert result is None
+
+    def test_empty_string(self):
+        result = parse_iso_timestamp("")
+        assert result is None
+
+
+class TestCheckMaxRetries:
+    def test_below_max(self):
+        status = {"retry_count": 1}
+        result = check_max_retries(status, 3)
+        assert result is None
+
+    def test_at_max(self):
+        status = {"retry_count": 3}
+        result = check_max_retries(status, 3)
+        assert result is not None
+        assert result["reason"] == "max_retries_exceeded"
+
+    def test_above_max(self):
+        status = {"retry_count": 5}
+        result = check_max_retries(status, 3)
+        assert result is not None
+
+    def test_zero_retries(self):
+        status = {"retry_count": 0}
+        result = check_max_retries(status, 3)
+        assert result is None
+
+    def test_missing_retry_count(self):
+        status = {}
+        result = check_max_retries(status, 3)
+        assert result is None  # defaults to 0
+
+    def test_non_int_retry_count(self):
+        status = {"retry_count": "not a number"}
+        result = check_max_retries(status, 3)
+        assert result is None
+
+
+class TestCheckStuckCheckpoint:
+    def _setup_sessions(self, tmp_path, checkpoints):
+        """Create a feature dir with sessions having given checkpoints."""
+        feature_dir = tmp_path / "feature"
+        sessions_dir = feature_dir / "sessions"
+        for i, cp in enumerate(checkpoints):
+            session_dir = sessions_dir / "session-{:03d}".format(i)
+            session_dir.mkdir(parents=True)
+            data = {"checkpoint_reached": cp}
+            (session_dir / "session-status.json").write_text(
+                json.dumps(data), encoding="utf-8"
+            )
+        return str(feature_dir)
+
+    def test_stuck_at_same_checkpoint(self, tmp_path):
+        feature_dir = self._setup_sessions(tmp_path, ["CP-3", "CP-3", "CP-3"])
+        result = check_stuck_checkpoint(feature_dir)
+        assert result is not None
+        assert result["reason"] == "stuck_at_checkpoint"
+        assert "CP-3" in result["details"]
+
+    def test_different_checkpoints(self, tmp_path):
+        feature_dir = self._setup_sessions(tmp_path, ["CP-1", "CP-2", "CP-3"])
+        result = check_stuck_checkpoint(feature_dir)
+        assert result is None
+
+    def test_fewer_than_three_sessions(self, tmp_path):
+        feature_dir = self._setup_sessions(tmp_path, ["CP-3", "CP-3"])
+        result = check_stuck_checkpoint(feature_dir)
+        assert result is None
+
+    def test_no_sessions(self, tmp_path):
+        feature_dir = tmp_path / "feature"
+        feature_dir.mkdir()
+        result = check_stuck_checkpoint(str(feature_dir))
+        assert result is None
+
+    def test_none_checkpoints(self, tmp_path):
+        feature_dir = self._setup_sessions(tmp_path, [None, None, None])
+        result = check_stuck_checkpoint(feature_dir)
+        assert result is None  # None checkpoints don't trigger stuck
+
+    def test_mixed_with_last_three_same(self, tmp_path):
+        feature_dir = self._setup_sessions(
+            tmp_path, ["CP-1", "CP-2", "CP-3", "CP-3", "CP-3"]
+        )
+        result = check_stuck_checkpoint(feature_dir)
+        assert result is not None
+        assert "CP-3" in result["details"]
+
+
+class TestCheckDependencyDeadlock:
+    def test_dependency_failed(self, state_dir):
+        # Create a failed dependency
+        dep_dir = os.path.join(state_dir, "features", "F-001")
+        os.makedirs(dep_dir, exist_ok=True)
+        with open(os.path.join(dep_dir, "status.json"), "w") as f:
+            json.dump({"status": "failed"}, f)
+
+        feature_list_data = {
+            "features": [
+                {"id": "F-001", "dependencies": []},
+                {"id": "F-002", "dependencies": ["F-001"]},
+            ]
+        }
+        result = check_dependency_deadlock("F-002", feature_list_data, state_dir)
+        assert result is not None
+        assert result["reason"] == "dependency_failed"
+        assert "F-001" in result["details"]
+
+    def test_dependency_completed(self, state_dir):
+        dep_dir = os.path.join(state_dir, "features", "F-001")
+        os.makedirs(dep_dir, exist_ok=True)
+        with open(os.path.join(dep_dir, "status.json"), "w") as f:
+            json.dump({"status": "completed"}, f)
+
+        feature_list_data = {
+            "features": [
+                {"id": "F-001", "dependencies": []},
+                {"id": "F-002", "dependencies": ["F-001"]},
+            ]
+        }
+        result = check_dependency_deadlock("F-002", feature_list_data, state_dir)
+        assert result is None
+
+    def test_no_dependencies(self, state_dir):
+        feature_list_data = {
+            "features": [
+                {"id": "F-001", "dependencies": []},
+            ]
+        }
+        result = check_dependency_deadlock("F-001", feature_list_data, state_dir)
+        assert result is None
+
+    def test_none_feature_list(self, state_dir):
+        result = check_dependency_deadlock("F-001", None, state_dir)
+        assert result is None
+
+    def test_feature_not_found(self, state_dir):
+        feature_list_data = {
+            "features": [
+                {"id": "F-001", "dependencies": []},
+            ]
+        }
+        result = check_dependency_deadlock("F-999", feature_list_data, state_dir)
+        assert result is None

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

@@ -0,0 +1,181 @@
+"""Tests for generate-bugfix-prompt.py."""
+
+import os
+import sys
+import pytest
+
+
+def _import_generate_bugfix_prompt():
+    import importlib.util
+    path = os.path.join(
+        os.path.dirname(__file__), "..", "scripts", "generate-bugfix-prompt.py"
+    )
+    spec = importlib.util.spec_from_file_location("generate_bugfix_prompt", path)
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules["generate_bugfix_prompt"] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+gen_bugfix = _import_generate_bugfix_prompt()
+format_acceptance_criteria = gen_bugfix.format_acceptance_criteria
+format_global_context = gen_bugfix.format_global_context
+format_error_source_details = gen_bugfix.format_error_source_details
+format_environment = gen_bugfix.format_environment
+process_conditional_blocks = gen_bugfix.process_conditional_blocks
+
+
+class TestFormatAcceptanceCriteria:
+    def test_normal(self):
+        result = format_acceptance_criteria(["Fix A", "Fix B"])
+        assert result == "- Fix A\n- Fix B"
+
+    def test_empty(self):
+        result = format_acceptance_criteria([])
+        assert "none specified" in result
+
+    def test_none(self):
+        result = format_acceptance_criteria(None)
+        assert "none specified" in result
+
+    def test_single(self):
+        result = format_acceptance_criteria(["Only one"])
+        assert result == "- Only one"
+
+
+class TestFormatGlobalContext:
+    def test_normal(self):
+        result = format_global_context({"lang": "Python"})
+        assert "**lang**" in result
+        assert "Python" in result
+
+    def test_empty(self):
+        assert "none specified" in format_global_context({})
+
+    def test_none(self):
+        assert "none specified" in format_global_context(None)
+
+
+class TestFormatErrorSourceDetails:
+    def test_stack_trace(self):
+        error_source = {
+            "type": "stack_trace",
+            "stack_trace": "Traceback ... Error",
+            "error_message": "Something broke",
+        }
+        result = format_error_source_details(error_source)
+        assert "Stack Trace" in result
+        assert "Traceback ... Error" in result
+        assert "Error Message" in result
+        assert "Something broke" in result
+
+    def test_log_pattern(self):
+        error_source = {
+            "type": "log_pattern",
+            "log_snippet": "ERROR 2024-01-01 ...",
+        }
+        result = format_error_source_details(error_source)
+        assert "Log Snippet" in result
+
+    def test_failed_test(self):
+        error_source = {
+            "type": "failed_test",
+            "failed_test_path": "tests/test_auth.py::test_login",
+        }
+        result = format_error_source_details(error_source)
+        assert "Failed Test" in result
+        assert "test_auth.py" in result
+
+    def test_user_report(self):
+        error_source = {
+            "type": "user_report",
+            "reproduction_steps": ["Step 1", "Step 2"],
+        }
+        result = format_error_source_details(error_source)
+        assert "Reproduction Steps" in result
+        assert "Step 1" in result
+        assert "Step 2" in result
+
+    def test_none_source(self):
+        result = format_error_source_details(None)
+        assert "no error source details" in result
+
+    def test_empty_source(self):
+        result = format_error_source_details({})
+        assert "no error source details" in result
+
+    def test_non_dict_source(self):
+        result = format_error_source_details("not a dict")
+        assert "no error source details" in result
+
+    def test_unknown_type_with_error_message(self):
+        error_source = {
+            "type": "unknown",
+            "error_message": "Something happened",
+        }
+        result = format_error_source_details(error_source)
+        assert "Error Message" in result
+
+
+class TestFormatEnvironment:
+    def test_normal(self):
+        result = format_environment({"os": "macOS", "browser": "Chrome"})
+        assert "**browser**" in result
+        assert "**os**" in result
+
+    def test_empty(self):
+        result = format_environment({})
+        assert "not specified" in result
+
+    def test_none(self):
+        result = format_environment(None)
+        assert "not specified" in result
+
+    def test_non_dict(self):
+        result = format_environment("not a dict")
+        assert "not specified" in result
+
+    def test_empty_values_filtered(self):
+        result = format_environment({"os": "macOS", "empty_key": ""})
+        assert "os" in result
+        # empty_key should be filtered because its value is falsy
+        assert "empty_key" not in result
+
+    def test_all_empty_values(self):
+        result = format_environment({"a": "", "b": None})
+        assert "not specified" in result
+
+
+class TestProcessConditionalBlocks:
+    def test_manual_verification_keeps_block(self):
+        bug = {"verification_type": "manual"}
+        content = "before\n{{IF_VERIFICATION_MANUAL_OR_HYBRID}}\nmanual stuff\n{{END_IF_VERIFICATION_MANUAL_OR_HYBRID}}\nafter"
+        result = process_conditional_blocks(content, bug)
+        assert "manual stuff" in result
+        assert "{{IF_VERIFICATION" not in result
+
+    def test_hybrid_verification_keeps_block(self):
+        bug = {"verification_type": "hybrid"}
+        content = "{{IF_VERIFICATION_MANUAL_OR_HYBRID}}\nhybrid stuff\n{{END_IF_VERIFICATION_MANUAL_OR_HYBRID}}"
+        result = process_conditional_blocks(content, bug)
+        assert "hybrid stuff" in result
+
+    def test_automated_verification_removes_block(self):
+        bug = {"verification_type": "automated"}
+        content = "before\n{{IF_VERIFICATION_MANUAL_OR_HYBRID}}\nmanual stuff\n{{END_IF_VERIFICATION_MANUAL_OR_HYBRID}}\nafter"
+        result = process_conditional_blocks(content, bug)
+        assert "manual stuff" not in result
+        assert "after" in result
+
+    def test_no_verification_type_defaults_automated(self):
+        bug = {}
+        content = "{{IF_VERIFICATION_MANUAL_OR_HYBRID}}\nstuff\n{{END_IF_VERIFICATION_MANUAL_OR_HYBRID}}\nrest"
+        result = process_conditional_blocks(content, bug)
+        assert "stuff" not in result
+        assert "rest" in result
+
+    def test_no_conditional_blocks(self):
+        bug = {"verification_type": "automated"}
+        content = "plain text"
+        result = process_conditional_blocks(content, bug)
+        assert result == "plain text"

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

@@ -0,0 +1,190 @@
+"""Tests for generate-bootstrap-prompt.py."""
+
+import os
+import sys
+import pytest
+
+
+def _import_generate_prompt():
+    import importlib.util
+    path = os.path.join(
+        os.path.dirname(__file__), "..", "scripts", "generate-bootstrap-prompt.py"
+    )
+    spec = importlib.util.spec_from_file_location("generate_bootstrap_prompt", path)
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules["generate_bootstrap_prompt"] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+gen_prompt = _import_generate_prompt()
+compute_feature_slug = gen_prompt.compute_feature_slug
+format_acceptance_criteria = gen_prompt.format_acceptance_criteria
+format_global_context = gen_prompt.format_global_context
+process_conditional_blocks = gen_prompt.process_conditional_blocks
+process_mode_blocks = gen_prompt.process_mode_blocks
+determine_pipeline_mode = gen_prompt.determine_pipeline_mode
+
+
+class TestComputeFeatureSlug:
+    def test_basic(self):
+        result = compute_feature_slug("F-001", "Project Infrastructure Setup")
+        assert result == "001-project-infrastructure-setup"
+
+    def test_special_characters(self):
+        result = compute_feature_slug("F-002", "User Auth (OAuth2.0)")
+        assert result == "002-user-auth-oauth20"
+
+    def test_uppercase_id(self):
+        result = compute_feature_slug("F-042", "My Feature")
+        assert result == "042-my-feature"
+
+    def test_lowercase_f(self):
+        result = compute_feature_slug("f-5", "Quick Fix")
+        assert result == "005-quick-fix"
+
+    def test_extra_spaces(self):
+        result = compute_feature_slug("F-010", "  Extra   Spaces  ")
+        assert result == "010-extra-spaces"
+
+    def test_empty_title(self):
+        result = compute_feature_slug("F-001", "")
+        # Numeric part only, no trailing hyphen
+        assert result.startswith("001")
+
+    def test_numeric_padding(self):
+        result = compute_feature_slug("F-1", "Test")
+        assert result.startswith("001-")
+
+
+class TestFormatAcceptanceCriteria:
+    def test_single_item(self):
+        result = format_acceptance_criteria(["Must work"])
+        assert result == "- Must work"
+
+    def test_multiple_items(self):
+        result = format_acceptance_criteria(["A", "B", "C"])
+        assert result == "- A\n- B\n- C"
+
+    def test_empty_list(self):
+        result = format_acceptance_criteria([])
+        assert "none specified" in result
+
+    def test_none_input(self):
+        result = format_acceptance_criteria(None)
+        assert "none specified" in result
+
+
+class TestFormatGlobalContext:
+    def test_basic(self):
+        result = format_global_context({"language": "Python", "framework": "FastAPI"})
+        assert "**framework**" in result
+        assert "**language**" in result
+        assert "Python" in result
+        assert "FastAPI" in result
+
+    def test_sorted_keys(self):
+        result = format_global_context({"z_key": "z", "a_key": "a"})
+        lines = result.split("\n")
+        assert "a_key" in lines[0]
+        assert "z_key" in lines[1]
+
+    def test_empty_context(self):
+        result = format_global_context({})
+        assert "none specified" in result
+
+    def test_none_context(self):
+        result = format_global_context(None)
+        assert "none specified" in result
+
+
+class TestProcessConditionalBlocks:
+    def test_fresh_start_keeps_fresh_block(self):
+        content = "before\n{{IF_FRESH_START}}\nfresh content\n{{END_IF_FRESH_START}}\nafter"
+        result = process_conditional_blocks(content, "null")
+        assert "fresh content" in result
+        assert "{{IF_FRESH_START}}" not in result
+        assert "after" in result
+
+    def test_fresh_start_removes_resume_block(self):
+        content = "before\n{{IF_RESUME}}\nresume content\n{{END_IF_RESUME}}\nafter"
+        result = process_conditional_blocks(content, "null")
+        assert "resume content" not in result
+        assert "after" in result
+
+    def test_resume_keeps_resume_block(self):
+        content = "before\n{{IF_RESUME}}\nresume content\n{{END_IF_RESUME}}\nafter"
+        result = process_conditional_blocks(content, "3")
+        assert "resume content" in result
+        assert "{{IF_RESUME}}" not in result
+
+    def test_resume_removes_fresh_block(self):
+        content = "before\n{{IF_FRESH_START}}\nfresh content\n{{END_IF_FRESH_START}}\nafter"
+        result = process_conditional_blocks(content, "3")
+        assert "fresh content" not in result
+        assert "after" in result
+
+    def test_no_conditional_blocks(self):
+        content = "just plain text"
+        result = process_conditional_blocks(content, "null")
+        assert result == "just plain text"
+
+
+class TestProcessModeBlocks:
+    def test_keeps_matching_mode(self):
+        content = "before\n{{IF_MODE_LITE}}\nlite content\n{{END_IF_MODE_LITE}}\nafter"
+        result = process_mode_blocks(content, "lite", False)
+        assert "lite content" in result
+        assert "{{IF_MODE_LITE}}" not in result
+
+    def test_removes_non_matching_mode(self):
+        content = "{{IF_MODE_FULL}}\nfull content\n{{END_IF_MODE_FULL}}\nrest"
+        result = process_mode_blocks(content, "lite", False)
+        assert "full content" not in result
+        assert "rest" in result
+
+    def test_init_done_keeps_init_done_block(self):
+        content = "{{IF_INIT_DONE}}\ninit done\n{{END_IF_INIT_DONE}}\n"
+        result = process_mode_blocks(content, "standard", True)
+        assert "init done" in result
+
+    def test_init_done_removes_init_needed_block(self):
+        content = "{{IF_INIT_NEEDED}}\nneed init\n{{END_IF_INIT_NEEDED}}\n"
+        result = process_mode_blocks(content, "standard", True)
+        assert "need init" not in result
+
+    def test_init_not_done_keeps_init_needed_block(self):
+        content = "{{IF_INIT_NEEDED}}\nneed init\n{{END_IF_INIT_NEEDED}}\n"
+        result = process_mode_blocks(content, "standard", False)
+        assert "need init" in result
+
+    def test_multiple_modes(self):
+        content = (
+            "{{IF_MODE_LITE}}\nlite\n{{END_IF_MODE_LITE}}\n"
+            "{{IF_MODE_STANDARD}}\nstandard\n{{END_IF_MODE_STANDARD}}\n"
+            "{{IF_MODE_FULL}}\nfull\n{{END_IF_MODE_FULL}}\n"
+        )
+        result = process_mode_blocks(content, "standard", False)
+        assert "lite" not in result
+        assert "standard" in result
+        assert "full" not in result
+
+
+class TestDeterminePipelineMode:
+    def test_low_complexity(self):
+        assert determine_pipeline_mode("low") == "lite"
+
+    def test_medium_complexity(self):
+        assert determine_pipeline_mode("medium") == "standard"
+
+    def test_high_complexity(self):
+        assert determine_pipeline_mode("high") == "full"
+
+    def test_critical_complexity(self):
+        assert determine_pipeline_mode("critical") == "full"
+
+    def test_unknown_complexity(self):
+        assert determine_pipeline_mode("unknown") == "standard"
+
+    def test_none_complexity(self):
+        assert determine_pipeline_mode(None) == "standard"