@remixmate/cli 0.9.72 → 0.9.73

package/skills/render-video/scripts/required_props.py

@@ -1,9 +1,9 @@
-"""Validate template-required scene props before asset generation or rendering.
 
-Binding records missingRequiredProps for diagnostics, but a production caller
-must reject those scenes instead of paying for audio and rendering placeholders.
-Existing RenderPlans need the same check because they bypass binding entirely.
-"""
+
+
+
+
+
 
 from __future__ import annotations
 
@@ -11,14 +11,14 @@ import math
 import sys
 from pathlib import Path
 
-# Shared cross-skill lib (see AGENTS.md). Inserted here rather than relying on
-# render_video's module-top setup because this module is imported directly by
-# tests and by prepare-video-assets.
+
+
+
 sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "template-registry" / "scripts"))
 
-from countdown_spec import resolve_countdown_spec  # noqa: E402
+from countdown_spec import resolve_countdown_spec
 sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "template-registry"))
-from video_dsl.runtime.payload_contract import required_payload_errors  # noqa: E402
+from video_dsl.runtime.payload_contract import required_payload_errors
 
 
 def _payload_prop(props: dict, key: str):
@@ -35,11 +35,11 @@ def _payload_prop(props: dict, key: str):
 
 
 def _required_value_errors(value, schema: dict, path: str) -> list[str]:
-    """Check required values only, using the template's declared shape and bounds.
 
-    This is not a full JSON Schema validator: optional fields and undeclared
-    extensions are left to the existing DSL validators and template runtime.
-    """
+
+
+
+
     if value is None or (isinstance(value, str) and not value.strip()):
         return [path]
     kind = schema.get("type")
@@ -67,10 +67,10 @@ def _required_value_errors(value, schema: dict, path: str) -> list[str]:
 
 
 def validate_required_props(template: dict, rows: list[dict]) -> None:
-    """Raise with scene IDs and field names only; never include scene content."""
+
     required_by_composition: dict[str, set[str]] = {}
-    # References reuse a concrete slot's composition, so only concrete slots
-    # contribute requirements here. Union if multiple slots share a component.
+
+
     for slot in (template.get("slotMapping") or {}).values():
         if not isinstance(slot, dict) or not slot.get("compositionId"):
             continue
@@ -102,29 +102,29 @@ def validate_required_props(template: dict, rows: list[dict]) -> None:
 
 
 def _index_of(row: dict, spec: dict):
-    """A beat's countdown index, or None when the row carries no usable item.
-
-    Returning None rather than indexing straight into the payload keeps a scene
-    with a missing/malformed item on the countdown error path (which names the
-    scene and says what to fix) instead of an AttributeError from deep inside the
-    validator. Reachable whenever a countdown template's point slot does not list
-    its item prop in requiredProps, so the earlier per-scene check lets it through.
-    """
+
+
+
+
+
+
+
+
     item = _payload_prop(row.get("props") or {}, spec["item_prop"])
     return item.get(spec["index_prop"]) if isinstance(item, dict) else None
 
 
 def _validate_countdown(template: dict, rows: list[dict]) -> None:
-    """Check a countdown plan's shape before anything is paid for.
-
-    Every prop name here comes from the template's own `capabilities.countdown`
-    declaration, so this function holds no knowledge of ranking, GitHub, or any
-    template id. That matters beyond tidiness: the names used to be hardcoded,
-    which meant a second countdown template calling its count `itemCount` would
-    find no counts at all, fall back to "however many beats are present", and
-    reduce the scene-count check to comparing that number against itself —
-    validation silently gone, with nothing on screen or in the logs to say so.
-    """
+
+
+
+
+
+
+
+
+
+
     spec = resolve_countdown_spec(template)
     if spec is None:
         return
@@ -134,7 +134,7 @@ def _validate_countdown(template: dict, rows: list[dict]) -> None:
     ending_id = (slots.get("ending") or {}).get("compositionId")
     points = [row for row in rows if row.get("compositionId") == point_id]
     count_props = [spec["count_prop"], *spec["legacy_count_props"]]
-    # Keep old plans usable: infer their count when no explicit count was saved.
+
     declared = []
     for row in rows:
         props = row.get("props") or {}
@@ -163,7 +163,7 @@ def _validate_countdown(template: dict, rows: list[dict]) -> None:
         )
     if not rows or rows[0].get("compositionId") != opening_id or sum(row.get("compositionId") == opening_id for row in rows) != 1:
         raise ValueError("Countdown requires exactly one opening before the beats")
-    # A separate ending may hold the final beat, but cannot add another index.
+
     endings = [row for row in rows if row.get("compositionId") == ending_id]
     if len(endings) > 1 or (endings and (rows[-1] is not endings[0] or _index_of(endings[0], spec) != 1)):
         raise ValueError("Countdown ending may only hold the #1 scene after the countdown")

package/skills/render-video/scripts/upload_video.py

@@ -1,26 +1,26 @@
 #!/usr/bin/env python3
-"""
-视频上传工具 - 将本地 MP4 文件通过 multipart/form-data 上传到 ab-api，
-获取可用 URL（直传阿里云 OSS，同步返回）。
 
-默认行为:
-  读取本地文件，以 multipart/form-data 形式 POST 到
-  `<MM_API_BASE_URL>/file/uploadMediaFile`，解析响应 JSON，输出 fileUrl。
 
-用法:
-  python3 upload_video.py --file output/video.mp4 --role final_video
-  python3 upload_video.py --file output/video.mp4 --role final_video --title "我的视频"
-  python3 upload_video.py --file output/video.mp4 --role final_video --json-output
 
-环境变量 PRIV_TOKEN 必填（接口在 ab-api 私有组，产物落素材表并归到调用者名下）。
 
-环境变量:
-  MM_API_BASE_URL - API 根地址（默认 MM_API_BASE_URL 环境变量或 https://api-agent.remixmate.ai/api）
 
-注意:
-  - `uploadMediaFile` 接口视频大小限制 ≤ 50MB，音频 ≤ 15MB
-  - 进度信息输出到 stderr，最终 URL 输出到 stdout（最后一行）
-"""
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 import argparse
 import http.client
@@ -42,11 +42,11 @@ def _guess_content_type(file_path: str) -> str:
 
 
 def _build_multipart_body(file_path: str, fields: dict) -> (bytes, str):
-    """
-    手动构建 multipart/form-data body。fields 里值为空的字段不发。
 
-    返回 (body_bytes, content_type_header)。
-    """
+
+
+
+
     boundary = "----MediaMakerBoundary" + uuid.uuid4().hex
     crlf = b"\r\n"
     parts = []
@@ -59,7 +59,7 @@ def _build_multipart_body(file_path: str, fields: dict) -> (bytes, str):
         parts.append(b"")
         parts.append(str(value).encode("utf-8"))
 
-    # file 字段
+
     file_name = os.path.basename(file_path)
     content_type = _guess_content_type(file_path)
     with open(file_path, "rb") as f:
@@ -76,7 +76,7 @@ def _build_multipart_body(file_path: str, fields: dict) -> (bytes, str):
     parts.append(b"")
     parts.append(file_data)
 
-    # 结尾 boundary
+
     parts.append(("--" + boundary + "--").encode("utf-8"))
     parts.append(b"")
 
@@ -94,15 +94,15 @@ def upload_media_file(
     role: str,
     retention: str = None,
 ) -> dict:
-    """
-    将本地媒体文件以 multipart/form-data 形式上传到 ab-api，并落素材表。
 
-    role 必填：素材语义角色（final_video / dh_drive_audio / source_audio ...），由调用方
-    按「这是什么」声明——ab-api 不再按文件类型猜。retention 可选（intermediate / output / user）。
 
-    返回服务端 data 字段，形如 {"fileUrl": "https://...", "fileId": 123, "fileUid": "file_xxx"}。
-    上传失败会抛出异常。
-    """
+
+
+
+
+
+
+
     if not role:
         raise ValueError("upload_media_file: role is required")
     if not os.path.exists(file_path):
@@ -118,7 +118,7 @@ def upload_media_file(
     body, content_type = _build_multipart_body(
         file_path, {"title": title, "role": role, "retention": retention}
     )
-    # 该接口在 ab-api 私有组：产物要落素材表、归到调用者名下，必须带 PrivToken。
+
     headers = {
         "Content-Type": content_type,
         "Content-Length": str(len(body)),
@@ -129,8 +129,8 @@ def upload_media_file(
     if conversation_id:
         headers["x-conversation-id"] = conversation_id
 
-    # Use http.client directly to avoid urllib RemoteDisconnected issues
-    # with servers that return 'connection: close'
+
+
     parsed = urllib.parse.urlparse(url)
     host = parsed.hostname
     port = parsed.port
@@ -164,7 +164,7 @@ def upload_media_file(
     except json.JSONDecodeError as e:
         raise RuntimeError(f"failed to parse response: {resp_body}") from e
 
-    # ab-api shared response: { code: 0, data: {...}, msg: "..." }
+
     if isinstance(result, dict) and result.get("code") not in (0, 200):
         raise RuntimeError(f"server returned an error: code={result.get('code')}, msg={result.get('msg')}")
 
@@ -217,7 +217,7 @@ def main():
     if args.json_output:
         print(json.dumps(data, ensure_ascii=False))
     else:
-        # 最终 URL 输出到 stdout（最后一行），方便其他脚本捕获
+
         print(data["fileUrl"])
 
 

package/skills/render-video/version.json

@@ -2,6 +2,6 @@
   "skillName": "render-video",
   "repoName": "agent-skill-media-maker",
   "skillId": "473",
-  "version": "V36",
+  "version": "V37",
   "skillDescription": "Final-render skill: loads a persisted RenderPlan by `job_id` and drives the Remotion engine to produce the final video.\n\nUse this skill as soon as the user mentions any of these intents (after assets are already prepared):\n- Render the video, composite the video, export the video\n- Turn the prepared assets into the final clip\n- Render with Remotion\n\nPrerequisite: assets must already be generated via `prepare_video_assets`. This skill never resolves or regenerates assets — pass it a `job_id` from a previous `prepare_video_assets` call.\n\n⚠️ Stop-and-confirm gate: never call this skill until the user has explicitly confirmed the assets prepared by `prepare_video_assets`. If those assets were prepared in the current turn and the user has not replied since, stop and ask instead of rendering."
 }

package/skills/template-registry/SKILL.md

@@ -86,6 +86,19 @@ When the user asks to see / browse / pick templates, they decide by *watching* s
 - No sample info (older backend, or a template with no samples yet) is not an error: show the template without it.
 - The detail page's prompt is meant to be pasted back into this chat; treat it like any user request.
 
+### Recommend templates when the user named none
+
+A video request without a template is a template choice the user has not made yet — not one for the agent to make silently. Shortlist with the list verb's hard constraints — they read each template's declarations, so a template that cannot serve the request is dropped with a stated reason (JSON `excluded[{templateId, reasons}]`, or an `Excluded by the current filters` block in the table):
+
+```bash
+remixmate template-registry --json-output --filter-aspect 9:16 --filter-language zh \
+  --user-media yes        # the user handed over images/videos (no = they did not)
+  # --source-doc pptx     # the user gave a .pptx (none = drop templates that need one)
+  # --narration no        # the user wants no voice-over
+```
+
+Set only the constraints the request actually pins down; an unset one does not filter. Then rank what is left against `llmHint` / `description` / `styleTags`, and use `notFor` (a template's own list of requests it is the wrong pick for) to separate close siblings. Use coarse levels (recommended / also fits) and show 2–3 in the format above with a one-line reason each. Then end the turn and let the user pick; `gen_script` takes the answer as `--template-source user-confirmed` plus `--template-candidates`. The full rule is in the `gen-script` skill, "Agent behavior: template selection comes before the script".
+
 ### Build a binding locally (debug only, not part of the render pipeline)
 
 ```python
@@ -110,6 +123,9 @@ print(json.dumps(binding, ensure_ascii=False, indent=2))
 | `--filter-tag` | Keep only templates whose `styleTags` match this substring (case-insensitive). | none |
 | `--filter-aspect` | Keep only templates declaring this aspect ratio (e.g. `9:16`). | none |
 | `--filter-language` | Keep only templates whose `contentLanguage` includes this code (`zh`/`en`); language-agnostic templates always show. | none |
+| `--user-media yes\|no` | Shortlist by the template's media shape (`capabilities.payloadStyle`, else derived from `assetRequirements`): `yes` drops templates with no place for the user's own images/videos, `no` drops templates that need them. | none |
+| `--source-doc <kind>\|none` | Shortlist by `capabilities.payloadHydration.docKind`: a kind keeps only templates built from such a document; `none` drops them. | none |
+| `--narration yes\|no` | Shortlist by `capabilities.needsNarration` (default true). | none |
 | `--include-beta` | Also show `status: beta` templates (same effect as `ENABLE_BETA_TEMPLATES=1`). | off |
 | `--json-output` | List mode: emit `{ "templates": [...] }` summaries (or full definitions with `--full`) instead of the table. Detail mode (`--template-id`) is always compact JSON. Summaries carry `pageUrl` (web detail page) and `showcases: { count, pageUrl, items }`; detail mode carries top-level `pageUrls` and `showcases` maps. Each is absent when the backend does not serve it. | off |
 | `--open <id>` | Print the template's web detail page URL (samples, layouts) and open the browser when run from an interactive terminal. Exits 1 when the backend has no link for it. Cannot be combined with `--template-id`. | — |

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

@@ -1,83 +1,83 @@
-"""Shared resolver for the ``countdown`` scene strategy.
-
-A countdown is the "one opening, then N beats of the same kind, counting down"
-shape: Top-N lists, "5 个技巧", "7 个常见错误". It sits on the same axis as
-``arc`` / ``single`` / ``fixed`` because it is a *shape*, not a subject — which
-is the whole reason it is not called "ranking" and holds no GitHub-specific
-knowledge.
-
-None of the existing strategies could express it: ``arc`` clamps to at least 3
-scenes, always appends a ``cta``, and numbers its beats upward; ``fixed`` needs a
-static scene list and so cannot take a count at all.
-
-─── Why this module is shared rather than copied ──────────────────────────────
-Two skills need the same answer from the same declaration:
-
-  * ``gen-script``   — to lay out the scenes and write the count into each payload
-  * ``render-video`` — to validate a plan (scene count, countdown completeness)
-    before any asset is paid for
-
-Copying the resolution into both is how the previous iteration of this feature
-went wrong in the other direction (a Python port of the template's copy rules
-living next to the real ones). ``skills/template-registry/scripts/`` is the
-sanctioned home for cross-skill Python — see AGENTS.md.
-
-─── What is declared where ───────────────────────────────────────────────────
-The strategy carries the shape; the template carries every concrete value:
-
-    "capabilities": {
-      "sceneStrategy": "countdown",
-      "countdown": {
-        "countProp": "topN",            // where the count goes in customPayload
-        "itemProp": "item",             // where one beat's item goes
-        "indexProp": "rank",            // the index field inside that item
-        "legacyCountProps": ["totalItems"],
-        "openingSec": 2.5,              // optional, default DEFAULT_OPENING_SEC
-        "countPatterns": ["..."]        // optional: regexes that find a count stated
-                                        // in on-screen copy (group 1 = the number)
-      }
-    }
 
-Bounds are deliberately **not** repeated here: they are read from
-``customPayloadSchema[countProp]``'s ``minimum`` / ``maximum`` / ``default``,
-which every template already has to author for its own payload contract. Having
-one number in two places is how they drift.
 
-Declaring the prop *names* is what keeps this module honest. They used to be
-hardcoded, which meant a second countdown template naming its count
-``itemCount`` would silently lose validation entirely: nothing would be found,
-the count would fall back to "however many cards are present", and the
-"scene count matches the count" check would compare that number to itself.
-"""
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 from __future__ import annotations
 
 import re
 
-#: Opening budget when the template declares none. A generic "an opening is a
-#: beat, not a chapter" value — **not** any one template's measurement. It used
-#: to be 3 hardcoded in gen_script, taken from github-repo-rank's reference film
-#: (2.43s), which put a single template's fact in the CLI.
+
+
+
+
 DEFAULT_OPENING_SEC = 3
 
 
 class CountdownError(ValueError):
-    """Raised for an unusable countdown declaration.
+    pass
+
+
+
+
 
-    A subclass so callers can keep treating it as the ValueError they already
-    handle, while a reader can still see that an authoring mistake and a bad
-    ``--item-count`` are two different things.
-    """
 
 
 def resolve_countdown_spec(template: dict | None) -> dict | None:
-    """Resolve a template's countdown declaration, or None if it is not one.
 
-    Raises CountdownError when ``sceneStrategy=countdown`` is declared but the
-    rest of the contract is missing. Failing loudly here is the point: every
-    downstream check reads these names, so an incomplete declaration must not
-    degrade into "no countdown rules apply".
-    """
+
+
+
+
+
+
     caps = (template or {}).get("capabilities")
     caps = caps if isinstance(caps, dict) else {}
     if caps.get("sceneStrategy") != "countdown":
@@ -96,8 +96,8 @@ def resolve_countdown_spec(template: dict | None) -> dict | None:
         )
     count_prop = count_prop.strip()
 
-    # itemProp / indexProp 同样必须声明：缺省值只能是某个具体模板的字段名，
-    # 那等于把那个模板写进 CLI。
+
+
     names: dict[str, str] = {}
     for key in ("itemProp", "indexProp"):
         value = cfg.get(key)
@@ -171,12 +171,12 @@ def resolve_countdown_spec(template: dict | None) -> dict | None:
 
 
 def stated_counts(spec: dict, text: str) -> set[int]:
-    """Counts that on-screen copy states, found with the template's ``countPatterns``.
 
-    How a count is worded (``Top 5`` / ``前 5 名`` / ``5 个技巧``) is the
-    template's copy convention, so the patterns are declared there; a template
-    that declares none gets no check.
-    """
+
+
+
+
+
     found: set[int] = set()
     for pattern in spec.get("count_patterns") or []:
         for match in pattern.finditer(text or ""):
@@ -187,14 +187,14 @@ def stated_counts(spec: dict, text: str) -> set[int]:
 
 
 def resolve_count(spec: dict, requested: int | None, scene_count: int | None) -> int:
-    """Validate a caller-supplied item count against the template's own bounds.
-
-    ``requested`` is the number of content beats the caller asked for — the same
-    number the user picked. It is deliberately *not* derived from ``scene_count``:
-    a caller passing the user's 5 as a total scene count would produce 4 cards
-    with a self-consistent ``count=4`` written everywhere, which no validator can
-    catch and the user never sees. So the two are cross-checked instead.
-    """
+
+
+
+
+
+
+
+
     count = spec["default"] if requested is None else requested
     if type(count) is not int or not spec["minimum"] <= count <= spec["maximum"]:
         raise ValueError(
@@ -210,26 +210,26 @@ def resolve_count(spec: dict, requested: int | None, scene_count: int | None) ->
 
 
 def opening_sec(spec: dict, count: int, duration: float) -> float:
-    """Seconds for the single opening scene.
 
-    ``openingSec`` is an upper bound, not a fixed value: on a short video it
-    yields to an even split so a long opening budget cannot starve the beats.
 
-    Worth knowing how provisional this is — ``render_video``'s
-    ``adjust_timeline_to_audio`` overwrites every scene's duration with the real
-    narration length once TTS exists. This number shapes the script the user
-    reviews and the duration/cost estimate, not the finished cut.
-    """
+
+
+
+
+
+
+
+
     return min(spec["opening_sec"], duration / (count + 1))
 
 
 def scene_payload(spec: dict, count: int, index: int | None) -> dict:
-    """The countdown part of one scene's customPayload, under declared names.
 
-    ``index`` is None for the opening. For a beat only the index is filled:
-    inventing the rest of the item would put fabricated data on screen, so the
-    caller is expected to fill it with real content before assets are prepared.
-    """
+
+
+
+
+
     payload: dict = {spec["count_prop"]: count}
     for prop in spec["legacy_count_props"]:
         payload[prop] = count