prizmkit 1.1.100 → 1.1.102

package/bundled/dev-pipeline-windows/scripts/patch-completion-notes.py

@@ -1,191 +0,0 @@
-#!/usr/bin/env python3
-"""Patch completion_notes into feature-list.json, refactor-list.json, or bug-fix-list.json.
-
-Reads a completion-summary.json file written by the AI session and patches
-the corresponding item in the task list with the completion_notes field.
-
-This enables rich dependency context propagation: when a downstream task's
-bootstrap prompt is generated, it can read completion_notes from its
-completed dependencies to understand what was built/changed.
-
-Usage:
-    python3 patch-completion-notes.py \
-        --feature-list .prizmkit/plans/feature-list.json \
-        --feature-id F-001 \
-        --summary .prizmkit/specs/001-my-feature/completion-summary.json
-
-    python3 patch-completion-notes.py \
-        --refactor-list .prizmkit/plans/refactor-list.json \
-        --refactor-id R-001 \
-        --summary <path-to-summary>
-"""
-
-import argparse
-import json
-import os
-import sys
-
-from utils import load_json_file, write_json_file, setup_logging
-
-LOGGER = setup_logging("patch-completion-notes")
-
-
-def parse_args():
-    parser = argparse.ArgumentParser(
-        description="Patch completion_notes into a task list from completion-summary.json."
-    )
-    parser.add_argument(
-        "--feature-list",
-        default=None,
-        help="Path to .prizmkit/plans/feature-list.json",
-    )
-    parser.add_argument(
-        "--refactor-list",
-        default=None,
-        help="Path to .prizmkit/plans/refactor-list.json",
-    )
-    parser.add_argument(
-        "--bug-list",
-        default=None,
-        help="Path to .prizmkit/plans/bug-fix-list.json",
-    )
-    parser.add_argument(
-        "--feature-id",
-        default=None,
-        help="Feature ID to patch (e.g. F-001)",
-    )
-    parser.add_argument(
-        "--refactor-id",
-        default=None,
-        help="Refactor ID to patch (e.g. R-001)",
-    )
-    parser.add_argument(
-        "--bug-id",
-        default=None,
-        help="Bug ID to patch (e.g. B-001)",
-    )
-    parser.add_argument(
-        "--summary",
-        required=True,
-        help="Path to completion-summary.json file",
-    )
-    return parser.parse_args()
-
-
-def read_completion_notes(summary_path):
-    """Read completion_notes from a completion-summary.json file.
-
-    Returns a list of strings, or an empty list if the file is missing
-    or malformed.
-    """
-    if not os.path.isfile(summary_path):
-        LOGGER.warning("Summary file not found: %s", summary_path)
-        return []
-
-    data, err = load_json_file(summary_path)
-    if err:
-        LOGGER.warning("Failed to read summary: %s", err)
-        return []
-
-    notes = data.get("completion_notes", [])
-    if not isinstance(notes, list):
-        LOGGER.warning("completion_notes is not a list in %s", summary_path)
-        return []
-
-    # Filter: only keep non-empty strings
-    return [n for n in notes if isinstance(n, str) and n.strip()]
-
-
-def patch_list(list_path, item_id, item_key, notes):
-    """Patch completion_notes into a task list JSON file.
-
-    Args:
-        list_path: Path to the JSON list file
-        item_id: ID of the item to patch (e.g. "F-001" or "R-001")
-        item_key: Key for the items array (e.g. "features" or "refactors")
-        notes: List of completion note strings
-    """
-    data, err = load_json_file(list_path)
-    if err:
-        LOGGER.error("Failed to read list: %s", err)
-        return False
-
-    items = data.get(item_key, [])
-    found = False
-    for item in items:
-        if isinstance(item, dict) and item.get("id") == item_id:
-            item["completion_notes"] = notes
-            found = True
-            break
-
-    if not found:
-        LOGGER.error("Item %s not found in %s", item_id, list_path)
-        return False
-
-    err = write_json_file(list_path, data)
-    if err:
-        LOGGER.error("Failed to write list: %s", err)
-        return False
-
-    LOGGER.info(
-        "Patched %d completion notes for %s in %s",
-        len(notes), item_id, list_path,
-    )
-    return True
-
-
-def main():
-    args = parse_args()
-
-    # Determine mode: feature, refactor, or bug
-    if args.feature_list and args.feature_id:
-        list_path = args.feature_list
-        item_id = args.feature_id
-        item_key = "features"
-    elif args.refactor_list and args.refactor_id:
-        list_path = args.refactor_list
-        item_id = args.refactor_id
-        item_key = "refactors"
-    elif args.bug_list and args.bug_id:
-        list_path = args.bug_list
-        item_id = args.bug_id
-        item_key = "bugs"
-    else:
-        print(
-            "Error: must provide either (--feature-list + --feature-id) "
-            "or (--refactor-list + --refactor-id) "
-            "or (--bug-list + --bug-id)",
-            file=sys.stderr,
-        )
-        sys.exit(1)
-
-    # Read completion notes
-    notes = read_completion_notes(args.summary)
-    if not notes:
-        LOGGER.info("No completion notes to patch for %s", item_id)
-        sys.exit(0)
-
-    # Patch the list
-    if not patch_list(list_path, item_id, item_key, notes):
-        sys.exit(1)
-
-    # Output result
-    result = {
-        "item_id": item_id,
-        "notes_count": len(notes),
-        "list_path": os.path.abspath(list_path),
-    }
-    print(json.dumps(result, indent=2, ensure_ascii=False))
-
-
-if __name__ == "__main__":
-    try:
-        main()
-    except KeyboardInterrupt:
-        sys.exit(130)
-    except SystemExit:
-        raise
-    except Exception as exc:
-        LOGGER.exception("Unhandled exception")
-        print("Error: {}".format(exc), file=sys.stderr)
-        sys.exit(1)

package/bundled/dev-pipeline-windows/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())