prizmkit 1.0.35 → 1.0.58

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

@@ -0,0 +1,207 @@
+"""Tests for generate-bootstrap-prompt.py core functions."""
+
+import re
+
+from generate_bootstrap_prompt import (
+    compute_feature_slug,
+    find_feature,
+    format_acceptance_criteria,
+    format_global_context,
+    get_completed_dependencies,
+    determine_pipeline_mode,
+    process_conditional_blocks,
+    process_mode_blocks,
+)
+
+
+# ---------------------------------------------------------------------------
+# compute_feature_slug
+# ---------------------------------------------------------------------------
+
+class TestComputeFeatureSlug:
+    def test_basic(self):
+        assert compute_feature_slug("F-001", "Project Infrastructure Setup") == "001-project-infrastructure-setup"
+
+    def test_strips_special_chars(self):
+        assert compute_feature_slug("F-012", "Add (User) Auth!") == "012-add-user-auth"
+
+    def test_pads_numeric(self):
+        assert compute_feature_slug("F-1", "Init") == "001-init"
+
+    def test_collapses_hyphens(self):
+        assert compute_feature_slug("F-003", "foo - - bar") == "003-foo---bar" or \
+               compute_feature_slug("F-003", "foo   bar") == "003-foo-bar"
+
+    def test_empty_title(self):
+        result = compute_feature_slug("F-099", "")
+        assert result == "099-"
+
+
+# ---------------------------------------------------------------------------
+# find_feature
+# ---------------------------------------------------------------------------
+
+class TestFindFeature:
+    def test_found(self):
+        features = [{"id": "F-001", "title": "A"}, {"id": "F-002", "title": "B"}]
+        assert find_feature(features, "F-002") == {"id": "F-002", "title": "B"}
+
+    def test_not_found(self):
+        assert find_feature([{"id": "F-001"}], "F-999") is None
+
+    def test_empty_list(self):
+        assert find_feature([], "F-001") is None
+
+    def test_non_dict_items(self):
+        assert find_feature(["garbage", 42, None, {"id": "F-001"}], "F-001") == {"id": "F-001"}
+
+
+# ---------------------------------------------------------------------------
+# format_acceptance_criteria
+# ---------------------------------------------------------------------------
+
+class TestFormatAcceptanceCriteria:
+    def test_none(self):
+        assert format_acceptance_criteria(None) == "- (none specified)"
+
+    def test_empty(self):
+        assert format_acceptance_criteria([]) == "- (none specified)"
+
+    def test_items(self):
+        result = format_acceptance_criteria(["Users can log in", "Password reset works"])
+        assert "- Users can log in" in result
+        assert "- Password reset works" in result
+
+
+# ---------------------------------------------------------------------------
+# format_global_context
+# ---------------------------------------------------------------------------
+
+class TestFormatGlobalContext:
+    def test_none(self):
+        assert format_global_context(None) == "- (none specified)"
+
+    def test_empty(self):
+        assert format_global_context({}) == "- (none specified)"
+
+    def test_dict(self):
+        result = format_global_context({"framework": "React", "lang": "TypeScript"})
+        assert "**framework**: React" in result
+        assert "**lang**: TypeScript" in result
+
+
+# ---------------------------------------------------------------------------
+# get_completed_dependencies
+# ---------------------------------------------------------------------------
+
+class TestGetCompletedDependencies:
+    def test_no_deps(self):
+        feature = {"id": "F-002", "dependencies": []}
+        assert "no dependencies" in get_completed_dependencies([], feature)
+
+    def test_with_completed_dep(self):
+        features = [
+            {"id": "F-001", "title": "Setup", "status": "completed"},
+            {"id": "F-002", "title": "Auth", "dependencies": ["F-001"]},
+        ]
+        result = get_completed_dependencies(features, features[1])
+        assert "F-001" in result
+        assert "completed" in result
+
+    def test_no_completed_dep(self):
+        features = [
+            {"id": "F-001", "title": "Setup", "status": "pending"},
+            {"id": "F-002", "title": "Auth", "dependencies": ["F-001"]},
+        ]
+        result = get_completed_dependencies(features, features[1])
+        assert "no completed dependencies" in result
+
+
+# ---------------------------------------------------------------------------
+# determine_pipeline_mode
+# ---------------------------------------------------------------------------
+
+class TestDeterminePipelineMode:
+    def test_low(self):
+        assert determine_pipeline_mode("low") == "lite"
+
+    def test_medium(self):
+        assert determine_pipeline_mode("medium") == "standard"
+
+    def test_high(self):
+        assert determine_pipeline_mode("high") == "full"
+
+    def test_critical(self):
+        assert determine_pipeline_mode("critical") == "full"
+
+    def test_unknown(self):
+        assert determine_pipeline_mode("banana") == "standard"
+
+
+# ---------------------------------------------------------------------------
+# process_conditional_blocks
+# ---------------------------------------------------------------------------
+
+class TestProcessConditionalBlocks:
+    def test_fresh_start_keeps_fresh_block(self):
+        tpl = "before\n{{IF_FRESH_START}}\nfresh content\n{{END_IF_FRESH_START}}\nafter"
+        result = process_conditional_blocks(tpl, "null")
+        assert "fresh content" in result
+        assert "IF_FRESH_START" not in result
+
+    def test_fresh_start_removes_resume_block(self):
+        tpl = "before\n{{IF_RESUME}}\nresume content\n{{END_IF_RESUME}}\nafter"
+        result = process_conditional_blocks(tpl, "null")
+        assert "resume content" not in result
+
+    def test_resume_keeps_resume_block(self):
+        tpl = "before\n{{IF_RESUME}}\nresume content\n{{END_IF_RESUME}}\nafter"
+        result = process_conditional_blocks(tpl, "3")
+        assert "resume content" in result
+        assert "IF_RESUME" not in result
+
+    def test_resume_removes_fresh_block(self):
+        tpl = "before\n{{IF_FRESH_START}}\nfresh content\n{{END_IF_FRESH_START}}\nafter"
+        result = process_conditional_blocks(tpl, "3")
+        assert "fresh content" not in result
+
+
+# ---------------------------------------------------------------------------
+# process_mode_blocks
+# ---------------------------------------------------------------------------
+
+class TestProcessModeBlocks:
+    def test_lite_mode_keeps_lite(self):
+        tpl = "{{IF_MODE_LITE}}lite content{{END_IF_MODE_LITE}}"
+        result = process_mode_blocks(tpl, "lite", init_done=True)
+        assert "lite content" in result
+        assert "IF_MODE" not in result
+
+    def test_lite_mode_removes_full(self):
+        tpl = "{{IF_MODE_FULL}}full content{{END_IF_MODE_FULL}}"
+        result = process_mode_blocks(tpl, "lite", init_done=True)
+        assert "full content" not in result
+
+    def test_init_done_keeps_init_done_block(self):
+        tpl = "{{IF_INIT_DONE}}\ninit done\n{{END_IF_INIT_DONE}}"
+        result = process_mode_blocks(tpl, "standard", init_done=True)
+        assert "init done" in result
+
+    def test_init_needed_when_not_done(self):
+        tpl = "{{IF_INIT_NEEDED}}\nneed init\n{{END_IF_INIT_NEEDED}}"
+        result = process_mode_blocks(tpl, "standard", init_done=False)
+        assert "need init" in result
+
+    def test_self_evolve_keeps_self_evolve_and_full(self):
+        tpl = (
+            "{{IF_MODE_SELF_EVOLVE}}se content{{END_IF_MODE_SELF_EVOLVE}}"
+            "{{IF_MODE_FULL}}full content{{END_IF_MODE_FULL}}"
+        )
+        result = process_mode_blocks(tpl, "self-evolve", init_done=True)
+        assert "se content" in result
+        assert "full content" in result
+
+    def test_self_evolve_removes_lite(self):
+        tpl = "{{IF_MODE_LITE}}lite content{{END_IF_MODE_LITE}}"
+        result = process_mode_blocks(tpl, "self-evolve", init_done=True)
+        assert "lite content" not in result

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

@@ -1,141 +1,82 @@
-"""Tests for utils.py."""
+"""Tests for dev-pipeline/scripts/utils.py shared utilities."""
 
 import json
 import os
-import pytest
+import tempfile
 
 from utils import load_json_file, write_json_file, pad_right, _build_progress_bar
 
 
-class TestLoadJsonFile:
-    def test_valid_json(self, tmp_path):
-        p = tmp_path / "valid.json"
-        p.write_text('{"key": "value"}', encoding="utf-8")
-        data, err = load_json_file(str(p))
-        assert err is None
-        assert data == {"key": "value"}
-
-    def test_invalid_json(self, tmp_path):
-        p = tmp_path / "invalid.json"
-        p.write_text("{not valid json", encoding="utf-8")
-        data, err = load_json_file(str(p))
-        assert data is None
-        assert "Invalid JSON" in err
-
-    def test_missing_file(self, tmp_path):
-        data, err = load_json_file(str(tmp_path / "missing.json"))
-        assert data is None
-        assert "File not found" in err
-
-    def test_empty_file(self, tmp_path):
-        p = tmp_path / "empty.json"
-        p.write_text("", encoding="utf-8")
-        data, err = load_json_file(str(p))
-        assert data is None
-        assert "Invalid JSON" in err
-
-    def test_unicode_content(self, tmp_path):
-        p = tmp_path / "unicode.json"
-        p.write_text('{"name": "hello"}', encoding="utf-8")
-        data, err = load_json_file(str(p))
-        assert err is None
-        assert data["name"] == "hello"
+# ---------------------------------------------------------------------------
+# load_json_file / write_json_file round-trip
+# ---------------------------------------------------------------------------
 
-    def test_nested_json(self, tmp_path):
-        nested = {"a": {"b": [1, 2, 3]}}
-        p = tmp_path / "nested.json"
-        p.write_text(json.dumps(nested), encoding="utf-8")
-        data, err = load_json_file(str(p))
+class TestJsonIO:
+    def test_round_trip(self, tmp_path):
+        path = str(tmp_path / "data.json")
+        data = {"features": [{"id": "F-001"}]}
+        err = write_json_file(path, data)
         assert err is None
-        assert data == nested
 
-
-class TestWriteJsonFile:
-    def test_write_and_read_back(self, tmp_path):
-        p = str(tmp_path / "output.json")
-        data = {"hello": "world", "num": 42}
-        err = write_json_file(p, data)
+        loaded, err = load_json_file(path)
         assert err is None
-        read_data, read_err = load_json_file(p)
-        assert read_err is None
-        assert read_data == data
-
-    def test_creates_parent_directories(self, tmp_path):
-        p = str(tmp_path / "a" / "b" / "c" / "output.json")
-        err = write_json_file(p, {"nested": True})
+        assert loaded == data
+
+    def test_load_missing_file(self):
+        loaded, err = load_json_file("/nonexistent/path.json")
+        assert loaded is None
+        assert "not found" in err.lower() or "File not found" in err
+
+    def test_load_invalid_json(self, tmp_path):
+        path = str(tmp_path / "bad.json")
+        with open(path, "w") as f:
+            f.write("{invalid json}")
+        loaded, err = load_json_file(path)
+        assert loaded is None
+        assert "invalid" in err.lower() or "Invalid" in err
+
+    def test_write_creates_parent_dirs(self, tmp_path):
+        path = str(tmp_path / "a" / "b" / "c" / "data.json")
+        err = write_json_file(path, {"ok": True})
         assert err is None
-        assert os.path.isfile(p)
-
-    def test_overwrites_existing(self, tmp_path):
-        p = str(tmp_path / "overwrite.json")
-        write_json_file(p, {"v": 1})
-        write_json_file(p, {"v": 2})
-        data, _ = load_json_file(p)
-        assert data["v"] == 2
-
-    def test_unicode_data(self, tmp_path):
-        p = str(tmp_path / "unicode.json")
-        err = write_json_file(p, {"name": "hello"})
-        assert err is None
-        data, _ = load_json_file(p)
-        assert data["name"] == "hello"
+        assert os.path.isfile(path)
+
 
+# ---------------------------------------------------------------------------
+# pad_right
+# ---------------------------------------------------------------------------
 
 class TestPadRight:
-    def test_shorter_than_width(self):
+    def test_basic_padding(self):
         result = pad_right("abc", 10)
         assert len(result) == 10
         assert result == "abc       "
 
-    def test_exact_width(self):
-        result = pad_right("abcde", 5)
-        assert result == "abcde"
-
-    def test_longer_than_width(self):
-        result = pad_right("abcdefgh", 5)
-        assert result == "abcdefgh"
+    def test_no_padding_needed(self):
+        result = pad_right("abcdef", 3)
+        assert result == "abcdef"
 
-    def test_empty_string(self):
-        result = pad_right("", 5)
-        assert result == "     "
+    def test_ansi_escape_ignored(self):
+        # ANSI color code should not count toward visible length
+        text = "\033[31mred\033[0m"  # "red" with ANSI color (3 visible chars)
+        result = pad_right(text, 10)
+        # Visible length is 3, so 7 spaces of padding
+        assert result.endswith("       ")
 
-    def test_ansi_codes_ignored(self):
-        # ANSI escape should not count toward visible length
-        text = "\033[92mHi\033[0m"  # visible "Hi" = 2 chars
-        result = pad_right(text, 5)
-        # visible width is 2, so 3 spaces of padding
-        assert result.endswith("   ")
-
-    def test_zero_width(self):
-        result = pad_right("abc", 0)
-        assert result == "abc"
 
+# ---------------------------------------------------------------------------
+# _build_progress_bar
+# ---------------------------------------------------------------------------
 
 class TestBuildProgressBar:
     def test_zero_percent(self):
-        bar = _build_progress_bar(0)
+        bar = _build_progress_bar(0, width=10)
         assert "0%" in bar
-        assert "\u2591" in bar  # empty blocks
-        assert "\u2588" not in bar  # no filled blocks
-
-    def test_fifty_percent(self):
-        bar = _build_progress_bar(50, width=20)
-        assert "50%" in bar
-        assert bar.count("\u2588") == 10
-        assert bar.count("\u2591") == 10
 
     def test_hundred_percent(self):
-        bar = _build_progress_bar(100, width=20)
+        bar = _build_progress_bar(100, width=10)
         assert "100%" in bar
-        assert bar.count("\u2588") == 20
-        assert bar.count("\u2591") == 0
 
-    def test_custom_width(self):
+    def test_fifty_percent(self):
         bar = _build_progress_bar(50, width=10)
-        assert bar.count("\u2588") == 5
-        assert bar.count("\u2591") == 5
-
-    def test_partial_percent(self):
-        bar = _build_progress_bar(33, width=10)
-        assert bar.count("\u2588") == 3
-        assert bar.count("\u2591") == 7
+        assert "50%" in bar

package/bundled/rules/prizm/prizm-commit-workflow.md

@@ -3,8 +3,8 @@ description: "PrizmKit commit workflow rules"
 ---
 
 Before any git commit in this project:
-1. Update `.prizm-docs/` for affected modules
+1. Run `/prizmkit-retrospective` to sync `.prizm-docs/` (memory maintenance)
 2. Use Conventional Commits format: type(scope): description
 3. Bug fixes use `fix()` prefix, not `feat()`
-4. Do NOT create REGISTRY.md entries for bug fixes
-5. Use `/prizmkit-committer` command for the complete commit workflow
+4. Bug fixes run retrospective with structural sync only (Job 1)
+5. Use `/prizmkit-committer` command for the pure commit workflow

package/bundled/skills/_metadata.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.0.35",
+  "version": "1.0.58",
   "skills": {
     "prizm-kit": {
       "description": "Full-lifecycle dev toolkit. Covers spec-driven development, Prizm context docs, code quality, debugging, deployment, and knowledge management.",
@@ -23,7 +23,7 @@
       "hasScripts": false
     },
     "prizmkit-clarify": {
-      "description": "Interactive requirement clarification. Resolves ambiguities in feature specs.",
+      "description": "Interactive requirement clarification. Resolves ambiguities in feature specs. Use when spec has unclear parts or you're unsure about requirements before planning.",
       "tier": "1",
       "category": "prizmkit-skill",
       "hasAssets": false,
@@ -37,7 +37,7 @@
       "hasScripts": false
     },
     "prizmkit-analyze": {
-      "description": "Cross-document consistency analysis for spec.md and plan.md (including Tasks section).",
+      "description": "Cross-document consistency analysis for spec.md and plan.md. Check if spec and plan are aligned, validate documents before coding.",
       "tier": "1",
       "category": "prizmkit-skill",
       "hasAssets": false,
@@ -58,24 +58,17 @@
       "hasScripts": false
     },
     "prizmkit-committer": {
-      "description": "Commit workflow with automatic Prizm doc updates and changelog management.",
+      "description": "Pure git commit workflow with safety checks. Does NOT modify .prizm-docs/.",
       "tier": "1",
       "category": "prizmkit-skill",
       "hasAssets": false,
       "hasScripts": false
     },
-    "prizmkit-summarize": {
-      "description": "Archive completed features to REGISTRY.md.",
-      "tier": "1",
-      "category": "prizmkit-skill",
-      "hasAssets": true,
-      "hasScripts": false
-    },
     "prizmkit-retrospective": {
-      "description": "Post-feature retrospective. Extracts lessons from completed features.",
+      "description": "Sole .prizm-docs/ maintainer. Update project documentation after code changes. Structural sync + knowledge injection (TRAPS/RULES/DECISIONS). Run after code review passes, before committing.",
       "tier": "1",
       "category": "prizmkit-skill",
-      "hasAssets": false,
+      "hasAssets": true,
       "hasScripts": false
     },
     "prizmkit-prizm-docs": {
@@ -224,6 +217,13 @@
       "category": "Custom-skill",
       "hasAssets": false,
       "hasScripts": false
+    },
+    "bug-fix-workflow": {
+      "description": "Interactive single-bug fix in current session. Guides triage → reproduce → fix → review → commit without background pipeline.",
+      "tier": "companion",
+      "category": "Custom-skill",
+      "hasAssets": false,
+      "hasScripts": false
     }
   },
   "suites": {
@@ -244,14 +244,14 @@
         "prizmkit-implement",
         "prizmkit-code-review",
         "prizmkit-committer",
-        "prizmkit-summarize",
         "prizmkit-retrospective",
         "feature-workflow",
         "refactor-workflow",
         "app-planner",
         "bug-planner",
         "dev-pipeline-launcher",
-        "bugfix-pipeline-launcher"
+        "bugfix-pipeline-launcher",
+        "bug-fix-workflow"
       ]
     },
     "minimal": {
@@ -267,7 +267,6 @@
         "prizmkit-implement",
         "prizmkit-code-review",
         "prizmkit-committer",
-        "prizmkit-summarize",
         "prizmkit-retrospective"
       ]
     }

package/bundled/skills/app-planner/SKILL.md

@@ -92,7 +92,7 @@ Execute the selected scenario workflow in conversation mode with mandatory check
 
 ### Checkpoints (Mandatory Gates)
 
-Never skip checkpoints. If any checkpoint fails, follow error recovery flow (see §Error Recovery).
+Checkpoints catch cascading errors early — skipping one means the next phase builds on unvalidated assumptions, which compounds into much harder debugging later.
 
 | Checkpoint | Artifact/State | Criteria | Phase |
 |-----------|----------------|----------|-------|
@@ -311,16 +311,17 @@ Resume incremental planning? (Y/n)"
 
 ### Artifact Path Convention
 
-Recommended structure for feature planning artifacts:
+The primary output `feature-list.json` is always written to the **project root** — this is where `dev-pipeline-launcher` and all pipeline scripts expect it.
 
 ```
-.prizmkit/planning/
-  ├── feature-list.json              # Primary output (always here)
-  ├── feature-list.validated.json    # Checkpoint backup after CP-AP-5
-  └── <ISO-timestamp>.backup.json    # Optional incremental backups
+<project-root>/
+  ├── feature-list.json              # Primary output (always here, at project root)
+  └── .prizmkit/planning/            # Optional organization for backups
+      ├── feature-list.validated.json    # Checkpoint backup after CP-AP-5
+      └── <ISO-timestamp>.backup.json    # Optional incremental backups
 ```
 
-Mention this path when summarizing (Phase 8 handoff) to help users organize future sessions.
+The pipeline reads `feature-list.json` from the project root by default. If the user specifies a custom path, the launcher accepts it as an argument.
 
 Maintainer note: evaluation workflow moved to `assets/evaluation-guide.md`.