hyper-animator-codex 0.8.1 → 0.8.3

package/skills/hyper-animator-codex/scripts/validate_hyperframes_html.py

@@ -4,27 +4,72 @@
 from __future__ import annotations
 
 import argparse
+import json
 import re
 import sys
+from html.parser import HTMLParser
 from pathlib import Path
 
 
-def has_attr(html: str, name: str) -> bool:
-    return re.search(rf"\b{name}\s*=\s*['\"]?[^'\"\s>]+", html, re.IGNORECASE) is not None
-
-
-def numeric_attr(html: str, name: str) -> float | None:
-    match = re.search(
-        rf"\b{name}\s*=\s*(?:['\"]([^'\"]+)['\"]|([^\s>]+))",
-        html,
-        re.IGNORECASE,
-    )
-    if not match:
-        return None
+MOTION_HELPERS = {
+    "slam-entrance": "slamEntrance",
+    "whip-transition": "whipTransition",
+    "crash-zoom": "crashZoom",
+    "push-stack-wipe": "pushStackWipe",
+    "dataviz-landscape-open": "datavizLandscapeOpen",
+    "panel-grid-reflow": "panelGridReflow",
+    "brand-resolve": "brandResolve",
+}
+
+
+class CompositionParser(HTMLParser):
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=True)
+        self.elements: list[tuple[str, dict[str, str | None]]] = []
+        self.scripts: list[str] = []
+        self.styles: list[str] = []
+        self.comments: list[str] = []
+        self._raw_tag: str | None = None
+        self._raw_text: list[str] = []
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        self.elements.append((tag.lower(), {name.lower(): value for name, value in attrs}))
+        if tag.lower() in ("script", "style"):
+            self._raw_tag = tag.lower()
+            self._raw_text = []
+
+    def handle_startendtag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        self.handle_starttag(tag, attrs)
+        self.handle_endtag(tag)
+
+    def handle_data(self, data: str) -> None:
+        if self._raw_tag:
+            self._raw_text.append(data)
+
+    def handle_endtag(self, tag: str) -> None:
+        if tag.lower() != self._raw_tag:
+            return
+        target = self.scripts if self._raw_tag == "script" else self.styles
+        target.append("".join(self._raw_text))
+        self._raw_tag = None
+        self._raw_text = []
+
+    def handle_comment(self, data: str) -> None:
+        self.comments.append(data)
+
+
+def parse_html(html: str) -> CompositionParser:
+    parser = CompositionParser()
+    parser.feed(html)
+    parser.close()
+    return parser
+
+
+def positive_number(value: str | None) -> bool:
     try:
-        return float(match.group(1) or match.group(2))
+        return value is not None and float(value) > 0
     except ValueError:
-        return None
+        return False
 
 
 def check_html(
@@ -32,70 +77,98 @@ def check_html(
     *,
     component: bool = False,
     preview_controls: bool = False,
+    shot_plan: dict | None = None,
 ) -> tuple[list[str], list[str]]:
     failures: list[str] = []
     warnings: list[str] = []
+    document = parse_html(html)
+    script = "\n".join(document.scripts)
+    style = "\n".join(document.styles)
+    composition_elements = [
+        attrs for _, attrs in document.elements if attrs.get("data-composition-id")
+    ]
 
     if not component:
+        composition = composition_elements[0] if composition_elements else {}
         for attr in ("data-width", "data-height", "data-duration", "data-composition-id"):
-            if not has_attr(html, attr):
+            if not composition.get(attr):
                 failures.append(f"missing {attr}")
         for attr in ("data-width", "data-height", "data-duration"):
-            if has_attr(html, attr):
-                value = numeric_attr(html, attr)
-                if value is None or value <= 0:
-                    failures.append(f"{attr} must be a positive number")
+            if attr in composition and not positive_number(composition.get(attr)):
+                failures.append(f"{attr} must be a positive number")
 
-    if "<!-- paste from " in html:
+    if any("paste from " in comment.lower() for comment in document.comments):
         failures.append("unresolved component paste placeholder")
 
     paused_timeline = re.search(
         r"gsap\s*\.\s*timeline\s*\(\s*\{[^}]*paused\s*:\s*true",
-        html,
+        script,
         re.IGNORECASE | re.DOTALL,
     )
     if not paused_timeline:
         failures.append("missing gsap.timeline({ paused: true })")
 
-    if "window.__timelines" not in html:
+    if "window.__timelines" not in script:
         failures.append("missing window.__timelines registration")
 
-    if re.search(r"\bDate\s*\.\s*now\s*\(", html):
+    if re.search(r"\bDate\s*\.\s*now\s*\(", script):
         failures.append("uses Date.now(); render progress must be timeline-driven")
 
-    if re.search(r"\bsetInterval\s*\(", html):
+    if re.search(r"\bsetInterval\s*\(", script):
         failures.append("uses setInterval(); primary render progress must be timeline-driven")
 
-    if re.search(r"\bMath\s*\.\s*random\s*\(", html):
+    if re.search(r"\bMath\s*\.\s*random\s*\(", script):
         failures.append("uses Math.random(); visual generation must use a fixed-seed deterministic PRNG")
 
-    if re.search(r"\brequestAnimationFrame\s*\(", html) and "fallback" not in html.lower():
+    if re.search(r"\brequestAnimationFrame\s*\(", script) and "fallback" not in script.lower():
         warnings.append("requestAnimationFrame found; ensure it is not the primary render clock and has render fallback")
 
-    if "<style" in html.lower() and "[data-composition-id" not in html:
+    if document.styles and "[data-composition-id" not in style:
         warnings.append("style block found without [data-composition-id] scoped selector")
 
-    if len(re.findall(r"data-duration\s*=\s*['\"]?(\d+(?:\.\d+)?)", html)) > 1:
+    if sum("data-duration" in attrs for _, attrs in document.elements) > 1:
         warnings.append("multiple data-duration values found; verify the intended render duration")
 
     if preview_controls:
-        if "data-hyper-preview-ui" not in html:
+        attrs = [attributes for _, attributes in document.elements]
+        if not any("data-hyper-preview-ui" in attributes for attributes in attrs):
             failures.append("missing preview controls: data-hyper-preview-ui")
-        if "data-hyper-preview-page" not in html:
+        if not any("data-hyper-preview-page" in attributes for attributes in attrs):
             failures.append("missing preview controls: page indicator")
-        if "data-hyper-preview-progress" not in html:
+        if not any("data-hyper-preview-progress" in attributes for attributes in attrs):
             failures.append("missing preview controls: progress input")
-        if not re.search(r"<input[^>]+type=[\"']range[\"']", html, re.IGNORECASE | re.DOTALL):
+        if not any(tag == "input" and attributes.get("type") == "range" for tag, attributes in document.elements):
             failures.append("missing preview controls: range input")
-        if "ArrowLeft" not in html or "ArrowRight" not in html:
+        if "ArrowLeft" not in script or "ArrowRight" not in script:
             failures.append("missing preview controls: left/right keyboard handlers")
-        if 'params.get("render") === "1"' not in html:
+        if 'params.get("render") === "1"' not in script:
             failures.append("missing preview controls: ?render=1 hidden-mode check")
-        if 'params.get("preview") === "0"' not in html:
+        if 'params.get("preview") === "0"' not in script:
             failures.append("missing preview controls: ?preview=0 hidden-mode check")
-        if 'dataset.renderMode === "video"' not in html:
+        if 'dataset.renderMode === "video"' not in script:
             failures.append("missing preview controls: data-render-mode video hidden-mode check")
 
+    if shot_plan is not None:
+        shot_elements = {
+            attrs.get("data-shot-id"): attrs
+            for _, attrs in document.elements
+            if attrs.get("data-shot-id")
+        }
+        for shot in shot_plan.get("shots", []):
+            shot_id = shot.get("id")
+            preset = shot.get("motion_contract", {}).get("motion_preset")
+            attrs = shot_elements.get(shot_id)
+            if attrs is None:
+                failures.append(f"missing data-shot-id element for shot: {shot_id}")
+                continue
+            if attrs.get("data-motion-preset") != preset:
+                failures.append(f"shot {shot_id} data-motion-preset must be {preset}")
+            helper = MOTION_HELPERS.get(preset)
+            if helper:
+                calls_only = re.sub(rf"\bfunction\s+{re.escape(helper)}\s*\(", "", script)
+                if not re.search(rf"\b{re.escape(helper)}\s*\(", calls_only):
+                    failures.append(f"shot {shot_id} must call motion-pack helper {helper}")
+
     return failures, warnings
 
 
@@ -112,6 +185,10 @@ def main() -> int:
         action="store_true",
         help="Require injected Hyper Animator preview controls",
     )
+    parser.add_argument(
+        "--shot-plan",
+        help="Cross-check data-shot-id and motion-pack usage against a shot-plan JSON file",
+    )
     args = parser.parse_args()
 
     path = Path(args.html_file)
@@ -120,10 +197,19 @@ def main() -> int:
         return 2
 
     html = path.read_text(encoding="utf-8")
+    shot_plan = None
+    if args.shot_plan:
+        try:
+            shot_plan = json.loads(Path(args.shot_plan).read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError) as error:
+            print(f"FAIL: cannot read shot plan: {error}", file=sys.stderr)
+            return 2
+
     failures, warnings = check_html(
         html,
         component=args.component,
         preview_controls=args.preview_controls,
+        shot_plan=shot_plan,
     )
 
     for warning in warnings:

package/skills/hyper-animator-codex/scripts/validate_shot_plan.mjs

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
+import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import validateSchema, { schemaSha256 } from "./shot_plan_schema_validator.mjs";
 
 const scriptDir = dirname(fileURLToPath(import.meta.url));
 const skillRoot = dirname(scriptDir);
@@ -67,6 +69,9 @@ function validateMotionContract(contract, label, shotcraftRefs, errors) {
   const expectedPresets = shotcraftRefs
     .map((reference) => SHOTCRAFT_MOTION_PRESETS.get(reference))
     .filter(Boolean);
+  if (new Set(expectedPresets).size > 1) {
+    errors.push(`${label}.shotcraft_refs require multiple motion presets; separate them into distinct shots`);
+  }
   if (expectedPresets.length > 0 && !expectedPresets.includes(contract.motion_preset)) {
     errors.push(`${label}.motion_contract.motion_preset must use ${expectedPresets.join(" or ")} for selected ShotCraft refs`);
   }
@@ -96,7 +101,7 @@ function validateShotPlan(plan, catalogs) {
   const errors = [];
 
   if (!isObject(plan)) return ["plan must be a JSON object"];
-  if (plan.schema_version !== "1.0.0") errors.push("schema_version must be 1.0.0");
+  if (plan.schema_version !== "1.1.0") errors.push("schema_version must be 1.1.0");
   if (!WORKFLOW_STAGES.has(plan.workflow_stage)) {
     errors.push("workflow_stage must be visual_draft, audio_integrated, or render_ready");
   }
@@ -132,13 +137,15 @@ function validateShotPlan(plan, catalogs) {
   if (!isObject(plan.model_routing)) {
     errors.push("model_routing must be an object");
   } else {
-    if (plan.model_routing.page_animation_authoring !== "gpt-5.6-sol") {
-      errors.push("model_routing.page_animation_authoring must be gpt-5.6-sol");
+    const authoring = plan.model_routing.page_animation_authoring;
+    const planning = plan.model_routing.planning_and_validation;
+    if (!isObject(authoring) || authoring.tier !== "high_quality" || !authoring.actual_model) {
+      errors.push("model_routing.page_animation_authoring must declare high_quality tier and actual_model");
     }
-    if (!plan.model_routing.planning_and_validation) {
-      errors.push("model_routing.planning_and_validation is required");
-    } else if (plan.model_routing.planning_and_validation === "gpt-5.6-sol") {
-      errors.push("model_routing.planning_and_validation must not use gpt-5.6-sol");
+    if (!isObject(planning) || planning.tier !== "fast" || !planning.actual_model) {
+      errors.push("model_routing.planning_and_validation must declare fast tier and actual_model");
+    } else if (authoring?.actual_model === planning.actual_model) {
+      errors.push("model_routing.planning_and_validation must use a different, fast model");
     }
   }
 
@@ -231,6 +238,14 @@ async function main() {
       return;
     }
     const plan = JSON.parse(await readFile(path, "utf8"));
+    const schemaText = await readFile(
+      join(skillRoot, "contracts", "shot-plan.schema.json"),
+      "utf8",
+    );
+    const actualSchemaSha256 = createHash("sha256").update(schemaText).digest("hex");
+    if (actualSchemaSha256 !== schemaSha256) {
+      throw new Error("shot-plan schema validator is stale; run npm run build:contracts");
+    }
     const hyperframesCatalog = JSON.parse(await readFile(
       join(skillRoot, "references", "hyperframes-catalog-map.json"),
       "utf8",
@@ -246,7 +261,12 @@ async function main() {
         ...card.styles.map((style) => style.key),
       ])),
     };
-    const errors = validateShotPlan(plan, catalogs);
+    const schemaErrors = validateSchema(plan)
+      ? []
+      : validateSchema.errors.map((error) => (
+        `${error.instancePath || "/"} ${error.message}${error.params?.additionalProperty ? `: ${error.params.additionalProperty}` : ""}`
+      ));
+    const errors = [...schemaErrors, ...validateShotPlan(plan, catalogs)];
     if (errors.length > 0) {
       output({ ok: false, path, errors }, 1);
       return;