@lemoncat7/dsh-partner 2.8.1 → 2.8.2

package/resources/skills/video-recap-production/upstream/skills/video-recap/scripts/project_binding.py

@@ -0,0 +1,286 @@
+"""Resolve a ``recap_project.json`` binding into the settings stage skills already accept.
+
+Only video-recap reads the library. A bound subtitle style becomes ``SUBTITLE_*`` env for
+video-assemble, a bound voice becomes the voiceover provider / voice arguments, a bound
+BGM becomes ``BGM_PATH``. Stage skills keep seeing concrete paths and values; they never
+learn about templates. Anything the caller already set explicitly must agree with the
+binding — a silent override would make the delivered file disagree with the project.
+"""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+import library as library_lib
+
+PROJECT_FILE = "recap_project.json"
+PROJECT_SCHEMA = "video-recap.project.v1"
+PROJECT_KEYS = {"schema", "name", "library", "bindings", "notes"}
+BINDING_KINDS = ("subtitle_style", "packaging", "voice", "bgm")
+
+
+class BindingError(SystemExit):
+    """A project binding that cannot be applied; exits before any stage runs."""
+
+    def __init__(self, message):
+        super().__init__(f"项目绑定无法使用: {message}")
+
+
+def project_path(value) -> Path:
+    path = Path(value).expanduser().resolve()
+    if path.is_dir():
+        path = path / PROJECT_FILE
+    if not path.is_file():
+        raise BindingError(f"找不到 {path}")
+    return path
+
+
+def _value(params, key):
+    node = params.get(key)
+    return node.get("value") if isinstance(node, dict) else None
+
+
+def _record(entry):
+    return json.loads(Path(entry["record"]).read_text(encoding="utf-8"))
+
+
+def _subtitle_env(template, record, resources):
+    params = record["params"]
+    canvas = record["canvas"]
+    env = {
+        "SUBTITLE_PLAY_RES_X": canvas["width"],
+        "SUBTITLE_PLAY_RES_Y": canvas["height"],
+        "SUBTITLE_FONT_SIZE": _value(params, "size_px"),
+        "SUBTITLE_OUTLINE": _value(params, "outline_px"),
+        "SUBTITLE_SHADOW": _value(params, "shadow_px"),
+        "SUBTITLE_PRIMARY_COLOR": _value(params, "primary_color"),
+        "SUBTITLE_OUTLINE_COLOR": _value(params, "outline_color"),
+        "SUBTITLE_MAX_CHARS": _value(params, "max_chars"),
+        "SUBTITLE_MAX_LINES": _value(params, "max_lines"),
+    }
+    font = params["font"]
+    if font.get("resource"):
+        resource = resources[font["resource"]]
+        env["SUBTITLE_FONT_NAME"] = (_record(resource).get("font") or {}).get("family")
+        env["SUBTITLE_FONT_FILE"] = resource["files"][0]["path"]
+    else:
+        env["SUBTITLE_FONT_NAME"] = font["family"]
+    band = _value(params, "band")
+    if band:
+        env["SUBTITLE_ALIGNMENT"] = 2
+        env["SUBTITLE_MARGIN_V"] = canvas["height"] - band["y_bot"]
+    return {k: str(v) for k, v in env.items() if v is not None}
+
+
+def _voice_updates(resource, args):
+    record = _record(resource)
+    voice = record.get("voice") or {}
+    provider = voice.get("provider")
+    consent = (record.get("consent") or {}).get("status")
+    if resource["files"] and consent == "denied":
+        raise BindingError(f"音色 {resource['id']} 的参考音频声音授权为 denied")
+    if args.tts_provider not in ("auto", provider):
+        raise BindingError(f"音色 {resource['id']} 属于 {provider}，与 --tts-provider {args.tts_provider} 冲突")
+    updates, env = {"tts_provider": provider}, {}
+    if provider == "mimo-tts":
+        if resource["files"]:
+            updates["voice_ref"] = resource["files"][0]["path"]
+        else:
+            updates["mimo_tts_voice"] = voice.get("voice_id")
+    elif provider == "fish-audio":
+        env["FISH_TTS_REFERENCE_ID"] = voice.get("voice_id")
+    else:
+        env["INDEX_TTS_VOICE"] = voice.get("voice_id")
+    return updates, env
+
+
+def _same_setting(key, current, value):
+    if key.endswith(("_PATH", "_FILE", "VOICE_REF")):
+        return Path(current).expanduser().resolve() == Path(value).expanduser().resolve()
+    try:
+        return float(current) == float(value)
+    except ValueError:
+        return current == value
+
+
+def _check_env_conflicts(env, environ):
+    for key, value in env.items():
+        current = environ.get(key, "").strip()
+        if current and not _same_setting(key, current, value):
+            raise BindingError(f"{key}={current} 与项目绑定的 {value} 冲突；删掉其中一处")
+
+
+def _check_arg_conflicts(updates, args):
+    for key, value in updates.items():
+        current = getattr(args, key, None)
+        if key == "tts_provider" or current in (None, ""):
+            continue
+        if str(current) != str(value):
+            raise BindingError(f"--{key.replace('_', '-')} {current} 与项目绑定的 {value} 冲突")
+
+
+def resolve_project(value, args, environ=None, *, include_voice=True) -> dict:
+    """Load and validate a project; return what to apply plus the lock's project block."""
+    environ = os.environ if environ is None else environ
+    path = project_path(value)
+    try:
+        project = json.loads(path.read_text(encoding="utf-8"))
+    except ValueError as exc:
+        raise BindingError(f"{path} 无法解析: {exc}") from None
+    if not isinstance(project, dict) or project.get("schema") != PROJECT_SCHEMA:
+        raise BindingError(f"{path} 的 schema 必须是 {PROJECT_SCHEMA}")
+    unknown = sorted(set(project) - PROJECT_KEYS)
+    bindings = project.get("bindings") or {}
+    unknown += sorted(f"bindings.{k}" for k in set(bindings) - set(BINDING_KINDS))
+    if unknown:
+        raise BindingError(f"{path} 有未知字段: {', '.join(unknown)}")
+    library_root = (path.parent / str(project.get("library", ""))).resolve()
+    if not (library_root / "library.json").is_file():
+        raise BindingError(f"库目录无效（缺少 library.json）: {library_root}")
+    index, report = library_lib.scan_library(library_root)
+    resources = {r["id"]: r for r in index["resources"]}
+    templates = {f"{t['id']}@v{t['version']}": t for t in index["templates"]}
+    errors = {}
+    for issue in report.errors:
+        errors.setdefault(issue["path"], issue["message"])
+
+    def require_valid(entry, label):
+        rel = Path(entry["record"]).relative_to(library_root).as_posix()
+        if rel in errors:
+            raise BindingError(f"{label}: {errors[rel]}（先运行 library.py check）")
+
+    def template(kind):
+        ref = bindings.get(kind)
+        if not ref:
+            return None
+        entry = templates.get(ref)
+        if entry is None or entry["kind"] != kind:
+            raise BindingError(f"{kind} 模板 {ref} 不存在或无效（先运行 library.py check）")
+        if entry["status"] != "adopted":
+            raise BindingError(f"{kind} 模板 {ref} 的状态是 {entry['status']}，只有 adopted 能绑定")
+        require_valid(entry, ref)
+        for _, rid in entry["refs"]:
+            if rid not in resources:
+                raise BindingError(f"{ref} 引用的资源 {rid} 不存在或无效（先运行 library.py check）")
+            require_valid(resources[rid], f"{ref} 引用的资源 {rid}")
+        return entry
+
+    def resource(kind):
+        rid = bindings.get(kind)
+        if not rid:
+            return None
+        entry = resources.get(rid)
+        if entry is None or entry["kind"] != kind:
+            raise BindingError(f"{kind} 资源 {rid} 不存在或无效（先运行 library.py check）")
+        require_valid(entry, f"{kind} 资源 {rid}")
+        return entry
+
+    env, updates, used_templates = {}, {}, []
+    subtitle = template("subtitle_style")
+    if subtitle:
+        env.update(_subtitle_env(subtitle, _record(subtitle), resources))
+        used_templates.append({"role": "subtitle_style", "id": subtitle["id"],
+                               "version": subtitle["version"], "status": subtitle["status"],
+                               "canvas": subtitle["canvas"]})
+    packaging = template("packaging")
+    if packaging:
+        used_templates.append({"role": "packaging", "id": packaging["id"],
+                               "version": packaging["version"], "status": packaging["status"],
+                               "canvas": packaging["canvas"]})
+    voice = resource("voice") if include_voice else None
+    if voice:
+        voice_updates, voice_env = _voice_updates(voice, args)
+        updates.update(voice_updates)
+        env.update(voice_env)
+    bgm = resource("bgm")
+    if bgm and getattr(args, "audio_mode", "narration") == "adopted-packet-copy":
+        raise BindingError("adopted-packet-copy 冻结原音轨，不能再绑定 BGM；去掉 bindings.bgm 或换声音模式")
+    if bgm:
+        env["BGM_PATH"] = bgm["files"][0]["path"]
+    material_env = environ.get("VIDEO_RECAP_MATERIAL_LIBRARY_DIR", "").strip()
+    if (material_env and not getattr(args, "material_library_dir", None)
+            and Path(material_env).expanduser().resolve() != library_root):
+        raise BindingError(
+            f"VIDEO_RECAP_MATERIAL_LIBRARY_DIR={material_env} 与项目的库 {library_root} 不是同一个目录；"
+            "素材库与资源库共用根目录，删掉其中一处"
+        )
+    _check_env_conflicts(env, environ)
+    _check_env_conflicts(
+        {name: updates[key] for key, name in (("mimo_tts_voice", "MIMO_TTS_VOICE"), ("voice_ref", "VOICE_REF"))
+         if key in updates},
+        environ,
+    )
+    _check_arg_conflicts(updates, args)
+    return {
+        "path": str(path),
+        "name": project.get("name", ""),
+        "library": str(library_root),
+        "env": env,
+        "arg_updates": updates,
+        "templates": used_templates,
+        "resources": [],
+        "packaging": packaging and {"record": _record(packaging), "resources": resources},
+    }
+
+
+def apply_project(resolved, args, environ=None) -> None:
+    """Write the resolved settings where the stage skills will read them."""
+    environ = os.environ if environ is None else environ
+    for key, value in resolved["env"].items():
+        environ[key] = value
+    bound = set()
+    for key, value in resolved["arg_updates"].items():
+        if getattr(args, key, None) != value:
+            bound.add(key)
+        setattr(args, key, value)
+    if not getattr(args, "material_library_dir", None):
+        args.material_library_dir = resolved["library"]
+        bound.add("material_library_dir")
+    args._bound_from_project = frozenset(bound)
+    args.resolved_project = resolved
+
+
+def check_canvas(resolved, width, height) -> None:
+    """Templates only apply to the canvas they were calibrated on."""
+    for template in resolved["templates"]:
+        canvas = template["canvas"]
+        if (canvas["width"], canvas["height"]) != (width, height):
+            raise BindingError(
+                f"{template['role']} 模板 {template['id']}@v{template['version']} 按 "
+                f"{canvas['width']}x{canvas['height']} 校准，成片画布是 {width}x{height}；换一个同画幅的模板"
+            )
+
+
+PACKAGING_LAYERS = "packaging_layers.json"
+_WRITTEN_BY = "video-recap --project"
+
+
+def sync_packaging_layers(work_dir, resolved) -> None:
+    """Write the bound packaging template's layers for video-assemble, or retire our old copy.
+
+    A caller-authored ``packaging_layers.json`` (no ``written_by`` marker) is left alone.
+    """
+    path = Path(work_dir) / PACKAGING_LAYERS
+    packaging = (resolved or {}).get("packaging")
+    if not packaging:
+        if path.exists():
+            try:
+                plan = json.loads(path.read_text(encoding="utf-8"))
+            except ValueError:
+                plan = None
+            ours = isinstance(plan, dict) and plan.get("written_by") == _WRITTEN_BY
+            if ours:
+                path.unlink()
+        return
+    record, resources = packaging["record"], packaging["resources"]
+    layers = [{"name": layer["name"],
+               "path": resources[layer["image"]["resource"]]["files"][0]["path"],
+               "rect": layer["rect"]}
+              for layer in record["params"]["layers"]]
+    path.write_text(json.dumps({
+        "written_by": _WRITTEN_BY,
+        "template": {"id": record["id"], "version": record["version"]},
+        "canvas": record["canvas"],
+        "layers": layers,
+    }, ensure_ascii=False, indent=2), encoding="utf-8")

package/resources/skills/video-recap-production/upstream/skills/video-recap/scripts/qc/__init__.py

@@ -0,0 +1 @@
+"""MiMo QC subpackage."""

package/resources/skills/video-recap-production/upstream/skills/video-recap/scripts/qc/mimo_client.py

@@ -0,0 +1,13 @@
+"""Load this skill's MiMo client without depending on the ambient ``lib`` module."""
+
+import importlib.util
+from pathlib import Path
+
+_SPEC = importlib.util.spec_from_file_location(
+    "video_recap_mimo_qc_lib", Path(__file__).resolve().parents[1] / "lib.py"
+)
+_LIB = importlib.util.module_from_spec(_SPEC)
+_SPEC.loader.exec_module(_LIB)
+
+DEFAULT_CONFIG = _LIB.CONFIG
+mimo_qc_api_call = _LIB.mimo_qc_api_call

package/resources/skills/video-recap-production/upstream/skills/video-recap/scripts/qc/mimo_contract.py

@@ -0,0 +1,9 @@
+"""Shared constants for the self-contained MiMo QC adapter."""
+
+ARTIFACT_NAME = "mimo_qc.json"
+DEFAULT_STAGE = "pre_assemble"
+MAX_OBSERVATIONS = 12
+MAX_MESSAGE_CHARS = 800
+MAX_FRAMES = 6
+MAX_FRAME_DIMENSION = 768
+FRAME_SAMPLER_VERSION = 2

package/resources/skills/video-recap-production/upstream/skills/video-recap/scripts/qc/mimo_evidence.py

@@ -0,0 +1,287 @@
+"""Collect and redact local evidence for MiMo QC."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+from collections.abc import Mapping, Sequence
+
+import qc_contract
+from qc.mimo_client import DEFAULT_CONFIG
+
+_JSON_ARTIFACTS = (
+    "narration.json",
+    "visual_overlays.json",
+    "clip_plan_validated.json",
+    "clip_plan.json",
+    "assembly_manifest.json",
+    "tts_meta.json",
+)
+
+_SOURCE_ASR_ARTIFACTS = (
+    "asr_clean.json",
+    "asr.json",
+    "asr_result.json",
+    "asr_segments.json",
+)
+
+_GENERATED_SUBTITLE_ARTIFACTS = (
+    "subtitles.json",
+    "subtitle.json",
+    "subtitles.srt",
+    "subtitle.srt",
+    "subtitles.vtt",
+    "subtitle.vtt",
+    "output.srt",
+    "output.vtt",
+)
+
+_OPTIONAL_VISUAL_METADATA = (
+    "sampled_frames.json",
+    "frame_samples.json",
+    "storyboard.json",
+    "storyboard_meta.json",
+    "frames_manifest.json",
+)
+
+
+def _load_json(path: Path) -> Any:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def _read_text_sample(path: Path, *, max_chars: int = 4000) -> dict[str, Any]:
+    text = path.read_text(encoding="utf-8", errors="replace")
+    return {
+        "kind": "text",
+        "bytes": path.stat().st_size,
+        "truncated": len(text) > max_chars,
+        "sample": text[:max_chars],
+    }
+
+
+def _summarize(
+    value: Any, *, max_items: int = 8, max_string: int = 700, depth: int = 0
+) -> Any:
+    """Keep request/report evidence bounded while retaining useful structure."""
+    if depth >= 4:
+        return {"type": type(value).__name__, "omitted": True}
+    if isinstance(value, Mapping):
+        out = {
+            str(key): _summarize(
+                item, max_items=max_items, max_string=max_string, depth=depth + 1
+            )
+            for key, item in list(value.items())[:max_items]
+        }
+        if len(value) > max_items:
+            out["_omitted_keys"] = len(value) - max_items
+        return out
+    if isinstance(value, list):
+        return {
+            "count": len(value),
+            "items": [
+                _summarize(
+                    item, max_items=max_items, max_string=max_string, depth=depth + 1
+                )
+                for item in value[:max_items]
+            ],
+            "omitted": max(0, len(value) - max_items),
+        }
+    if isinstance(value, str) and len(value) > max_string:
+        return {"text": value[:max_string], "truncated": True, "chars": len(value)}
+    return value
+
+
+def _collect_file(work_dir: Path, name: str) -> dict[str, Any] | None:
+    path = work_dir / name
+    if not path.is_file():
+        return None
+    if path.suffix.lower() == ".json":
+        kind, summary = "json", _summarize(_load_json(path))
+    else:
+        kind, summary = "text", _summarize(_read_text_sample(path))
+    stat = path.stat()
+    return {
+        "path": name,
+        "kind": kind,
+        "bytes": stat.st_size,
+        "mtime_ns": stat.st_mtime_ns,
+        "summary": summary,
+    }
+
+
+def _first_existing(work_dir: Path, names: Sequence[str]) -> str | None:
+    return next((name for name in names if (work_dir / name).is_file()), None)
+
+
+def _collect_multi_source_asr(work_dir: Path) -> dict[str, Any]:
+    """Collect per-source ASR when a multi-source project has no root transcript."""
+    manifest_path = work_dir / "multi_source_manifest.json"
+    if not manifest_path.is_file():
+        return {}
+    collected = {}
+    for source in _load_json(manifest_path)["sources"]:
+        relative_dir = source["source_work_dir"]  # recap writes sources/<source_id>
+        name = _first_existing(work_dir / relative_dir, _SOURCE_ASR_ARTIFACTS)
+        if name is not None:
+            collected[source["source_id"]] = _collect_file(work_dir, f"{relative_dir}/{name}")
+    return collected
+
+
+def _resolve_candidate(work_dir: Path, candidate: str | Path) -> Path:
+    path = Path(candidate)
+    return path if path.is_absolute() else work_dir / path
+
+
+def _final_output_path(
+    work_dir: Path, final_output: str | Path | None
+) -> tuple[Path, str] | None:
+    """(path, display) of the final output: the caller's, else assembly_manifest.final_output
+    (video-assemble always writes it); None before the assembler has run."""
+    if final_output is None:
+        manifest_path = work_dir / "assembly_manifest.json"
+        if not manifest_path.is_file():
+            return None
+        final_output = _load_json(manifest_path)["final_output"]
+    return _resolve_candidate(work_dir, final_output), str(final_output)
+
+
+def _final_output_metadata(
+    work_dir: Path, final_output: str | Path | None = None
+) -> dict[str, Any]:
+    resolved = _final_output_path(work_dir, final_output)
+    if resolved is None:
+        return {"candidates": []}
+    path, display = resolved
+    item: dict[str, Any] = {"path": display, "exists": path.is_file()}
+    if item["exists"]:
+        stat = path.stat()
+        item.update({"bytes": stat.st_size, "mtime_ns": stat.st_mtime_ns})
+    return {"candidates": [item]}
+
+
+def _existing_final_output(
+    work_dir: Path, final_output: str | Path | None
+) -> Path | None:
+    resolved = _final_output_path(work_dir, final_output)
+    return resolved[0] if resolved is not None and resolved[0].is_file() else None
+
+
+def collect_evidence(
+    work_dir: str | Path, *, final_output: str | Path | None = None
+) -> dict[str, Any]:
+    """Collect lightweight, secret-scrubbed evidence from one work directory."""
+    root = Path(work_dir)
+    artifacts: dict[str, Any] = {}
+    preferred_plan = _first_existing(
+        root, ("clip_plan_validated.json", "clip_plan.json")
+    )
+    for name in _JSON_ARTIFACTS:
+        if (
+            name in {"clip_plan_validated.json", "clip_plan.json"}
+            and name != preferred_plan
+        ):
+            continue
+        item = _collect_file(root, name)
+        if item is not None:
+            artifacts[name] = item
+    evidence = {
+        # Display only; excluded from cache_input so moving the work directory is a cache hit.
+        "work_dir": str(root),
+        "artifacts": artifacts,
+        "source_asr": {
+            name: item
+            for name in _SOURCE_ASR_ARTIFACTS
+            if (item := _collect_file(root, name)) is not None
+        },
+        "generated_subtitles": {
+            name: item
+            for name in _GENERATED_SUBTITLE_ARTIFACTS
+            if (item := _collect_file(root, name)) is not None
+        },
+        "visual_metadata": {
+            name: item
+            for name in _OPTIONAL_VISUAL_METADATA
+            if (item := _collect_file(root, name)) is not None
+        },
+        "final_output": _final_output_metadata(root, final_output),
+    }
+    if not evidence["source_asr"]:
+        evidence["source_asr"] = _collect_multi_source_asr(root)
+    # The evidence goes into the MiMo request as well as the persisted report, so it is
+    # redacted here, before either.
+    return qc_contract.redact_secrets(evidence)
+
+
+def _cache_file_group(group: Mapping[str, Any]) -> dict[str, Any]:
+    return {
+        name: {key: item[key] for key in ("kind", "bytes", "mtime_ns")}
+        for name, item in sorted(group.items())
+    }
+
+
+def _cache_evidence(evidence: Mapping[str, Any]) -> dict[str, Any]:
+    """The per-file identities ({kind, bytes, mtime_ns}) a cached stage report was built
+    from; work_dir is excluded so moving the directory is still a cache hit."""
+    return {
+        "artifacts": _cache_file_group(evidence["artifacts"]),
+        "source_asr": _cache_file_group(evidence["source_asr"]),
+        "generated_subtitles": _cache_file_group(evidence["generated_subtitles"]),
+        "visual_metadata": _cache_file_group(evidence["visual_metadata"]),
+        "final_output": [
+            {key: item[key] for key in ("exists", "bytes", "mtime_ns") if key in item}
+            for item in evidence["final_output"]["candidates"]
+        ],
+    }
+
+
+def _effective_config(config: Mapping[str, Any] | None = None) -> dict[str, Any]:
+    source = dict(DEFAULT_CONFIG)
+    if config:
+        source.update(dict(config))
+        if not config.get("mimo_qc_model"):
+            source["mimo_qc_model"] = (
+                config.get("mimo_video_model")
+                or config.get("mimo_model")
+                or source["mimo_qc_model"]
+            )
+    # MIMO_QC_MODEL is intentionally read at call time for embedded/CLI tests and
+    # long-running agent processes whose environment may be adjusted between runs.
+    if os.environ.get("MIMO_QC_MODEL") and not (config and config.get("mimo_qc_model")):
+        source["mimo_qc_model"] = os.environ["MIMO_QC_MODEL"]
+    return source
+
+
+def safe_mimo_config(config: Mapping[str, Any] | None = None) -> dict[str, Any]:
+    """Return non-secret settings suitable for persisted report metadata."""
+    source = _effective_config(config)
+    keep = (
+        "api_provider",
+        "mimo_api_url",
+        "mimo_api_url_source",
+        "mimo_video_api_url",
+        "mimo_video_api_url_source",
+        "mimo_qc_model",
+        "mimo_qc_model_source",
+        "mimo_model",
+        "mimo_model_source",
+        "mimo_video_model",
+        "mimo_video_model_source",
+        "mimo_disable_thinking",
+        "mimo_disable_thinking_source",
+        "mimo_media_resolution",
+        "mimo_media_resolution_source",
+    )
+    safe = {key: source[key] for key in keep}
+    safe["model"] = (
+        source["mimo_qc_model"] or source["mimo_video_model"] or source["mimo_model"]
+    )
+    key_present = bool(
+        source.get("mimo_video_api_key")
+        or source.get("mimo_api_key")
+        or source.get("api_key")
+    )
+    safe = qc_contract.redact_secrets(safe)
+    safe["key_present"] = key_present
+    return safe