@remixmate/cli 0.9.63 → 0.9.64

package/dist/manifest.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
-  "version": "0.9.63",
-  "generatedAt": "2026-10-04T06:46:47.501Z",
+  "version": "0.9.64",
+  "generatedAt": "2026-10-04T11:52:39.175Z",
   "skills": [
     {
       "id": "doc-parse",
@@ -994,7 +994,7 @@
           },
           "json_output": {
             "type": "boolean",
-            "description": "Emit a JSON result instead of the human-readable table: { templates: [...] } — summaries, or full definitions when template_id / full is set — or { examples: [...] }. When the backend serves samples, list summaries carry showcases { count, pageUrl, items } and the template_id view carries a top-level showcases map."
+            "description": "Emit a JSON result instead of the human-readable table: { templates: [...] } — summaries, or full definitions when template_id / full is set — or { examples: [...] }. List summaries carry pageUrl (the template's web detail page — show it to the user as a link) and, when the backend serves samples, showcases { count, pageUrl, items }; the template_id view carries top-level pageUrls / showcases maps."
           },
           "open": {
             "type": "string",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remixmate/cli",
-  "version": "0.9.63",
+  "version": "0.9.64",
   "description": "AI media generation skills for Claude Code / Codex — 12 skills covering image, video, voice, digital human, web screenshot, web recording, script, template registry, rendering, Jianying export, and video deconstruction.",
   "type": "module",
   "main": "dist/index.js",

package/skills/template-registry/SKILL.md

@@ -78,7 +78,7 @@ remixmate template-registry --list-templates
 
 ### Show templates to the user
 
-When the user asks to see / browse / pick templates, they decide by *watching* samples, not by reading definitions. The list adds, per template, the number of samples and a link to its web detail page (playable samples, layouts, a copy-ready prompt) whenever the backend serves them (`↳ samples: N · <url>` in the table; `showcases.count` / `showcases.pageUrl` in JSON).
+When the user asks to see / browse / pick templates, they decide by *watching* samples, not by reading definitions. The list adds, per template, a link to its web detail page (playable samples, layouts, a copy-ready prompt) and the number of samples whenever the backend serves them — table: `↳ detail: <url>` and `↳ samples: N`; JSON: each summary's `pageUrl` and `showcases.count`; `--template-id`: top-level `pageUrls`.
 
 - Present each template as: name, aspect ratios, sample count, and its `pageUrl` as a clickable Markdown link. Keep the URL exactly as printed.
 - When the user wants to see what one template looks like, give its link, or run `remixmate template-registry --open <templateId>` (prints the URL; opens the browser only from an interactive terminal — relay the printed URL either way).
@@ -111,7 +111,7 @@ print(json.dumps(binding, ensure_ascii=False, indent=2))
 | `--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 |
 | `--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 `showcases: { count, pageUrl, items }` and detail mode a top-level `showcases` map when the backend serves samples (absent otherwise). | 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`. | — |
 
 ### List vs. detail

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

@@ -72,9 +72,10 @@ Flags:
                                    (samples, layouts); also opens the browser
                                    when stdout is an interactive terminal
 
-Samples (showcase_loader.py): list and detail views add each template's sample
-count and web detail-page link when ab-api serves them; when it does not, the
-views are unchanged apart from one stderr warning.
+Links & samples: list and detail views add each template's web detail-page
+link (registry document-level ``pageUrls``, falling back to the samples
+endpoint) and sample count (showcase_loader.py) when ab-api serves them; when
+it does not, the views are unchanged apart from one stderr warning.
 """
 
 from __future__ import annotations
@@ -94,6 +95,7 @@ from registry_loader import (  # noqa: E402
     RegistryUnreachableError,
     get_template,
     list_templates as load_visible_templates,
+    registry_page_urls,
 )
 from showcase_loader import load_showcases, summarize_group  # noqa: E402
 
@@ -198,6 +200,23 @@ def _open_in_browser(url: str) -> None:
         pass
 
 
+def _page_url(template_id: object, page_urls: dict[str, str], groups: dict | None) -> str | None:
+    """Web detail page link for one template.
+
+    The registry's document-level ``pageUrls`` comes first: it rides on the call
+    every list makes anyway, so the link survives the samples endpoint being
+    down. The samples group's ``pageUrl`` is the fallback (same URL, built by
+    the same backend helper).
+    """
+    if not isinstance(template_id, str):
+        return None
+    if page_urls.get(template_id):
+        return page_urls[template_id]
+    group = (groups or {}).get(template_id)
+    url = group.get("pageUrl") if isinstance(group, dict) else None
+    return url if isinstance(url, str) and url else None
+
+
 def _report_unknown_ids(missing: list[str], templates: list[dict]) -> None:
     for tid in missing:
         # Distinguish "gated out by status" from "does not exist" —
@@ -459,6 +478,7 @@ def main() -> None:
         sys.exit(1)
 
     by_id = {t.get("templateId"): t for t in templates}
+    page_urls = registry_page_urls()
 
     # ----- open mode (--open) -------------------------------------------------
     #
@@ -468,8 +488,9 @@ def main() -> None:
         if args.open_id not in by_id:
             _report_unknown_ids([args.open_id], templates)
             sys.exit(1)
-        groups = load_showcases([args.open_id], 1)
-        page_url = (groups or {}).get(args.open_id, {}).get("pageUrl")
+        page_url = _page_url(args.open_id, page_urls, None)
+        if not page_url:
+            page_url = _page_url(args.open_id, {}, load_showcases([args.open_id], 1))
         if not page_url:
             print(
                 "❌ No web detail page link for this template: the backend does not "
@@ -520,9 +541,16 @@ def main() -> None:
         # chars), which alone pushed the plain call past the tool-result cap and
         # got it spilled to a file the agent cannot read. Humans can `| jq`.
         detail: dict = {"templates": picked}
-        # Samples sit beside the definitions, never inside them: the definition
-        # is the template's authoring contract, samples are web content.
+        # Samples and links sit beside the definitions, never inside them: the
+        # definition is the template's authoring contract, these are web content.
         groups = load_showcases([str(t.get("templateId")) for t in picked], _DETAIL_SHOWCASES)
+        links = {
+            str(t.get("templateId")): url
+            for t in picked
+            if (url := _page_url(t.get("templateId"), page_urls, groups))
+        }
+        if links:
+            detail["pageUrls"] = links
         if groups is not None:
             detail["showcases"] = {
                 tid: summarize_group(g, _DETAIL_SHOWCASES) for tid, g in groups.items()
@@ -554,6 +582,8 @@ def main() -> None:
         summaries = []
         for t in visible:
             s = _summarize(t)
+            if url := _page_url(t.get("templateId"), page_urls, groups):
+                s["pageUrl"] = url
             # Absent (not null) when the endpoint is unavailable, so a consumer
             # never mistakes "unknown" for "zero samples".
             if groups is not None and t.get("templateId") in groups:
@@ -576,6 +606,7 @@ def main() -> None:
         return
 
     groups = load_showcases([str(t.get("templateId")) for t in visible], _LIST_SHOWCASES)
+    any_link = False
 
     header = (
         f"\n{'Template ID':<22} {'Name':<18} {'Aspect':<12} "
@@ -596,12 +627,14 @@ def main() -> None:
         hint = _truncate(tpl.get("llmHint"), _SUMMARY_HINT_CHARS)
         if hint:
             print(f"{' ' * 22}   ↳ {hint}")
+        # Two lines, link on its own: an agent summarizing the table keeps a
+        # labelled `detail:` line, a URL trailing a count reads as an aside.
         group = (groups or {}).get(tpl.get("templateId"))
         if group is not None:
-            line = f"samples: {int(group.get('showcaseCount') or 0)}"
-            if group.get("pageUrl"):
-                line += f" · {group['pageUrl']}"
-            print(f"{' ' * 22}   ↳ {line}")
+            print(f"{' ' * 22}   ↳ samples: {int(group.get('showcaseCount') or 0)}")
+        if url := _page_url(tpl.get("templateId"), page_urls, groups):
+            print(f"{' ' * 22}   ↳ detail: {url}")
+            any_link = True
 
     print(f"\n{len(visible)} template(s) shown")
     first_id = str(visible[0].get("templateId", "<templateId>"))
@@ -609,8 +642,8 @@ def main() -> None:
         f"Full definition of one template: --template-id {first_id} --json-output "
         "(llmHint / customPayloadSchema / slideSchemas / slotMapping / variants)",
     )
-    if groups:
-        print(f"Watch samples in the browser: --open {first_id}")
+    if any_link:
+        print(f"Watch samples / layouts in the browser: open a detail link, or --open {first_id}")
 
 
 if __name__ == "__main__":

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

@@ -306,6 +306,23 @@ def load_registry_data(
     return _load_from_url(url, ttl=ttl_seconds, timeout=http_timeout)
 
 
+def registry_page_urls() -> dict[str, str]:
+    """Document-level ``pageUrls`` (templateId → web detail page), built by ab-api.
+
+    Kept beside ``templates`` rather than inside each definition: a definition is
+    the template's authoring contract, a link is site information. Absent on
+    older backends, offline registries, or when the backend has no site address
+    configured — returns ``{}`` then (never raises: it is display-only).
+    """
+    try:
+        raw = load_registry_data().get("pageUrls")
+    except Exception:  # noqa: BLE001 — the caller already loaded the registry once
+        return {}
+    if not isinstance(raw, dict):
+        return {}
+    return {k: v for k, v in raw.items() if isinstance(k, str) and isinstance(v, str) and v}
+
+
 # ════════════════════════════════════════════════════════════════════════════
 # Indexed views — O(1) template-id lookup + status / beta gating
 #

package/skills/template-registry/skill.json

@@ -19,7 +19,7 @@
       "filter_aspect": { "type": "string", "description": "Show only templates that declare this aspect ratio. E.g. '9:16' / '16:9' / '1:1'." },
       "filter_language": { "type": "string", "description": "Show only templates whose contentLanguage includes this code ('zh' or 'en'). Templates with no declared language are always shown (treated as language-agnostic)." },
       "include_beta": { "type": "boolean", "description": "Also list templates with status='beta'. Default off (only 'stable' shows). The ENABLE_BETA_TEMPLATES env var has the same effect process-wide." },
-      "json_output": { "type": "boolean", "description": "Emit a JSON result instead of the human-readable table: { templates: [...] } — summaries, or full definitions when template_id / full is set — or { examples: [...] }. When the backend serves samples, list summaries carry showcases { count, pageUrl, items } and the template_id view carries a top-level showcases map." },
+      "json_output": { "type": "boolean", "description": "Emit a JSON result instead of the human-readable table: { templates: [...] } — summaries, or full definitions when template_id / full is set — or { examples: [...] }. List summaries carry pageUrl (the template's web detail page — show it to the user as a link) and, when the backend serves samples, showcases { count, pageUrl, items }; the template_id view carries top-level pageUrls / showcases maps." },
       "open": { "type": "string", "description": "Print the web detail page URL of <templateId> (playable samples, layouts, copy-ready prompt) and open it in the browser when run from an interactive terminal. Relay the printed URL to the user." }
     },
     "required": []