prizmkit 1.0.35 → 1.0.58

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

@@ -1,127 +0,0 @@
-"""Tests for check-session-status.py."""
-
-import json
-import os
-import sys
-import pytest
-
-
-def _import_check_session():
-    import importlib.util
-    path = os.path.join(
-        os.path.dirname(__file__), "..", "scripts", "check-session-status.py"
-    )
-    spec = importlib.util.spec_from_file_location("check_session_status", path)
-    mod = importlib.util.module_from_spec(spec)
-    sys.modules["check_session_status"] = mod
-    spec.loader.exec_module(mod)
-    return mod
-
-
-css = _import_check_session()
-validate_required_fields = css.validate_required_fields
-determine_status = css.determine_status
-
-
-class TestValidateRequiredFields:
-    def test_all_present(self):
-        data = {
-            "session_id": "s-001",
-            "feature_id": "F-001",
-            "status": "success",
-            "timestamp": "2024-01-01T00:00:00Z",
-        }
-        missing = validate_required_fields(data)
-        assert missing == []
-
-    def test_missing_session_id(self):
-        data = {
-            "feature_id": "F-001",
-            "status": "success",
-            "timestamp": "2024-01-01T00:00:00Z",
-        }
-        missing = validate_required_fields(data)
-        assert "session_id" in missing
-
-    def test_missing_multiple(self):
-        data = {"feature_id": "F-001"}
-        missing = validate_required_fields(data)
-        assert "session_id" in missing
-        assert "status" in missing
-        assert "timestamp" in missing
-
-    def test_empty_string_field(self):
-        data = {
-            "session_id": "",
-            "feature_id": "F-001",
-            "status": "success",
-            "timestamp": "2024-01-01T00:00:00Z",
-        }
-        missing = validate_required_fields(data)
-        assert "session_id" in missing
-
-    def test_whitespace_only_field(self):
-        data = {
-            "session_id": "   ",
-            "feature_id": "F-001",
-            "status": "success",
-            "timestamp": "2024-01-01T00:00:00Z",
-        }
-        missing = validate_required_fields(data)
-        assert "session_id" in missing
-
-    def test_non_string_field(self):
-        data = {
-            "session_id": 123,
-            "feature_id": "F-001",
-            "status": "success",
-            "timestamp": "2024-01-01T00:00:00Z",
-        }
-        missing = validate_required_fields(data)
-        assert "session_id" in missing
-
-    def test_empty_data(self):
-        missing = validate_required_fields({})
-        assert len(missing) == 4
-
-
-class TestDetermineStatus:
-    def test_success(self):
-        data = {"status": "success"}
-        assert determine_status(data) == "success"
-
-    def test_failed(self):
-        data = {"status": "failed"}
-        assert determine_status(data) == "failed"
-
-    def test_partial_resumable(self):
-        data = {"status": "partial", "can_resume": True}
-        assert determine_status(data) == "partial_resumable"
-
-    def test_partial_not_resumable(self):
-        data = {"status": "partial", "can_resume": False}
-        assert determine_status(data) == "partial_not_resumable"
-
-    def test_partial_no_resume_key(self):
-        data = {"status": "partial"}
-        assert determine_status(data) == "partial_not_resumable"
-
-    def test_commit_missing(self):
-        data = {"status": "commit_missing"}
-        assert determine_status(data) == "commit_missing"
-
-    def test_docs_missing(self):
-        data = {"status": "docs_missing"}
-        assert determine_status(data) == "docs_missing"
-
-    def test_unknown_status(self):
-        data = {"status": "something_weird"}
-        assert determine_status(data) == "crashed"
-
-    def test_empty_status(self):
-        data = {"status": ""}
-        assert determine_status(data) == "crashed"
-
-    def test_missing_status(self):
-        data = {}
-        assert determine_status(data) == "crashed"

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

@@ -1,119 +0,0 @@
-"""Tests for cleanup-logs.py."""
-
-import json
-import os
-import subprocess
-import sys
-import time
-
-
-def _script_path():
-    return os.path.join(
-        os.path.dirname(__file__), "..", "scripts", "cleanup-logs.py"
-    )
-
-
-def _write_log_file(path, content):
-    os.makedirs(os.path.dirname(path), exist_ok=True)
-    with open(path, "w", encoding="utf-8") as f:
-        f.write(content)
-
-
-def test_iter_log_files_only_sessions_logs(state_dir):
-    # Targeted log path under sessions/*/logs/
-    valid_log = os.path.join(
-        state_dir, "features", "F-001", "sessions", "S-001", "logs", "session.log"
-    )
-    _write_log_file(valid_log, "ok")
-
-    # logs/ not under sessions should be ignored
-    ignored_log = os.path.join(state_dir, "features", "F-001", "logs", "misc.log")
-    _write_log_file(ignored_log, "ignore me")
-
-    # Import script module for direct function test
-    import importlib.util
-
-    path = _script_path()
-    spec = importlib.util.spec_from_file_location("cleanup_logs", path)
-    mod = importlib.util.module_from_spec(spec)
-    sys.modules["cleanup_logs"] = mod
-    spec.loader.exec_module(mod)
-
-    files = list(mod.iter_log_files(state_dir))
-    assert valid_log in files
-    assert ignored_log not in files
-
-
-def test_cleanup_removes_old_logs_by_retention(state_dir):
-    old_log = os.path.join(
-        state_dir, "features", "F-001", "sessions", "S-001", "logs", "session.log"
-    )
-    new_log = os.path.join(
-        state_dir, "features", "F-001", "sessions", "S-002", "logs", "session.log"
-    )
-
-    _write_log_file(old_log, "old")
-    _write_log_file(new_log, "new")
-
-    # Make old log 20 days old
-    old_ts = time.time() - (20 * 86400)
-    os.utime(old_log, (old_ts, old_ts))
-
-    result = subprocess.run(
-        [
-            sys.executable,
-            _script_path(),
-            "--state-dir",
-            state_dir,
-            "--retention-days",
-            "14",
-            "--max-total-mb",
-            "1024",
-        ],
-        check=True,
-        capture_output=True,
-        text=True,
-    )
-
-    report = json.loads(result.stdout)
-    assert report["deleted_by_reason"]["retention"] >= 1
-    assert not os.path.exists(old_log)
-    assert os.path.exists(new_log)
-
-
-def test_cleanup_enforces_total_size_cap(state_dir):
-    log1 = os.path.join(
-        state_dir, "features", "F-001", "sessions", "S-001", "logs", "session.log"
-    )
-    log2 = os.path.join(
-        state_dir, "features", "F-001", "sessions", "S-002", "logs", "session.log"
-    )
-
-    _write_log_file(log1, "a" * 1024)
-    _write_log_file(log2, "b" * 1024)
-
-    # Ensure deterministic ordering: log1 older than log2
-    old_ts = time.time() - 120
-    new_ts = time.time() - 60
-    os.utime(log1, (old_ts, old_ts))
-    os.utime(log2, (new_ts, new_ts))
-
-    result = subprocess.run(
-        [
-            sys.executable,
-            _script_path(),
-            "--state-dir",
-            state_dir,
-            "--retention-days",
-            "999",
-            "--max-total-mb",
-            "0",
-        ],
-        check=True,
-        capture_output=True,
-        text=True,
-    )
-
-    report = json.loads(result.stdout)
-    assert report["deleted_by_reason"]["size"] >= 1
-    assert report["final_total_bytes"] == 0

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

@@ -1,207 +0,0 @@
-"""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

@@ -1,181 +0,0 @@
-"""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"