prizmkit 1.1.107 → 1.1.108

package/bundled/dev-pipeline/scripts/prizmkit-test-gate.py

@@ -1,446 +0,0 @@
-#!/usr/bin/env python3
-"""Scoped PrizmKit test gate for feature pipeline prompts.
-
-The feature bootstrap prompt calls this script instead of embedding the full
-Bash/PowerShell report validation logic inline.  It intentionally prints compact
-`GATE:*` lines so the AI session can decide whether to continue, retry, or stop.
-"""
-
-import argparse
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-REQUIRED_BOUNDARY_COLUMNS = [
-    "Module",
-    "Interface",
-    "Service Type",
-    "Happy Path",
-    "Request Validation",
-    "Auth / Permission / Ownership",
-    "Domain Invariants",
-    "Collection / Pagination",
-    "Date / Time",
-    "State Transitions",
-    "Dependency Failure",
-    "Response Contract",
-    "N/A Reasons",
-    "Final Status",
-]
-
-BOUNDARY_VALIDATOR_CANDIDATES = [
-    ".claude/command-assets/prizmkit-test/scripts/validate_boundary_report.py",
-    ".codebuddy/skills/prizmkit-test/scripts/validate_boundary_report.py",
-    ".agents/skills/prizmkit-test/scripts/validate_boundary_report.py",
-]
-
-OPENAPI_CANDIDATES = [
-    "openapi.yaml",
-    "openapi.yml",
-    "swagger.yaml",
-    "swagger.yml",
-    "docs/openapi.yaml",
-    "docs/openapi.yml",
-    "docs/swagger.yaml",
-    "docs/swagger.yml",
-    "api/openapi.yaml",
-    "api/openapi.yml",
-    "api/swagger.yaml",
-    "api/swagger.yml",
-]
-
-IGNORED_SCOPE_VALUES = {"none", "n/a", "not applicable", "(none)", "{...}", "..."}
-
-
-def default_artifact_dir(feature_slug):
-    return ".prizmkit/specs/{}/".format(feature_slug)
-
-
-def marker_path(feature_slug):
-    return os.path.join(default_artifact_dir(feature_slug), ".prizmkit-test-started")
-
-
-def pointer_path(feature_slug):
-    return os.path.join(default_artifact_dir(feature_slug), "test-report-path.txt")
-
-
-def normalize_artifact_dir(path):
-    return str(path or "").strip().replace("\\", "/").rstrip("/")
-
-
-def read_text(path):
-    with open(path, "r", encoding="utf-8") as fh:
-        return fh.read()
-
-
-def start_gate(feature_slug):
-    marker = marker_path(feature_slug)
-    os.makedirs(os.path.dirname(marker), exist_ok=True)
-    Path(marker).touch()
-    return {"gate": "GATE:START", "marker": marker}
-
-
-def newest_report_after_marker(marker):
-    if not os.path.isfile(marker):
-        return ""
-    try:
-        marker_mtime = os.path.getmtime(marker)
-    except OSError:
-        return ""
-
-    matches = []
-    for root, _dirs, files in os.walk(os.path.join(".prizmkit", "test")):
-        if "test-report.md" not in files:
-            continue
-        path = os.path.join(root, "test-report.md")
-        try:
-            report_mtime = os.path.getmtime(path)
-        except OSError:
-            continue
-        if report_mtime >= marker_mtime:
-            matches.append((report_mtime, path))
-
-    if not matches:
-        return ""
-    return sorted(matches)[-1][1]
-
-
-def extract_section(report_text, heading):
-    in_section = False
-    lines = []
-    for raw_line in report_text.splitlines():
-        line = raw_line.strip()
-        if line == heading:
-            in_section = True
-            continue
-        if in_section and line.startswith("## "):
-            break
-        if in_section:
-            lines.append(raw_line)
-    return lines
-
-
-def extract_scope_field(report_text, field_name):
-    prefix = "- {}:".format(field_name)
-    for raw_line in extract_section(report_text, "## Scope"):
-        line = raw_line.strip()
-        if line.startswith(prefix):
-            return line[len(prefix):].strip()
-    return ""
-
-
-def extract_verdict(report_text):
-    for raw_line in extract_section(report_text, "## Verdict"):
-        line = raw_line.strip()
-        if line:
-            return line
-    return ""
-
-
-def extract_key_value(section_lines, field_name):
-    prefix = "{}:".format(field_name).lower()
-    for raw_line in section_lines:
-        line = raw_line.strip()
-        if line.startswith("-"):
-            line = line[1:].strip()
-        if line.lower().startswith(prefix):
-            return line[len(prefix):].strip()
-    return ""
-
-
-def parse_markdown_cells(line):
-    stripped = line.strip()
-    if not stripped.startswith("|"):
-        return []
-    return [cell.strip() for cell in stripped.strip("|").split("|")]
-
-
-def boundary_columns_ok(matrix_lines):
-    for line in matrix_lines:
-        cells = parse_markdown_cells(line)
-        if cells and all(column in cells for column in REQUIRED_BOUNDARY_COLUMNS):
-            return True
-    return False
-
-
-def boundary_incomplete(matrix_lines):
-    text = "\n".join(matrix_lines).lower()
-    return any(token in text for token in ["boundary-missing", "happy-path-only", "unresolved"])
-
-
-def discover_openapi_file():
-    for candidate in OPENAPI_CANDIDATES:
-        if os.path.isfile(candidate):
-            return candidate
-    return ""
-
-
-def boundary_validator_passed(report_path, openapi_file):
-    for validator in BOUNDARY_VALIDATOR_CANDIDATES:
-        if not os.path.isfile(validator):
-            continue
-        args = [sys.executable, validator, "--report", report_path]
-        if openapi_file:
-            args.extend(["--openapi", openapi_file])
-        result = subprocess.run(
-            args,
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-            check=False,
-        )
-        if result.returncode == 0:
-            return True
-    return False
-
-
-def scope_list(report_text, name):
-    values = []
-    in_list = False
-    marker = "- {}:".format(name)
-    for raw_line in extract_section(report_text, "## Scope"):
-        line = raw_line.strip()
-        if line == marker:
-            in_list = True
-            continue
-        if not in_list:
-            continue
-        if raw_line.startswith("  -") or raw_line.startswith("\t-"):
-            value = line[2:].strip().strip("`")
-            if value and value not in {"{...}", "..."}:
-                values.append(value)
-            continue
-        if line.startswith("- "):
-            break
-    return values
-
-
-def path_is_inside_project(project_root, candidate):
-    try:
-        return os.path.commonpath([project_root, candidate]) == project_root
-    except ValueError:
-        return False
-
-
-def scope_fresh_ok(report_path, marker, report_text):
-    try:
-        report_mtime = os.path.getmtime(report_path)
-        marker_mtime = os.path.getmtime(marker)
-    except OSError:
-        return False
-    if report_mtime < marker_mtime:
-        return False
-
-    source_files = scope_list(report_text, "In-Scope Source Files")
-    test_files = scope_list(report_text, "In-Scope Test Files")
-    if not source_files or not test_files:
-        return False
-
-    project_root = os.path.realpath(os.getcwd())
-    for listed_file in source_files + test_files:
-        normalized = listed_file.strip().strip("`")
-        if not normalized or normalized.lower() in IGNORED_SCOPE_VALUES:
-            return False
-        candidate = normalized if os.path.isabs(normalized) else os.path.join(os.getcwd(), normalized)
-        candidate_real = os.path.realpath(candidate)
-        if not path_is_inside_project(project_root, candidate_real):
-            return False
-        if not os.path.isfile(candidate_real):
-            return False
-        if os.path.getmtime(candidate_real) > report_mtime:
-            return False
-    return True
-
-
-def write_report_pointer(feature_slug, report_path):
-    path = pointer_path(feature_slug)
-    os.makedirs(os.path.dirname(path), exist_ok=True)
-    with open(path, "w", encoding="utf-8") as fh:
-        fh.write(report_path + "\n")
-    return path
-
-
-def update_checkpoint(checkpoint_path):
-    script_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "update-checkpoint.py")
-    if not checkpoint_path:
-        return True, ""
-    result = subprocess.run(
-        [
-            sys.executable,
-            script_path,
-            "--checkpoint-path",
-            checkpoint_path,
-            "--step",
-            "prizmkit-test",
-            "--status",
-            "completed",
-        ],
-        stdout=subprocess.PIPE,
-        stderr=subprocess.STDOUT,
-        text=True,
-        check=False,
-    )
-    if result.returncode == 0:
-        return True, ""
-    output = " ".join((result.stdout or "").split())
-    return False, output[:500]
-
-
-def validate_report(report_path, marker, feature_slug, expected_artifact_dir):
-    try:
-        report_text = read_text(report_path)
-    except OSError as exc:
-        return {
-            "status": "FAIL",
-            "reason": "unreadable_report",
-            "error": str(exc),
-            "report": report_path,
-        }
-
-    report_mode = extract_scope_field(report_text, "Mode")
-    report_artifact_dir = extract_scope_field(report_text, "Artifact Dir")
-    report_verdict = extract_verdict(report_text)
-
-    boundary_gate = extract_section(report_text, "## Boundary Completion Gate")
-    boundary_matrix = extract_section(report_text, "## Boundary Matrix")
-    boundary_validation = extract_section(report_text, "## Boundary Validation")
-
-    gate_passed = extract_key_value(boundary_gate, "Completion gate passed")
-    boundary_missing = extract_key_value(boundary_gate, "Boundary-missing")
-    happy_path_only = extract_key_value(boundary_gate, "Happy-path-only")
-    validation_result = extract_key_value(boundary_validation, "Validator result").lower()
-
-    columns_ok = boundary_columns_ok(boundary_matrix)
-    incomplete = boundary_incomplete(boundary_matrix)
-    openapi_file = discover_openapi_file()
-    validator_ok = boundary_validator_passed(report_path, openapi_file)
-    fresh_ok = scope_fresh_ok(report_path, marker, report_text)
-
-    artifact_ok = normalize_artifact_dir(report_artifact_dir) == normalize_artifact_dir(expected_artifact_dir)
-    boundary_ok = (
-        columns_ok
-        and not incomplete
-        and gate_passed == "yes"
-        and boundary_missing == "0"
-        and happy_path_only == "0"
-        and validation_result == "passed"
-        and validator_ok
-        and fresh_ok
-    )
-
-    result = {
-        "status": "PASS" if report_mode == "this-change" and artifact_ok and report_verdict == "PASS" and boundary_ok else "FAIL",
-        "verdict": report_verdict,
-        "mode": report_mode,
-        "artifact_dir": report_artifact_dir,
-        "boundary_gate": gate_passed,
-        "boundary_missing": boundary_missing,
-        "happy_path_only": happy_path_only,
-        "boundary_validation": validation_result,
-        "validator_passed": "1" if validator_ok else "0",
-        "scope_fresh": "1" if fresh_ok else "0",
-        "openapi": openapi_file,
-        "report": report_path,
-        "feature_slug": feature_slug,
-    }
-    if not columns_ok:
-        result["reason"] = "boundary_columns_missing"
-    elif incomplete:
-        result["reason"] = "boundary_incomplete"
-    elif not fresh_ok:
-        result["reason"] = "scope_not_fresh"
-    elif not artifact_ok:
-        result["reason"] = "wrong_artifact_dir"
-    elif report_mode != "this-change":
-        result["reason"] = "wrong_mode"
-    elif report_verdict != "PASS":
-        result["reason"] = "verdict_not_pass"
-    elif not validator_ok:
-        result["reason"] = "validator_failed"
-    elif not boundary_ok:
-        result["reason"] = "boundary_gate_failed"
-    return result
-
-
-def check_gate(feature_slug, artifact_dir=None, checkpoint_path=None):
-    expected_artifact_dir = artifact_dir or default_artifact_dir(feature_slug)
-    marker = marker_path(feature_slug)
-    report_path = newest_report_after_marker(marker)
-    if not report_path:
-        return {"status": "MISSING", "marker": marker}
-
-    result = validate_report(report_path, marker, feature_slug, expected_artifact_dir)
-    if result["status"] != "PASS":
-        return result
-
-    write_report_pointer(feature_slug, report_path)
-    checkpoint_ok, checkpoint_error = update_checkpoint(checkpoint_path)
-    if not checkpoint_ok:
-        result["status"] = "FAIL"
-        result["reason"] = "checkpoint_update_failed"
-        result["checkpoint_error"] = checkpoint_error
-    return result
-
-
-def format_result(result):
-    status = result.get("status") or result.get("gate", "")
-    if status == "GATE:START":
-        return "GATE:START marker={}".format(result.get("marker", ""))
-    if status == "MISSING":
-        return "GATE:MISSING marker={}".format(result.get("marker", ""))
-    if status == "PASS":
-        return "GATE:PASS {}".format(result.get("report", ""))
-
-    ordered = [
-        "reason",
-        "verdict",
-        "mode",
-        "artifact_dir",
-        "boundary_gate",
-        "boundary_missing",
-        "happy_path_only",
-        "boundary_validation",
-        "validator_passed",
-        "scope_fresh",
-        "openapi",
-        "report",
-        "checkpoint_error",
-        "error",
-    ]
-    parts = []
-    for key in ordered:
-        value = result.get(key)
-        if value is not None and value != "":
-            parts.append("{}={}".format(key, value))
-    return "GATE:FAIL {}".format(" ".join(parts)).rstrip()
-
-
-def build_parser():
-    parser = argparse.ArgumentParser(
-        description="Run the scoped PrizmKit feature test gate.",
-    )
-    subparsers = parser.add_subparsers(dest="command", required=True)
-
-    start = subparsers.add_parser("start", help="Create the test gate marker")
-    start.add_argument("--feature-slug", required=True)
-
-    check = subparsers.add_parser("check", help="Validate the latest scoped test report")
-    check.add_argument("--feature-slug", required=True)
-    check.add_argument("--artifact-dir", default="")
-    check.add_argument("--checkpoint-path", default="")
-    return parser
-
-
-def main(argv=None):
-    parser = build_parser()
-    args = parser.parse_args(argv)
-    if args.command == "start":
-        result = start_gate(args.feature_slug)
-    else:
-        result = check_gate(args.feature_slug, args.artifact_dir, args.checkpoint_path)
-    print(format_result(result))
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/bundled/dev-pipeline/templates/sections/log-size-awareness.md

@@ -1,20 +0,0 @@
-## Session Checkpoint Awareness (CHECKPOINT GUIDANCE)
-
-This section provides passive checkpoint guidance for checkpoint/continuation only. Context-saving rules (anti re-read, output filtering) live in Context Budget Rules above — do not duplicate.
-
-### Checkpoint Before Large Work Batches
-
-- Before major phases or large task batches, update durable artifacts: plan/task checkboxes, context snapshots, implementation/review notes, workflow checkpoints, session status, test reports.
-- Checkpoint often so automatic continuation can resume from durable state.
-- Capture targeted output summaries instead of pasting large raw logs into the conversation.
-
-### Headless Recovery Source of Truth
-
-- Headless recovery must rely on durable checkpoints and artifacts, not interactive slash commands.
-- If context overflow occurs, the runner detects it and starts a fresh continuation session from checkpoint files and durable artifacts.
-- Durable checkpoint files are the source of truth for what was completed, what remains, and which gates were already run.
-
-### Interactive Claude Code Note
-
-- `/compact` may help when a human is manually operating an interactive Claude Code session.
-- `/compact` is optional interactive convenience only — not required for headless recovery.

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

@@ -1,107 +0,0 @@
-"""Tests for prizmkit-test-gate.py."""
-
-import json
-import os
-import time
-from pathlib import Path
-
-from prizmkit_test_gate import check_gate, start_gate
-
-
-def scoped_report_text():
-    return "\n".join([
-        "# Test Report",
-        "",
-        "## Scope",
-        "- Mode: this-change",
-        "- Artifact Dir: .prizmkit/specs/123-scope-test/",
-        "- In-Scope Source Files:",
-        "  - src/feature.js",
-        "- In-Scope Test Files:",
-        "  - tests/feature.test.js",
-        "",
-        "## Boundary Matrix",
-        "| Module | Interface | Service Type | Happy Path | Request Validation | Auth / Permission / Ownership | Domain Invariants | Collection / Pagination | Date / Time | State Transitions | Dependency Failure | Response Contract | N/A Reasons | Final Status |",
-        "|--------|-----------|--------------|------------|--------------------|-------------------------------|-------------------|-------------------------|-------------|-------------------|-------------------|-------------------|-------------|--------------|",
-        "| feature | POST /feature | API | covered | covered | covered | covered | covered | covered | covered | covered | covered | none | boundary-covered |",
-        "",
-        "## Boundary Completion Gate",
-        "- Interfaces total: 1",
-        "- Boundary-covered: 1",
-        "- Boundary-missing: 0",
-        "- Happy-path-only: 0",
-        "- Completion gate passed: yes",
-        "",
-        "## Boundary Validation",
-        "- Validator command: `python3 validate_boundary_report.py`",
-        "- Validator result: passed",
-        "- Validator output: Boundary report validation: PASS",
-        "",
-        "## Verdict",
-        "PASS",
-        "",
-    ])
-
-
-def prepare_project(tmp_path):
-    (tmp_path / "src").mkdir()
-    (tmp_path / "tests").mkdir()
-    (tmp_path / "src" / "feature.js").write_text("export const feature = true;\n", encoding="utf-8")
-    (tmp_path / "tests" / "feature.test.js").write_text("test('feature', () => {});\n", encoding="utf-8")
-
-    validator = tmp_path / ".claude" / "command-assets" / "prizmkit-test" / "scripts" / "validate_boundary_report.py"
-    validator.parent.mkdir(parents=True, exist_ok=True)
-    validator.write_text("import sys\nsys.exit(0)\n", encoding="utf-8")
-
-    checkpoint = tmp_path / ".prizmkit" / "specs" / "123-scope-test" / "workflow-checkpoint.json"
-    checkpoint.parent.mkdir(parents=True, exist_ok=True)
-    checkpoint.write_text(
-        json.dumps({"steps": [{"id": "S01", "skill": "prizmkit-test", "status": "pending"}]}),
-        encoding="utf-8",
-    )
-    return checkpoint
-
-
-def write_report(tmp_path):
-    report = tmp_path / ".prizmkit" / "test" / "run" / "test-report.md"
-    report.parent.mkdir(parents=True, exist_ok=True)
-    time.sleep(0.01)
-    report.write_text(scoped_report_text(), encoding="utf-8")
-    return report
-
-
-def test_gate_pass_writes_pointer_and_updates_checkpoint(tmp_path, monkeypatch):
-    monkeypatch.chdir(tmp_path)
-    checkpoint = prepare_project(tmp_path)
-    start = start_gate("123-scope-test")
-    report = write_report(tmp_path)
-
-    result = check_gate(
-        "123-scope-test",
-        ".prizmkit/specs/123-scope-test/",
-        str(checkpoint),
-    )
-
-    assert start["gate"] == "GATE:START"
-    assert result["status"] == "PASS"
-    assert result["report"] == os.path.join(".prizmkit", "test", "run", "test-report.md")
-    pointer = tmp_path / ".prizmkit" / "specs" / "123-scope-test" / "test-report-path.txt"
-    assert pointer.read_text(encoding="utf-8").strip() == str(report.relative_to(tmp_path))
-    checkpoint_data = json.loads(checkpoint.read_text(encoding="utf-8"))
-    assert checkpoint_data["steps"][0]["status"] == "completed"
-
-
-def test_gate_fails_when_in_scope_file_is_newer_than_report(tmp_path, monkeypatch):
-    monkeypatch.chdir(tmp_path)
-    prepare_project(tmp_path)
-    start_gate("123-scope-test")
-    report = write_report(tmp_path)
-    now = time.time()
-    os.utime(report, (now, now))
-    os.utime(tmp_path / "src" / "feature.js", (now + 10, now + 10))
-
-    result = check_gate("123-scope-test", ".prizmkit/specs/123-scope-test/", "")
-
-    assert result["status"] == "FAIL"
-    assert result["reason"] == "scope_not_fresh"
-    assert result["scope_fresh"] == "0"