@oh-story/dsh 0.1.10 → 0.1.12

package/lib/video-recap/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/lib/video-recap/skills/video-recap/scripts/qc/__init__.py

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

package/lib/video-recap/skills/video-recap/scripts/{mimo_qc_client.py → qc/mimo_client.py}

@@ -4,7 +4,7 @@ import importlib.util
 from pathlib import Path
 
 _SPEC = importlib.util.spec_from_file_location(
-    "video_recap_mimo_qc_lib", Path(__file__).with_name("lib.py")
+    "video_recap_mimo_qc_lib", Path(__file__).resolve().parents[1] / "lib.py"
 )
 _LIB = importlib.util.module_from_spec(_SPEC)
 _SPEC.loader.exec_module(_LIB)

package/lib/video-recap/skills/video-recap/scripts/{mimo_qc_evidence.py → qc/mimo_evidence.py}

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import hashlib
 import json
 import os
 from pathlib import Path
@@ -10,7 +9,7 @@ from typing import Any
 from collections.abc import Mapping, Sequence
 
 import qc_contract
-from mimo_qc_client import DEFAULT_CONFIG
+from qc.mimo_client import DEFAULT_CONFIG
 
 _JSON_ARTIFACTS = (
     "narration.json",
@@ -48,14 +47,6 @@ _OPTIONAL_VISUAL_METADATA = (
 )
 
 
-def _stable_json(value: Any) -> str:
-    return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
-
-
-def _fingerprint_value(value: Any) -> str:
-    return hashlib.sha256(_stable_json(value).encode("utf-8")).hexdigest()
-
-
 def _load_json(path: Path) -> Any:
     return json.loads(path.read_text(encoding="utf-8"))
 
@@ -75,7 +66,7 @@ def _summarize(
 ) -> Any:
     """Keep request/report evidence bounded while retaining useful structure."""
     if depth >= 4:
-        return {"type": type(value).__name__, "fingerprint": _fingerprint_value(value)}
+        return {"type": type(value).__name__, "omitted": True}
     if isinstance(value, Mapping):
         out = {
             str(key): _summarize(
@@ -110,11 +101,12 @@ def _collect_file(work_dir: Path, name: str) -> dict[str, Any] | None:
         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": path.stat().st_size,
-        "fingerprint": qc_contract.artifact_fingerprint(path),
+        "bytes": stat.st_size,
+        "mtime_ns": stat.st_mtime_ns,
         "summary": summary,
     }
 
@@ -128,21 +120,12 @@ def _collect_multi_source_asr(work_dir: Path) -> dict[str, Any]:
     manifest_path = work_dir / "multi_source_manifest.json"
     if not manifest_path.is_file():
         return {}
-    root = work_dir.resolve(strict=False)
     collected = {}
     for source in _load_json(manifest_path)["sources"]:
-        relative_dir = source["source_work_dir"]
-        source_dir = (root / relative_dir).resolve(strict=False)
-        if not source_dir.is_relative_to(root):
-            continue
-        name = _first_existing(source_dir, _SOURCE_ASR_ARTIFACTS)
+        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:
-            evidence_path = (source_dir / name).resolve(strict=False)
-            if not evidence_path.is_relative_to(root):
-                continue
-            collected[source["source_id"]] = _collect_file(
-                root, str(evidence_path.relative_to(root))
-            )
+            collected[source["source_id"]] = _collect_file(work_dir, f"{relative_dir}/{name}")
     return collected
 
 
@@ -151,55 +134,38 @@ def _resolve_candidate(work_dir: Path, candidate: str | Path) -> Path:
     return path if path.is_absolute() else work_dir / path
 
 
-def _final_output_candidates(
+def _final_output_path(
     work_dir: Path, final_output: str | Path | None
-) -> list[tuple[Path, str]]:
-    raw: list[str | Path] = []
-    if final_output:
-        raw.append(final_output)
-    manifest_path = work_dir / "assembly_manifest.json"
-    if manifest_path.is_file():
-        raw.append(_load_json(manifest_path)["final_output"])
-    raw.extend(("output.mp4", "recap.mp4", "final.mp4"))
-    seen: set[str] = set()
-    result = []
-    for item in raw:
-        path = _resolve_candidate(work_dir, item)
-        key = str(path.resolve(strict=False))
-        if key not in seen:
-            seen.add(key)
-            result.append((path, str(item)))
-    return result
+) -> 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]:
-    outputs = []
-    for path, display in _final_output_candidates(work_dir, final_output):
-        item: dict[str, Any] = {"path": display, "exists": path.is_file()}
-        if item["exists"]:
-            item.update(
-                {
-                    "bytes": path.stat().st_size,
-                    "fingerprint": qc_contract.artifact_fingerprint(path),
-                }
-            )
-        outputs.append(item)
-    return {"candidates": outputs}
+    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:
-    return next(
-        (
-            path
-            for path, _display in _final_output_candidates(work_dir, final_output)
-            if path.is_file()
-        ),
-        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(
@@ -243,7 +209,6 @@ def collect_evidence(
     }
     if not evidence["source_asr"]:
         evidence["source_asr"] = _collect_multi_source_asr(root)
-    evidence["fingerprint"] = _fingerprint_value(_cache_evidence(evidence))
     # 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)
@@ -251,19 +216,21 @@ def collect_evidence(
 
 def _cache_file_group(group: Mapping[str, Any]) -> dict[str, Any]:
     return {
-        name: {key: item[key] for key in ("kind", "bytes", "fingerprint")}
+        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", "fingerprint") if key in item}
+            {key: item[key] for key in ("exists", "bytes", "mtime_ns") if key in item}
             for item in evidence["final_output"]["candidates"]
         ],
     }

package/lib/video-recap/skills/video-recap/scripts/{mimo_qc_observations.py → qc/mimo_observations.py}

@@ -8,9 +8,9 @@ from typing import Any
 from collections.abc import Mapping
 
 import qc_contract
-from mimo_qc_evidence import _fingerprint_value, _summarize, safe_mimo_config
-from mimo_qc_payload import _strip_json_fence
-from mimo_qc_contract import (
+from qc.mimo_evidence import _summarize, safe_mimo_config
+from qc.mimo_payload import _strip_json_fence
+from qc.mimo_contract import (
     ARTIFACT_NAME,
     DEFAULT_STAGE,
     MAX_MESSAGE_CHARS,
@@ -146,10 +146,6 @@ def normalize_observations(
             **(raw_evidence if isinstance(raw_evidence, Mapping) else {}),
             "model": model_used,
             "config": cfg,
-            "fingerprint": {
-                "evidence": payload["evidence_fingerprint"],
-                "observation": _fingerprint_value(observation),
-            },
         }
         location = obs.get("location")
         findings.append(
@@ -172,10 +168,6 @@ def normalize_observations(
                 location=location if isinstance(location, Mapping) else {},
                 evidence=evidence,
                 model_used=model_used,
-                artifact_fingerprints={
-                    "payload": payload["payload_fingerprint"],
-                    "evidence": payload["evidence_fingerprint"],
-                },
                 next_action="human_review",
                 decision_reason=message,
             )

package/lib/video-recap/skills/video-recap/scripts/{mimo_qc_payload.py → qc/mimo_payload.py}

@@ -6,8 +6,8 @@ import json
 from typing import Any
 from collections.abc import Mapping, Sequence
 
-from mimo_qc_evidence import _fingerprint_value, safe_mimo_config
-from mimo_qc_contract import ARTIFACT_NAME, DEFAULT_STAGE
+from qc.mimo_evidence import safe_mimo_config
+from qc.mimo_contract import ARTIFACT_NAME, DEFAULT_STAGE
 
 
 def _semantic_evidence(evidence: Mapping[str, Any], *, stage: str) -> dict[str, Any]:
@@ -16,12 +16,11 @@ def _semantic_evidence(evidence: Mapping[str, Any], *, stage: str) -> dict[str,
     ``collect_evidence`` already bounds every artifact independently.  The additional
     summarization here therefore needs enough depth to retain the narration/ASR/TTS
     scalars nested inside those summaries.  A shallow second pass used to replace the
-    values with fingerprints, which made live QC invent missing-script and failed-TTS
+    values with opaque placeholders, which made live QC invent missing-script and failed-TTS
     findings from evidence it could no longer read.
     """
     semantic = dict(evidence)
     semantic.pop("work_dir", None)
-    semantic.pop("fingerprint", None)
     semantic["evidence_roles"] = {
         "narration.json": (
             "Planned recap voiceover on the OUTPUT timeline; judge its factual and temporal "
@@ -104,7 +103,7 @@ def build_payload(
         "instructions": (
             "你是 video-recap 的建议性质量审阅器。结合解说、剪辑计划、字幕/ASR、TTS、"
             "组装元数据和抽样画面，指出语义或审美问题。只返回主观观察，不做自动修复，"
-            "只根据可见的实际字段判断，不得从文件字节数、指纹、截断或省略标记推断内容缺失；"
+            "只根据可见的实际字段判断，不得从文件字节数、截断或省略标记推断内容缺失；"
             "source_asr 是源素材原声证据，不是生成后 TTS 的逐字转录；generated_subtitles 是本轮生成字幕，"
             "二者角色不可混淆，解说改写与源台词不一致本身不是问题；"
             "空 failures 表示没有失败，storyboard 的 labels_burned 仅表示诊断图上的时间标签，"
@@ -131,9 +130,7 @@ def build_payload(
             '"semantic|aesthetic|sampled","evidence":{...}}]}。最多 12 条。'
         ),
         "evidence": _semantic_evidence(evidence, stage=stage),
-        "evidence_fingerprint": evidence["fingerprint"],
     }
-    payload["payload_fingerprint"] = _fingerprint_value(payload)
     return payload