motionloom 2.0.0 → 2.2.0

package/scripts/eval-projects.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+"""Evaluate MotionLoom's project-aware analyzer against a labeled project corpus.
+
+The manifest records provenance and expected signals, but this runner never
+clones, installs or executes code from external projects. A checkout is only
+considered available when the caller explicitly places it under --workspace.
+Missing external projects produce ``insufficient_evidence`` rather than a
+false pass. This keeps product-value claims separate from owned fixtures.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_MANIFEST = ROOT / "tests/evals/project-corpus.json"
+ANALYZER = ROOT / "scripts/analyze.py"
+
+
+def invoke(project: Path, output: Path, args: argparse.Namespace) -> subprocess.CompletedProcess[str]:
+    command = [
+        sys.executable,
+        str(ANALYZER),
+        str(project),
+        "--output",
+        str(output),
+        "--max-files",
+        str(args.max_files),
+        "--max-bytes",
+        str(args.max_bytes),
+        "--max-seconds",
+        str(args.max_seconds),
+    ]
+    for value in args.ignore_dir:
+        command.extend(["--ignore-dir", value])
+    for value in args.ignore_glob:
+        command.extend(["--ignore-glob", value])
+    return subprocess.run(command, cwd=ROOT, capture_output=True, text=True)
+
+
+def evaluate_case(case: dict, workspace: Path, repository_root: Path, args: argparse.Namespace, temp: Path) -> dict:
+    relative = Path(str(case["local_path"]))
+    base = repository_root if case.get("scope") == "repository" else workspace
+    project = (base / relative).resolve()
+    try:
+        project.relative_to(base.resolve())
+    except ValueError:
+        return {"id": case["id"], "class": case.get("class"), "status": "fail", "detail": "local_path escapes evaluation root"}
+    if not project.is_dir():
+        return {
+            "id": case["id"],
+            "class": case.get("class"),
+            "status": "unavailable",
+            "external": bool(case.get("external")),
+            "source": case.get("source"),
+            "detail": f"checkout not present at {relative.as_posix()}",
+        }
+
+    output = temp / f"{case['id']}.json"
+    result = invoke(project, output, args)
+    if result.returncode != 0 or not output.is_file():
+        return {
+            "id": case["id"],
+            "class": case.get("class"),
+            "status": "fail",
+            "external": bool(case.get("external")),
+            "source": case.get("source"),
+            "detail": (result.stdout + result.stderr).strip()[-1000:],
+        }
+
+    context = json.loads(output.read_text(encoding="utf-8"))
+    expected = case.get("expected", {})
+    checks = []
+    if expected.get("name") is not None:
+        checks.append((context.get("name") == expected["name"], f"name={context.get('name')!r}"))
+    if expected.get("framework") is not None:
+        actual = context.get("stack", {}).get("framework")
+        checks.append((actual == expected["framework"], f"framework={actual!r}"))
+    if expected.get("scan_truncated") is not None:
+        checks.append((context.get("scan_truncated") is expected["scan_truncated"], f"scan_truncated={context.get('scan_truncated')!r}"))
+    passed = all(item[0] for item in checks)
+    return {
+        "id": case["id"],
+        "class": case.get("class"),
+        "status": "pass" if passed else "fail",
+        "external": bool(case.get("external")),
+        "source": case.get("source"),
+        "checks": [detail for _, detail in checks],
+        "scan": context.get("scan", {}),
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Run a provenance-labeled MotionLoom project corpus evaluation.")
+    parser.add_argument("--manifest", default=str(DEFAULT_MANIFEST))
+    parser.add_argument("--workspace", default=str(ROOT), help="Explicit directory containing corpus checkouts")
+    parser.add_argument("--repository-root", default=str(ROOT), help="First-party repository root")
+    parser.add_argument("--output")
+    parser.add_argument("--require-external", type=int, help="Override manifest external-project requirement")
+    parser.add_argument("--allow-insufficient", action="store_true", help="Return success while reporting insufficient_evidence")
+    parser.add_argument("--max-files", type=int, default=2500)
+    parser.add_argument("--max-bytes", type=int, default=25_000_000)
+    parser.add_argument("--max-seconds", type=float, default=10.0)
+    parser.add_argument("--ignore-dir", action="append", default=[])
+    parser.add_argument("--ignore-glob", action="append", default=[])
+    args = parser.parse_args()
+
+    manifest_path = Path(args.manifest).expanduser().resolve()
+    workspace = Path(args.workspace).expanduser().resolve()
+    repository_root = Path(args.repository_root).expanduser().resolve()
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    cases = manifest.get("projects", [])
+    required_external = args.require_external if args.require_external is not None else int(manifest.get("required_external_projects", 0))
+
+    with tempfile.TemporaryDirectory(prefix="motionloom-project-eval-") as td:
+        results = [evaluate_case(case, workspace, repository_root, args, Path(td)) for case in cases]
+    available_external = sum(1 for item in results if item.get("external") and item.get("status") == "pass")
+    failed = [item for item in results if item["status"] == "fail"]
+    unavailable_external = [item for item in results if item.get("external") and item["status"] == "unavailable"]
+    if failed:
+        status = "fail"
+    elif available_external < required_external:
+        status = "insufficient_evidence"
+    else:
+        status = "pass"
+
+    report = {
+        "schema_version": "1.0",
+        "corpus_id": manifest.get("corpus_id"),
+        "status": status,
+        "workspace": str(workspace),
+        "required_external_projects": required_external,
+        "available_external_projects": available_external,
+        "unavailable_external_projects": len(unavailable_external),
+        "project_count": len(results),
+        "results": results,
+    }
+    payload = json.dumps(report, indent=2, ensure_ascii=False) + "\n"
+    if args.output:
+        output = Path(args.output).expanduser().resolve()
+        output.parent.mkdir(parents=True, exist_ok=True)
+        output.write_text(payload, encoding="utf-8")
+    print(payload, end="")
+    if status == "insufficient_evidence" and args.allow_insufficient:
+        return 0
+    return 0 if status == "pass" else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/intelligence.py

@@ -824,11 +824,54 @@ def semantic_lint_validate_data(report: dict[str, Any]) -> list[str]:
         issues.append("schema_version must be 0.1")
     if report.get("status") not in {"pass", "warn", "fail"}:
         issues.append("status must be pass, warn or fail")
-    summary = report.get("summary") or {}
-    findings = report.get("findings") or []
+    for field in ("report_id", "task_id", "scene"):
+        if not isinstance(report.get(field), str) or not report.get(field).strip():
+            issues.append(f"{field} must be a non-empty string")
+    ruleset = report.get("ruleset")
+    if not isinstance(ruleset, dict) or not isinstance(ruleset.get("id"), str) or not ruleset.get("id").strip() or not isinstance(ruleset.get("version"), str) or not ruleset.get("version").strip():
+        issues.append("ruleset must contain non-empty id and version")
+    summary = report.get("summary") if isinstance(report.get("summary"), dict) else {}
+    summary_required = {"total", "errors", "warnings", "infos", "blocking"}
+    issues.extend(f"summary missing {field}" for field in sorted(summary_required - set(summary)))
+    findings = report.get("findings") if isinstance(report.get("findings"), list) else []
+    if not isinstance(report.get("findings"), list):
+        issues.append("findings must be an array")
     if summary.get("total") != len(findings):
         issues.append("summary.total does not match findings length")
-    blocking = sum(bool(item.get("approval_blocking")) for item in findings if isinstance(item, dict))
+    finding_required = {"id", "rule_id", "category", "severity", "confidence", "basis", "message", "evidence_refs", "affected_paths", "approval_blocking"}
+    categories = {"intent", "timing", "easing", "accessibility", "performance", "continuity", "anti_pattern"}
+    severities = {"info", "warning", "error"}
+    bases = {"deterministic", "runtime", "human", "heuristic"}
+    severity_counts = {"info": 0, "warning": 0, "error": 0}
+    blocking = 0
+    for index, item in enumerate(findings):
+        if not isinstance(item, dict):
+            issues.append(f"finding[{index}] must be an object")
+            continue
+        issues.extend(f"finding[{index}] missing {field}" for field in sorted(finding_required - set(item)))
+        if item.get("severity") not in severities:
+            issues.append(f"finding[{index}] severity is invalid")
+        else:
+            severity_counts[item["severity"]] += 1
+        if item.get("category") not in categories:
+            issues.append(f"finding[{index}] category is invalid")
+        if item.get("basis") not in bases:
+            issues.append(f"finding[{index}] basis is invalid")
+        if not isinstance(item.get("confidence"), (int, float)) or not 0 <= item.get("confidence", -1) <= 1:
+            issues.append(f"finding[{index}] confidence must be between 0 and 1")
+        if not isinstance(item.get("evidence_refs"), list) or not isinstance(item.get("affected_paths"), list):
+            issues.append(f"finding[{index}] evidence_refs and affected_paths must be arrays")
+        if item.get("approval_blocking") is True:
+            blocking += 1
+    for field in ("total", "errors", "warnings", "infos", "blocking"):
+        if not isinstance(summary.get(field), int) or summary.get(field) < 0:
+            issues.append(f"summary.{field} must be a non-negative integer")
+    if summary.get("errors") != severity_counts["error"]:
+        issues.append("summary.errors does not match findings")
+    if summary.get("warnings") != severity_counts["warning"]:
+        issues.append("summary.warnings does not match findings")
+    if summary.get("infos") != severity_counts["info"]:
+        issues.append("summary.infos does not match findings")
     if summary.get("blocking") != blocking:
         issues.append("summary.blocking does not match findings")
     if report.get("status") == "fail" and blocking == 0:
@@ -1040,15 +1083,72 @@ def continuity_report_data(task_dirs: list[Path], project_id: str | None = None)
 
 def continuity_validate_data(report: dict[str, Any]) -> list[str]:
     issues: list[str] = []
+    required = {"schema_version", "report_id", "project_id", "status", "scenes", "transitions", "summary", "generated_at"}
+    issues.extend(f"missing {field}" for field in sorted(required - set(report)))
     if report.get("schema_version") != "0.1":
         issues.append("schema_version must be 0.1")
-    scenes = report.get("scenes") or []
-    transitions = report.get("transitions") or []
+    if report.get("status") not in {"pass", "warn", "fail"}:
+        issues.append("status must be pass, warn or fail")
+    for field in ("report_id", "project_id"):
+        if not isinstance(report.get(field), str) or not report.get(field).strip():
+            issues.append(f"{field} must be a non-empty string")
+    scenes = report.get("scenes") if isinstance(report.get("scenes"), list) else []
+    transitions = report.get("transitions") if isinstance(report.get("transitions"), list) else []
+    if not isinstance(report.get("scenes"), list):
+        issues.append("scenes must be an array")
+    if not isinstance(report.get("transitions"), list):
+        issues.append("transitions must be an array")
     if not scenes:
         issues.append("continuity report requires at least one scene")
     if len(transitions) != max(0, len(scenes) - 1):
         issues.append("transition count must equal scene count minus one")
-    if report.get("summary", {}).get("scene_count") != len(scenes):
+    scene_names = set()
+    for index, scene in enumerate(scenes):
+        if not isinstance(scene, dict):
+            issues.append(f"scene[{index}] must be an object")
+            continue
+        scene_required = {"scene", "order", "motion_ir_path", "motion_ir_sha256", "context_hash", "intent"}
+        issues.extend(f"scene[{index}] missing {field}" for field in sorted(scene_required - set(scene)))
+        name = scene.get("scene")
+        if not isinstance(name, str) or not name.strip():
+            issues.append(f"scene[{index}].scene must be a non-empty string")
+        elif name in scene_names:
+            issues.append(f"duplicate scene name: {name}")
+        else:
+            scene_names.add(name)
+        if not isinstance(scene.get("order"), int) or scene.get("order", -1) < 0:
+            issues.append(f"scene[{index}].order must be a non-negative integer")
+        for field in ("motion_ir_path", "intent"):
+            if not isinstance(scene.get(field), str) or not scene.get(field).strip():
+                issues.append(f"scene[{index}].{field} must be a non-empty string")
+        for field in ("motion_ir_sha256", "context_hash"):
+            value = scene.get(field)
+            if not isinstance(value, str) or len(value) != 64 or any(char not in "0123456789abcdef" for char in value):
+                issues.append(f"scene[{index}].{field} must be a lowercase SHA-256 digest")
+    for index, transition in enumerate(transitions):
+        if not isinstance(transition, dict):
+            issues.append(f"transition[{index}] must be an object")
+            continue
+        transition_required = {"id", "from_scene", "to_scene", "status", "checks"}
+        issues.extend(f"transition[{index}] missing {field}" for field in sorted(transition_required - set(transition)))
+        if transition.get("status") not in {"pass", "warn", "fail"}:
+            issues.append(f"transition[{index}].status is invalid")
+        if transition.get("from_scene") not in scene_names or transition.get("to_scene") not in scene_names:
+            issues.append(f"transition[{index}] references unknown scene")
+        if not isinstance(transition.get("checks"), list) or any(not isinstance(item, str) or not item.strip() for item in transition.get("checks", [])):
+            issues.append(f"transition[{index}].checks must be a non-empty-string array")
+    summary = report.get("summary") if isinstance(report.get("summary"), dict) else {}
+    summary_required = {"scene_count", "transition_count", "errors", "warnings", "blocking"}
+    issues.extend(f"summary missing {field}" for field in sorted(summary_required - set(summary)))
+    if report.get("summary") is not None and not isinstance(report.get("summary"), dict):
+        issues.append("summary must be an object")
+    for field in ("scene_count", "transition_count", "errors", "warnings", "blocking"):
+        minimum = 1 if field == "scene_count" else 0
+        if not isinstance(summary.get(field), int) or summary.get(field) < minimum:
+            issues.append(f"summary.{field} must be a valid non-negative count")
+    if summary.get("transition_count") != len(transitions):
+        issues.append("summary.transition_count does not match transitions")
+    if summary.get("scene_count") != len(scenes):
         issues.append("summary.scene_count does not match scenes")
     return issues
 

package/scripts/pr.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+"""
+MotionLoom confirm-to-PR entrypoint.
+
+Style contract: review-first and side-effect explicit. OPEN_PR defaults to 0;
+this module preserves the guarded shell workflow while using pathlib and
+subprocess argument arrays so it works on Ubuntu, macOS and Windows.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+
+SCENE_RE = re.compile(r"^[A-Za-z0-9._-]+$")
+
+
+def run(repo: Path, args: list[str], *, capture: bool = False) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        args,
+        cwd=repo,
+        check=True,
+        text=True,
+        capture_output=capture,
+    )
+
+
+def git_output(repo: Path, args: list[str]) -> str:
+    return run(repo, ["git", *args], capture=True).stdout.strip()
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Validate and commit a reviewed MotionLoom scene")
+    parser.add_argument("scene")
+    parser.add_argument("title", nargs="?", default=None)
+    parser.add_argument("--repo", default=None)
+    parser.add_argument("--context", default=None)
+    parser.add_argument("--task-dir", default=None)
+    parser.add_argument("--open-pr", action="store_true", help="Push and open a PR; default is local-only")
+    args = parser.parse_args()
+
+    if not SCENE_RE.fullmatch(args.scene) or args.scene in {".", ".."}:
+        parser.error("scene id contains unsafe branch/path characters")
+
+    repo = Path(args.repo).expanduser().resolve() if args.repo else Path(__file__).resolve().parents[1]
+    scene_dir = repo / "src" / "output" / args.scene
+    if not scene_dir.is_dir():
+        print(f"error: scene directory not found: {scene_dir}", file=sys.stderr)
+        return 1
+
+    try:
+        top_level = Path(git_output(repo, ["rev-parse", "--show-toplevel"])).resolve()
+    except (subprocess.CalledProcessError, FileNotFoundError) as exc:
+        print(f"error: repository is not a Git clone: {exc}", file=sys.stderr)
+        return 1
+    if top_level != repo:
+        print(f"error: --repo must be the Git repository root ({top_level})", file=sys.stderr)
+        return 1
+
+    if not args.task_dir:
+        print("error: --task-dir is required; user review must be persisted before PR", file=sys.stderr)
+        return 1
+    task_dir = Path(args.task_dir).expanduser()
+    if not task_dir.is_absolute():
+        task_dir = repo / task_dir
+    task_dir = task_dir.resolve()
+    try:
+        task_dir.relative_to(repo)
+    except ValueError:
+        print("error: task directory must be inside the repository", file=sys.stderr)
+        return 1
+
+    task_path = task_dir / "task.json"
+    try:
+        task_data = json.loads(task_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        print(f"error: cannot read task.json: {exc}", file=sys.stderr)
+        return 1
+    if task_data.get("scene") != args.scene:
+        print("error: task.json scene does not match requested scene", file=sys.stderr)
+        return 1
+
+    python = os.environ.get("MOTIONLOOM_PYTHON") or ("python" if os.name == "nt" else "python3")
+    quality_args = [
+        str(repo / "scripts" / "quality-gate.py"),
+        "--scene", args.scene,
+        "--context", args.context or str(repo / "project-context.json"),
+        "--task-dir", str(task_dir),
+        "--require-browser-review",
+        "--require-visual-truth",
+    ]
+    print("== running context-bound quality gate ==")
+    run(repo, [python, *quality_args])
+    run(repo, [python, str(repo / "scripts" / "review-hook.py"), "validate", "--task-dir", str(task_dir), "--require-approved"])
+    run(repo, [python, str(repo / "scripts" / "report.py"), "check", "--task-dir", str(task_dir)])
+
+    branch = f"fix/{args.scene}"
+    try:
+        run(repo, ["git", "checkout", "-b", branch])
+    except subprocess.CalledProcessError:
+        run(repo, ["git", "checkout", branch])
+
+    task_rel = task_dir.relative_to(repo)
+    run(repo, ["git", "add", str(Path("src") / "output" / args.scene), str(task_rel)])
+    staged = subprocess.run(["git", "diff", "--cached", "--quiet"], cwd=repo).returncode
+    if staged == 0:
+        print("error: no staged scene changes to commit", file=sys.stderr)
+        return 1
+
+    title = args.title or f"animation: scene '{args.scene}' (verified in Dev Lab)"
+    commit_message = (
+        f"feat(animation): scene '{args.scene}' — proven in Dev Lab\n\n"
+        f"- motion-spec signed (see src/output/{args.scene}/motion-spec.json)\n"
+        f"- snapshot frames: 0/50/100% in src/output/{args.scene}/snapshot/\n"
+        "- context-bound quality gate: passed\n"
+        f"- brand tokens bound from {args.context or 'project-context.json'}"
+    )
+    run(repo, ["git", "commit", "-m", commit_message])
+
+    if not args.open_pr and os.environ.get("OPEN_PR") != "1":
+        print(f"== committed to {branch} — OPEN_PR=0, push/open PR manually ==")
+        return 0
+
+    if shutil.which("gh") is None:
+        print(f"== committed to {branch} — install gh CLI to open the PR ==")
+        print(f"   git push origin {branch}")
+        return 0
+
+    run(repo, ["git", "push", "-u", "origin", branch])
+    body = (
+        f"## Scene: {args.scene}\n\n"
+        "Verified in the Dev Lab (checklist + snapshot diffs attached).\n"
+        "Framework, duration, easing, reduced-motion policy and theme tokens per the signed motion spec.\n\n"
+        "### Snapshots\n| 0% | 50% | 100% |\n|---|---|---|\n"
+        "| `snapshot/frame-00.png` | `snapshot/frame-50.png` | `snapshot/frame-100.png` |\n\n"
+        "Ready to review — comment fixes in the Dev Lab or approve to merge."
+    )
+    run(repo, ["gh", "pr", "create", "--title", title, "--body", body])
+    print(f"== PR opened for scene: {args.scene} ==")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/prepack-clean.mjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+/**
+ * Cross-platform npm prepack cleanup. Do not rely on find/rm so publishing
+ * from PowerShell, macOS and Linux produces the same tarball.
+ */
+import { readdir, lstat, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = join(fileURLToPath(new URL("..", import.meta.url)));
+const ignoredDirectories = new Set(["node_modules", ".git", ".venv", "venv"]);
+
+async function clean(directory) {
+  let entries = [];
+  try {
+    entries = await readdir(directory, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  await Promise.all(entries.map(async (entry) => {
+    const path = join(directory, entry.name);
+    if (entry.isDirectory()) {
+      if (ignoredDirectories.has(entry.name)) return;
+      if (entry.name === "__pycache__") {
+        await rm(path, { recursive: true, force: true });
+        return;
+      }
+      await clean(path);
+      return;
+    }
+    if (entry.isFile() && /\.(pyc|pyo)$/.test(entry.name)) {
+      await rm(path, { force: true });
+    }
+  }));
+}
+
+await clean(root);