@remixmate/cli 0.9.49 → 0.9.51

package/skills/template-registry/scripts/template_paths.py

@@ -1,72 +0,0 @@
-"""Centralized monorepo path resolution for template-library artifacts.
-
-Why this module exists
-----------------------
-Before this file landed, every caller that needed to reach into the
-monorepo's ``template-library/`` from inside ``apps/ab-skill/`` had to count
-``..`` segments by hand. The depth differs per call site:
-
-    skills/template-registry/scripts/registry_loader.py    → 5 × ".."
-    skills/template-registry/scripts/check_contracts.py    → 3 × ".."
-    skills/template-registry/video_dsl/runtime/template_binder → 6 × ".."
-    skills/gen-script/scripts/gen_script.py                → 5 × ".."
-    skills/render-video/scripts/render_video.py            → 4 × ".."
-
-Five copies, five chances for an off-by-one bug, and any future directory
-move silently breaks one site without touching the others. This module
-computes the monorepo root **once** from its own location and exposes
-helpers so callers no longer count.
-
-All sibling skills (including the ``list_templates.py`` CLI entry, via
-``registry_loader``) go through these helpers, so the monorepo-root
-computation lives in exactly one place.
-"""
-from __future__ import annotations
-
-import os
-from typing import Optional
-
-__all__ = ["monorepo_root", "monorepo_registry_path", "monorepo_template_src_dir"]
-
-# This file lives at:
-#   <repo>/apps/ab-skill/skills/template-registry/scripts/template_paths.py
-# So the monorepo root is 5 levels up.
-_HERE = os.path.dirname(os.path.abspath(__file__))
-_REPO_ROOT = os.path.normpath(os.path.join(_HERE, "..", "..", "..", "..", ".."))
-
-
-def monorepo_root() -> str:
-    """Absolute path to the ab-platform monorepo root.
-
-    Always returns a string; the caller is responsible for checking
-    ``os.path.isdir(...)`` if the root may genuinely be absent (e.g. when
-    the skill is consumed standalone via the npm package).
-    """
-    return _REPO_ROOT
-
-
-def monorepo_registry_path() -> str:
-    """Path to ``template-library/packages/metadata/registry.json``.
-
-    Always returns the computed path even when the file does not exist —
-    so callers can keep their existing ``os.path.exists(...)`` / try-load
-    branches unchanged. Mirrors the historical behavior of the 4 in-tree
-    helpers it replaces.
-    """
-    return os.path.join(_REPO_ROOT, "template-library", "packages", "metadata", "registry.json")
-
-
-def monorepo_template_src_dir(template_id: str) -> Optional[str]:
-    """Locate a template's source directory under ``template-library``.
-
-    Returns the absolute path **only when the directory exists**; returns
-    ``None`` for the standalone / npm-consumer case where there is no
-    monorepo to reach into. Matches ``gen_script._locate_template_dir``'s
-    historical contract (callers test the result for None).
-    """
-    if not template_id:
-        return None
-    tpl_dir = os.path.join(
-        _REPO_ROOT, "template-library", "packages", "templates", "src", template_id
-    )
-    return tpl_dir if os.path.isdir(tpl_dir) else None

package/skills/template-registry/scripts/verify_props_contract.py

@@ -1,273 +0,0 @@
-#!/usr/bin/env python3
-"""
-脆弱点 6②：propExtractors / requiredProps ↔ 组件实际消费 props 的**双向对账**。
-
-不同于纯静态「consumed - providable」对账（噪声过大：分不清可选/必填、textLayers
-派生、同名变量污染），本校验用**三个无误报的稳健信号**做对账，且复用 render-video
-的真实 `build_binding`（而非重写绑定逻辑），保证与运行时一致：
-
-  A. requiredProps ⊆ produced
-     用真实 dsl-example.json 跑 build_binding，断言每个 slot 声明的 requiredProps
-     都真的进了 props。缺失 = 渲染前会回退通用布局（脆弱点 2 的 slideId 事故类）。
-     —— ERROR
-
-  B. requiredProps ⊆ typeFields
-     slot 声明 required 的 prop，组件 props 类型（entry.props as <T>，<T> 定义在
-     types.ts）里必须有该字段；否则 = 契约自相矛盾（声明必填却无处接收）。
-     —— ERROR
-
-  C. propExtractors keys ⊆ typeFields
-     提取器产出的每个 prop，目标组件类型必须声明；否则 = 死字段 / 漂移（提取器辛苦
-     算出来却没人读，或类型重命名后提取器没跟）。
-     —— WARN
-
-为什么这三个无误报：它们只用「类型声明（含 ?可选信息）」+「requiredProps 显式契约」
-+「真实绑定产出」，完全不猜组件源码里的 `props.x` 成员访问（那才是噪声源，且 tsc
-已覆盖「读了类型里没有的字段」）。
-
-与 test-template-pipeline.py 的分工：后者通过 ab-api registry 跑 build_binding，已
-覆盖 A（missingRequiredProps），但**离线 CI 跑不了**（registry_loader 需 ab-api）；
-本模块直接从磁盘读 template.json + types.ts，**无需 ab-api**，且额外提供类型级的
-B/C 对账（别处都没有）。由 scripts/test-props-contract.py 作为 CI 入口驱动。
-
-库接口：
-  verify_template(template_dir) -> {name, errors[], warnings[], info{}}
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import re
-import sys
-
-# 复用真实绑定逻辑（同目录 sibling 模块）。registry_loader 无 import 期副作用，
-# 不触发 ab-api，故可安全 import。
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from match_template import build_binding  # noqa: E402
-
-
-CAST_RE = re.compile(r"entry\.props\s+as\s+([A-Za-z_$][\w$]*)")
-
-
-def parse_interface_fields(types_src: str) -> dict:
-    """从 types.ts 解析 `export interface Name { ... }` → {Name: {field: optional_bool}}.
-
-    只解析顶层 interface 的顶层成员（足够覆盖模板 props 类型——它们都是扁平接口）。
-    嵌套对象类型按整体跳过（不影响顶层字段名收集）。
-    """
-    result: dict = {}
-    i = 0
-    n = len(types_src)
-    iface_re = re.compile(r"export\s+interface\s+([A-Za-z_$][\w$]*)\s*\{")
-    for m in iface_re.finditer(types_src):
-        name = m.group(1)
-        # 从 `{` 起做花括号配平，截取 body
-        start = m.end() - 1
-        depth = 0
-        j = start
-        while j < n:
-            c = types_src[j]
-            if c == "{":
-                depth += 1
-            elif c == "}":
-                depth -= 1
-                if depth == 0:
-                    break
-            j += 1
-        body = types_src[start + 1 : j]
-        result[name] = _parse_members(body)
-    return result
-
-
-def _parse_members(body: str) -> dict:
-    """解析接口 body 顶层成员名 + 是否可选。嵌套 { } 整体跳过。"""
-    fields: dict = {}
-    i = 0
-    n = len(body)
-    # 移除注释，避免把注释里的标识符当成员
-    body = re.sub(r"/\*.*?\*/", "", body, flags=re.S)
-    body = re.sub(r"//[^\n]*", "", body)
-    n = len(body)
-    # 按顶层切分：在 depth==0 处遇到 `;` 或 `\n` 视为成员边界
-    member_re = re.compile(r"([A-Za-z_$][\w$]*)\s*(\??)\s*:")
-    depth = 0
-    seg_start = 0
-    segments = []
-    for k, c in enumerate(body):
-        if c in "{([":
-            depth += 1
-        elif c in "})]":
-            depth -= 1
-        elif c in ";\n" and depth == 0:
-            segments.append(body[seg_start:k])
-            seg_start = k + 1
-    segments.append(body[seg_start:])
-    for seg in segments:
-        seg = seg.strip()
-        if not seg:
-            continue
-        mm = member_re.match(seg)
-        if mm:
-            fields[mm.group(1)] = mm.group(2) == "?"
-    return fields
-
-
-def resolve_slot_def(slot_mapping: dict, purpose: str) -> dict:
-    slot_def = slot_mapping.get(purpose) or slot_mapping.get("default") or {}
-    visited = set()
-    while isinstance(slot_def, dict) and "$ref" in slot_def:
-        ref = slot_def["$ref"]
-        if ref in visited:
-            break
-        visited.add(ref)
-        slot_def = slot_mapping.get(ref) or {}
-    return slot_def
-
-
-def verify_template(tdir: str) -> dict:
-    """对单个模板目录做 A/B/C 对账，返回 {errors:[], warnings:[], info:{}}。"""
-    name = os.path.basename(tdir.rstrip("/"))
-    errors: list = []
-    warnings: list = []
-    info: dict = {}
-
-    tpl_path = os.path.join(tdir, "template.json")
-    with open(tpl_path, "r", encoding="utf-8") as f:
-        tpl = json.load(f)
-
-    slot_mapping = tpl.get("slotMapping", {}) or {}
-    compositions = tpl.get("compositions", []) or []
-
-    # compositionId → componentFile
-    comp_file = {c.get("compositionId"): c.get("componentFile") for c in compositions}
-
-    # componentFile → cast 类型名（entry.props as <T>）
-    file_cast: dict = {}
-    for cf in set(comp_file.values()):
-        if not cf:
-            continue
-        src_path = os.path.normpath(os.path.join(tdir, cf))
-        if not os.path.exists(src_path):
-            warnings.append(f"组件文件不存在：{cf}")
-            continue
-        with open(src_path, "r", encoding="utf-8") as f:
-            src = f.read()
-        casts = CAST_RE.findall(src)
-        file_cast[cf] = casts[0] if casts else None
-        if not casts:
-            warnings.append(f"{cf} 未找到 `entry.props as <Type>`，跳过类型对账")
-
-    # 收集 types.ts（含同目录所有 .ts 里的 interface，稳妥起见全扫）
-    type_fields: dict = {}
-    for root, _dirs, files in os.walk(tdir):
-        for fn in files:
-            if fn.endswith(".ts") and not fn.endswith(".d.ts"):
-                try:
-                    with open(os.path.join(root, fn), "r", encoding="utf-8") as f:
-                        type_fields.update(parse_interface_fields(f.read()))
-                except Exception:
-                    pass
-
-    # compositionId → 类型字段集合
-    def fields_for_comp(comp_id: str):
-        cf = comp_file.get(comp_id)
-        cast = file_cast.get(cf)
-        if cast and cast in type_fields:
-            return set(type_fields[cast].keys()), cast
-        return None, cast
-
-    # ---- B & C：基于 slot 声明（不依赖 dsl-example）----
-    seen_slots = set()
-    for purpose in list(slot_mapping.keys()):
-        sd = resolve_slot_def(slot_mapping, purpose)
-        comp_id = sd.get("compositionId")
-        if not comp_id or comp_id in seen_slots:
-            continue
-        seen_slots.add(comp_id)
-        tfields, cast = fields_for_comp(comp_id)
-        required = sd.get("requiredProps") or []
-        extractor_keys = list((sd.get("propExtractors") or {}).keys())
-
-        if tfields is None:
-            if required or extractor_keys:
-                warnings.append(
-                    f"slot→{comp_id}: 无法解析组件 props 类型({cast})，B/C 跳过"
-                )
-            continue
-
-        # B: requiredProps ⊆ typeFields
-        for rp in required:
-            if rp not in tfields:
-                errors.append(
-                    f"[B] slot→{comp_id}: requiredProps 含 '{rp}'，但组件类型 {cast} 未声明该字段"
-                )
-        # C: propExtractors keys ⊆ typeFields
-        for ek in extractor_keys:
-            if ek not in tfields:
-                warnings.append(
-                    f"[C] slot→{comp_id}: propExtractors 产出 '{ek}'，但组件类型 {cast} 未声明 → 死字段/漂移"
-                )
-
-    # ---- A：用真实 dsl-example 跑 build_binding，requiredProps ⊆ produced ----
-    ex_path = os.path.join(tdir, "dsl-example.json")
-    if os.path.exists(ex_path):
-        with open(ex_path, "r", encoding="utf-8") as f:
-            dsl = json.load(f)
-        binding = build_binding(tpl, dsl)
-        miss_rows = [b for b in binding.get("bindings", []) if b.get("missingRequiredProps")]
-        for b in miss_rows:
-            errors.append(
-                f"[A] scene={b['sceneId']} slot={b['slotId']}: "
-                f"requiredProps 缺失 {b['missingRequiredProps']}（dsl-example 跑真实绑定后仍未产出）"
-            )
-        info["scenes_bound"] = len(binding.get("bindings", []))
-    else:
-        warnings.append("缺 dsl-example.json，A（运行时绑定对账）跳过")
-
-    return {"name": name, "errors": errors, "warnings": warnings, "info": info}
-
-
-def verify_all(base: str) -> int:
-    """对 base/*/template.json 逐个对账，打印报告，返回 error 总数。"""
-    dirs = sorted(
-        os.path.join(base, d)
-        for d in os.listdir(base)
-        if os.path.isdir(os.path.join(base, d))
-        and os.path.exists(os.path.join(base, d, "template.json"))
-    )
-    if not dirs:
-        print(f"未发现模板（{base}/*/template.json）", file=sys.stderr)
-        return 0
-
-    total_err = 0
-    total_warn = 0
-    for tdir in dirs:
-        r = verify_template(tdir)
-        status = "FAIL" if r["errors"] else ("WARN" if r["warnings"] else "PASS")
-        scenes = r["info"].get("scenes_bound", "-")
-        print(f"\n=== {r['name']}  [{status}]  (scenes_bound={scenes}) ===")
-        for e in r["errors"]:
-            print(f"  ERROR {e}")
-        for w in r["warnings"]:
-            print(f"  WARN  {w}")
-        if not r["errors"] and not r["warnings"]:
-            print("  ✓ A/B/C 全部通过")
-        total_err += len(r["errors"])
-        total_warn += len(r["warnings"])
-
-    print(f"\n—— 汇总：{len(dirs)} 模板，{total_err} error，{total_warn} warning ——")
-    return total_err
-
-
-if __name__ == "__main__":
-    import argparse
-
-    ap = argparse.ArgumentParser(description="脆弱点 6② props 双向对账（A/B/C）")
-    ap.add_argument("--templates-dir", required=True, help="template-library/packages/templates/src")
-    args = ap.parse_args()
-    base = os.path.abspath(args.templates_dir)
-    if not os.path.isdir(base):
-        print(f"templates-dir 不存在: {base}", file=sys.stderr)
-        raise SystemExit(2)
-    raise SystemExit(1 if verify_all(base) else 0)

package/skills/template-registry/video_dsl/runtime/template_binder.py

@@ -1,87 +0,0 @@
-"""
-模板 registry 摘要导出器 - 把 ``@ab-templates/metadata`` 的 registry.json
-浓缩为 LLM prompt / 离线脚本使用的精简版本并写盘。
-
-历史：本模块之前还托管了 ``bind_template`` / ``load_template`` / ``extract_props``
-等 DSL→TemplateBinding 接口；那条路径已被 ``scripts/match_template.py`` 接管
-(由 render-video 直接 import)，留在这里的副本无任何外部调用方且与
-match_template 的算法已经漂移。删除这些死接口后，本文件只保留 ``sync_registry``
-所需的最小依赖链 (``_load_registry`` → ``load_all_templates`` → ``build_registry``)。
-
-monorepo 路径解析统一走 ``scripts/template_paths``，避免本文件再自己数 ``..``。
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import sys
-from typing import Optional
-
-# template_paths 住在 ../../scripts/，把它挂上 sys.path 后才能 import。
-_SCRIPTS_DIR = os.path.abspath(
-    os.path.join(os.path.dirname(__file__), "..", "..", "scripts")
-)
-if _SCRIPTS_DIR not in sys.path:
-    sys.path.insert(0, _SCRIPTS_DIR)
-
-from template_paths import monorepo_registry_path  # noqa: E402
-
-_registry_cache: Optional[dict] = None
-
-
-def _load_registry(registry_path: Optional[str] = None) -> dict:
-    """Load and cache the template registry from ``@ab-templates/metadata``.
-
-    File-only: this helper never goes to HTTP (that's ``registry_loader`` 的
-    职责)；``sync_registry`` 的输出只是给 LLM prompt 用，对一致性要求弱，所以
-    本地读盘即可。
-    """
-    global _registry_cache
-    if _registry_cache is not None:
-        return _registry_cache
-
-    path = registry_path or monorepo_registry_path()
-    if not os.path.isfile(path):
-        return {"templates": []}
-
-    with open(path, "r", encoding="utf-8") as f:
-        _registry_cache = json.load(f)
-    return _registry_cache
-
-
-def load_all_templates(registry_path: Optional[str] = None) -> list[dict]:
-    """Return every template definition from the metadata registry."""
-    registry = _load_registry(registry_path)
-    return registry.get("templates", [])
-
-
-def build_registry(registry_path: Optional[str] = None) -> dict:
-    """Return the registry in the legacy summary format (for LLM prompts etc.)."""
-    templates = load_all_templates(registry_path)
-    matching_fields = [
-        "templateId", "name", "description", "supportedAspectRatios",
-        "supportedDurations", "styleTags", "scenePatterns", "assetRequirements",
-    ]
-    summary = []
-    for tpl in templates:
-        summary.append({k: tpl[k] for k in matching_fields if k in tpl})
-    return {
-        "version": "v1alpha1",
-        "description": "视频模板注册表 - 来自 @ab-templates/metadata",
-        "templates": summary,
-    }
-
-
-def sync_registry(output_path: Optional[str] = None, registry_path: Optional[str] = None) -> str:
-    """Write a local registry-cache.json from ``@ab-templates/metadata``.
-
-    Returns the absolute path of the written file.
-    """
-    registry = build_registry(registry_path)
-    out = output_path or os.path.join(os.path.dirname(__file__), "..", "registry-cache.json")
-    out = os.path.abspath(out)
-    with open(out, "w", encoding="utf-8") as f:
-        json.dump(registry, f, ensure_ascii=False, indent=2)
-        f.write("\n")
-    return out