prizmkit 1.0.35 → 1.0.58

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"

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

@@ -1,153 +0,0 @@
-"""Tests for init-bugfix-pipeline.py."""
-
-import json
-import os
-import sys
-import pytest
-
-
-def _import_init_bugfix_pipeline():
-    import importlib.util
-    path = os.path.join(
-        os.path.dirname(__file__), "..", "scripts", "init-bugfix-pipeline.py"
-    )
-    spec = importlib.util.spec_from_file_location("init_bugfix_pipeline", path)
-    mod = importlib.util.module_from_spec(spec)
-    sys.modules["init_bugfix_pipeline"] = mod
-    spec.loader.exec_module(mod)
-    return mod
-
-
-init_bugfix = _import_init_bugfix_pipeline()
-validate_schema = init_bugfix.validate_schema
-validate_bugs = init_bugfix.validate_bugs
-create_state_directory = init_bugfix.create_state_directory
-
-
-class TestValidateSchema:
-    def test_valid_schema(self, sample_bug_list):
-        errors = validate_schema(sample_bug_list)
-        assert errors == []
-
-    def test_wrong_schema(self):
-        data = {
-            "$schema": "wrong",
-            "project_name": "Test",
-            "bugs": [{"id": "B-001"}],
-        }
-        errors = validate_schema(data)
-        assert any("$schema" in e for e in errors)
-
-    def test_missing_project_name(self):
-        data = {
-            "$schema": "dev-pipeline-bug-fix-list-v1",
-            "bugs": [{"id": "B-001"}],
-        }
-        errors = validate_schema(data)
-        assert any("project_name" in e for e in errors)
-
-    def test_empty_project_name(self):
-        data = {
-            "$schema": "dev-pipeline-bug-fix-list-v1",
-            "project_name": "  ",
-            "bugs": [{"id": "B-001"}],
-        }
-        errors = validate_schema(data)
-        assert any("project_name" in e for e in errors)
-
-    def test_missing_bugs(self):
-        data = {
-            "$schema": "dev-pipeline-bug-fix-list-v1",
-            "project_name": "Test",
-        }
-        errors = validate_schema(data)
-        assert any("bugs" in e for e in errors)
-
-    def test_bugs_not_array(self):
-        data = {
-            "$schema": "dev-pipeline-bug-fix-list-v1",
-            "project_name": "Test",
-            "bugs": "not array",
-        }
-        errors = validate_schema(data)
-        assert any("bugs must be an array" in e for e in errors)
-
-    def test_empty_bugs_array(self):
-        data = {
-            "$schema": "dev-pipeline-bug-fix-list-v1",
-            "project_name": "Test",
-            "bugs": [],
-        }
-        errors = validate_schema(data)
-        assert any("at least one bug" in e for e in errors)
-
-
-class TestValidateBugs:
-    def test_valid_bugs(self, sample_bug_list):
-        errors, ids = validate_bugs(sample_bug_list["bugs"])
-        assert errors == []
-        assert ids == {"B-001", "B-002"}
-
-    def test_duplicate_ids(self):
-        bugs = [
-            _make_bug("B-001"), _make_bug("B-001", title="Other"),
-        ]
-        errors, ids = validate_bugs(bugs)
-        assert any("Duplicate" in e for e in errors)
-
-    def test_invalid_id_format(self):
-        bugs = [_make_bug("X-001")]
-        errors, ids = validate_bugs(bugs)
-        assert any("invalid id" in e for e in errors)
-
-    def test_invalid_severity(self):
-        bug = _make_bug("B-001")
-        bug["severity"] = "super_critical"
-        errors, ids = validate_bugs([bug])
-        assert any("invalid severity" in e for e in errors)
-
-    def test_invalid_verification_type(self):
-        bug = _make_bug("B-001")
-        bug["verification_type"] = "magic"
-        errors, ids = validate_bugs([bug])
-        assert any("invalid verification_type" in e for e in errors)
-
-    def test_invalid_status(self):
-        bug = _make_bug("B-001")
-        bug["status"] = "nonexistent_status"
-        errors, ids = validate_bugs([bug])
-        assert any("invalid status" in e for e in errors)
-
-    def test_missing_required_fields(self):
-        bugs = [{"id": "B-001"}]
-        errors, ids = validate_bugs(bugs)
-        assert len(errors) > 0
-
-    def test_error_source_not_object(self):
-        bug = _make_bug("B-001")
-        bug["error_source"] = "a string"
-        errors, ids = validate_bugs([bug])
-        assert any("error_source must be an object" in e for e in errors)
-
-    def test_error_source_missing_type(self):
-        bug = _make_bug("B-001")
-        bug["error_source"] = {"detail": "something"}
-        errors, ids = validate_bugs([bug])
-        assert any("error_source missing required field: type" in e for e in errors)
-
-    def test_non_dict_bug(self):
-        errors, ids = validate_bugs(["not a dict"])
-        assert any("not an object" in e for e in errors)
-
-
-def _make_bug(bid, title="Test Bug"):
-    return {
-        "id": bid,
-        "title": title,
-        "description": "A bug",
-        "severity": "medium",
-        "error_source": {"type": "stack_trace"},
-        "verification_type": "automated",
-        "acceptance_criteria": ["Fixed"],
-        "status": "pending",
-    }

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

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