prizmkit 1.0.45 → 1.0.66

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

@@ -1,131 +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_merge_conflict(self):
-        data = {"status": "merge_conflict"}
-        assert determine_status(data) == "merge_conflict"
-
-    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_prompt.py

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