Skip to content

zenstory-ai/video-recap-skills / skills/video-recap

video-recap

Verified

把一段或多集视频做成带画框字幕的中文解说成片或纯原声高光短片。用户提供 .mp4 / .mov / .mkv / .webm,要求做影视解说、短剧二创、加旁白配音、跨集混剪或导出剪映草稿时使用;串联完成看片识台词、定主线与留原声、按台词停顿切镜头、写词检查、TTS 配音与混音加字幕。触发词:视频解说、影视解说、视频旁白、生成解说、视频 recap、video recap、voiceover、narration、recap。

FileKindSize
SKILL.mdskill md18.4 KB
assets/dashboard/app.jsscript16.2 KB
assets/dashboard/index.htmlother867 B
assets/dashboard/styles.cssother22.6 KB
assets/dashboard/tokens.cssother8.9 KB
assets/dashboard/views.jsscript31.4 KB
references/audio-modes.mdmarkdown3.6 KB
references/config-playbook.mdmarkdown8.1 KB
references/creative-editing-playbook.mdmarkdown12.3 KB
references/data-schema.mdmarkdown34.6 KB
references/index-tts.mdmarkdown2.1 KB
references/jianying/LICENSE.duo-videoother1.0 KB
references/jianying/SOURCE.mdmarkdown703 B
references/jianying/empty_draft_meta_info.jsonconfig1.7 KB
references/jianying/empty_jy_material_video.jsonconfig1.8 KB
references/jianying/empty_jy_meta_material_value.jsonconfig358 B
references/jianying/empty_jy_project_info.jsonconfig3.6 KB
references/jianying/empty_jy_segment.jsonconfig1.3 KB
references/jianying/empty_jy_text_styles.jsonconfig440 B
references/jianying/empty_yj_material_audio.jsonconfig865 B
references/jianying/empty_yj_material_text.jsonconfig2.4 KB
references/packaging.mdmarkdown6.8 KB
references/promotional-copy.mdmarkdown4.1 KB
references/prompt-templates.mdmarkdown2.0 KB
references/research-guide.mdmarkdown2.7 KB
references/resource-library.mdmarkdown12.1 KB
references/shot-review.mdmarkdown4.8 KB
scripts/agent_text.pyscript2.7 KB
scripts/artifacts.pyscript972 B
scripts/asr.pyscript12.5 KB
scripts/asr_timing_evidence.pyscript4.2 KB
scripts/assemble.pyscript31.0 KB
scripts/assemble_constants.pyscript894 B
scripts/assembly_contract.pyscript10.3 KB
scripts/assembly_settings.pyscript3.8 KB
scripts/audio_automation.pyscript6.6 KB
scripts/audio_mix.pyscript18.5 KB
scripts/briefing/__init__.pyscript101 B
scripts/briefing/builder.pyscript31.1 KB
scripts/briefing/context.pyscript6.1 KB
scripts/briefing/timeline.pyscript23.0 KB
scripts/codec_peak.pyscript5.1 KB
scripts/cut.pyscript148 B
scripts/cut_cli.pyscript12.4 KB
scripts/cut_contract.pyscript13.3 KB
scripts/cut_qc.pyscript1.9 KB
scripts/cut_render.pyscript13.2 KB
scripts/dashboard/__init__.pyscript159 B
scripts/dashboard/data.pyscript24.6 KB
scripts/dashboard/io.pyscript7.1 KB
scripts/dashboard/runs.pyscript21.8 KB
scripts/dashboard/templates.pyscript9.6 KB
scripts/dashboard_server.pyscript9.3 KB
scripts/detect.pyscript22.2 KB
scripts/doctor.pyexecutablescript12.9 KB
scripts/entry_suggestion.pyscript4.6 KB
scripts/export_jianying.pyscript5.6 KB
scripts/extract.pyscript2.5 KB
scripts/final_qc.pyscript19.0 KB
scripts/frame_grid.pyscript10.6 KB
scripts/jianying/__init__.pyscript49 B
scripts/jianying/builders.pyscript11.3 KB
scripts/jianying/model.pyscript2.7 KB
scripts/jianying/optional.pyscript1012 B
scripts/jianying/schema.pyscript2.5 KB
scripts/jianying/templates.pyscript1.0 KB
scripts/jianying/timeline_contract.pyscript5.8 KB
scripts/jianying/tracks.pyscript2.0 KB
scripts/jianying/writer.pyscript7.8 KB
scripts/lib.pyscript29.6 KB
scripts/library.pyscript31.1 KB
scripts/lint_summary.pyscript5.0 KB
scripts/loudness.pyscript14.7 KB
scripts/materials.pyscript22.1 KB
scripts/media.pyscript18.8 KB
scripts/narration_audio.pyscript13.5 KB
scripts/narration_lint.pyscript24.1 KB
scripts/narrative_selection.pyscript8.9 KB
scripts/packaging.pyscript6.1 KB
scripts/packaging_fonts.pyscript12.0 KB
scripts/packaging_plates.pyscript31.2 KB
scripts/packaging_studio.pyscript34.1 KB
scripts/providers/__init__.pyscript72 B
scripts/providers/fish_audio.pyscript3.1 KB
scripts/providers/index_tts.pyscript8.8 KB
scripts/recap.pyscript183 B
scripts/recap_cli.pyscript6.9 KB
scripts/recap_inspect.pyscript16.5 KB
scripts/recap_runner.pyscript22.0 KB
scripts/recap_runtime.pyscript11.8 KB
scripts/recap_source.pyscript1.8 KB
scripts/recap_stage_qc.pyscript2.7 KB
scripts/recap_timeline.pyscript7.7 KB
scripts/render_preflight.pyscript1.7 KB
scripts/resources/__init__.pyscript200 B
scripts/resources/lock.pyscript6.8 KB
scripts/resources/project_binding.pyscript16.1 KB
scripts/sentence_boundaries.pyscript28.8 KB
scripts/sentence_gate.pyscript8.6 KB
scripts/sfx_mix.pyscript14.6 KB
scripts/shot_review.pyscript18.9 KB
scripts/source_subtitles.pyscript7.2 KB
scripts/speech_ownership.pyscript9.3 KB
scripts/storyboard.pyscript21.8 KB
scripts/subtitles/__init__.pyscript56 B
scripts/subtitles/core.pyscript19.0 KB
scripts/subtitles/render.pyscript8.0 KB
scripts/timeline.pyscript8.2 KB
scripts/timeline_emit.pyscript5.4 KB
scripts/tts_audio.pyscript9.6 KB
scripts/tts_cache.pyscript4.5 KB
scripts/understand.pyscript171 B
scripts/understanding_brief.pyscript6.3 KB
scripts/understanding_cache.pyscript8.0 KB
scripts/understanding_runner.pyscript9.8 KB
scripts/understanding_storyboard.pyscript11.9 KB
scripts/validate.pyscript5.7 KB
scripts/visual_render.pyscript10.1 KB
scripts/vlm.pyscript16.4 KB
scripts/voiceover.pyscript28.0 KB

scripts/narrative_selection.py

View on GitHub
"""Validate explicitly required source spans in a normalized constant-speed cut plan.

This checks source-span selection and ordering only.  It does not claim that the
rendered mix is audible or that the declared content is semantically correct.
"""

from __future__ import annotations

import math
import os
from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from typing import TypeGuard


_EPSILON = 1e-9


def _invalid(message):
    return {
        "selection_status": "BLOCK",
        "nodes": [],
        "findings": [
            {
                "code": "REQUIRED_EVIDENCE_INVALID",
                "message": message,
            }
        ],
        "semantic_status": "NOT_CHECKED",
    }


def _realpath(value, *, require_absolute=True):
    if not isinstance(value, str) or (require_absolute and not os.path.isabs(value)):
        raise ValueError("required evidence source must be an absolute path")
    return os.path.realpath(value)


def _finite_nonnegative(value: object) -> TypeGuard[int | float]:
    return (
        isinstance(value, (int, float))
        and not isinstance(value, bool)
        and math.isfinite(value)
        and value >= 0
    )


def _validate_contract(contract):
    if not isinstance(contract, dict):
        raise ValueError("required_evidence must be an object")
    nodes = contract.get("nodes")
    if not isinstance(nodes, list) or not nodes:
        raise ValueError("required_evidence.nodes must be a non-empty array")
    if not isinstance(contract.get("before"), list):
        raise ValueError("required_evidence.before must be an array")

    normalized = []
    ids = set()
    for index, node in enumerate(nodes, 1):
        if not isinstance(node, dict):
            raise ValueError(f"required evidence node #{index} must be an object")
        node_id = node.get("id")
        if not isinstance(node_id, str) or not node_id.strip() or node_id in ids:
            raise ValueError("required evidence node ids must be unique non-empty strings")
        ids.add(node_id)
        track = node.get("track")
        if track not in {"audio", "video"}:
            raise ValueError(f"required evidence node {node_id} has invalid track")
        content = node.get("content")
        if not isinstance(content, str) or not content.strip():
            raise ValueError(f"required evidence node {node_id} has empty content")
        start, end = node.get("start"), node.get("end")
        if not (_finite_nonnegative(start) and _finite_nonnegative(end) and end > start):
            raise ValueError(f"required evidence node {node_id} has invalid start/end")
        source_id = node.get("source_id")
        if "source_id" in node and (
            not isinstance(source_id, str) or not source_id.strip()
        ):
            raise ValueError(f"required evidence node {node_id} has invalid source_id")

        item = {
            "id": node_id,
            "track": track,
            "content": content,
            "source": _realpath(node.get("source")),
            "start": start,
            "end": end,
        }
        if "source_id" in node:
            item["source_id"] = source_id
        normalized.append(item)

    edges = []
    for edge in contract["before"]:
        if (
            not isinstance(edge, list)
            or len(edge) != 2
            or edge[0] not in ids
            or edge[1] not in ids
            or edge[0] == edge[1]
        ):
            raise ValueError("required_evidence.before contains an invalid node pair")
        edges.append((edge[0], edge[1]))
    return normalized, edges


def _same(value, expected):
    return abs(value - expected) <= _EPSILON


def _matching_segments(node, validated_plan, input_video):
    segments = []
    for clip in validated_plan["clips"]:
        source = _realpath(
            os.fspath(clip.get("source_path", input_video)), require_absolute=False
        )
        if source != node["source"]:
            continue
        if "source_id" in node and clip.get("source_id") != node["source_id"]:
            continue

        clip_start = clip["source_start"]
        clip_end = clip["source_end"]
        start = max(node["start"], clip_start)
        end = min(node["end"], clip_end)
        if end <= start:
            continue
        output_start = clip["output_start"] + start - clip_start
        segments.append(
            {
                "source_id": clip.get("source_id"),
                "source_start": start,
                "source_end": end,
                "output_start": output_start,
                "output_end": output_start + end - start,
            }
        )
    return sorted(segments, key=lambda item: item["output_start"])


def _occurrences(node, validated_plan, input_video):
    segments = _matching_segments(node, validated_plan, input_video)
    occurrences = []
    for index, segment in enumerate(segments):
        if not _same(segment["source_start"], node["start"]):
            continue
        source_cursor = segment["source_end"]
        output_cursor = segment["output_end"]
        for following in segments[index + 1 :]:
            if source_cursor >= node["end"] - _EPSILON:
                break
            if (
                following["source_id"] == segment["source_id"]
                and _same(following["source_start"], source_cursor)
                and _same(following["output_start"], output_cursor)
            ):
                source_cursor = following["source_end"]
                output_cursor = following["output_end"]
        if _same(source_cursor, node["end"]):
            occurrences.append(
                {"start": segment["output_start"], "end": output_cursor}
            )
    return occurrences


def check_required_evidence(contract, validated_plan, *, input_video, source_audio) -> dict:
    """Return bounded source-selection QC for a declared required-evidence contract.

    `source_audio(realpath) -> bool` is consulted only for audio nodes, after the contract
    has been validated, so callers never pre-walk the raw contract to decide whether to probe."""
    try:
        nodes, edges = _validate_contract(contract)
    except (AttributeError, KeyError, TypeError, ValueError) as exc:
        return _invalid(str(exc))

    findings = []
    occurrences_by_id = {}
    fragment_starts_by_id = {}
    report_nodes = []
    for node in nodes:
        if node["track"] == "audio" and source_audio(node["source"]) is not True:
            occurrences = []
            fragment_starts = []
            findings.append(
                {
                    "code": "REQUIRED_EVIDENCE_AUDIO_UNAVAILABLE",
                    "message": (
                        f"audio node {node['id']} requires a source with an audio stream"
                    ),
                    "node_id": node["id"],
                }
            )
        else:
            fragment_starts = [
                segment["output_start"]
                for segment in _matching_segments(node, validated_plan, input_video)
            ]
            occurrences = _occurrences(node, validated_plan, input_video)
            if not occurrences:
                findings.append(
                    {
                        "code": "REQUIRED_EVIDENCE_MISSING",
                        "message": (
                            f"node {node['id']} is not retained as one continuous source "
                            "and output span"
                        ),
                        "node_id": node["id"],
                    }
                )
        occurrences_by_id[node["id"]] = occurrences
        fragment_starts_by_id[node["id"]] = fragment_starts
        report_nodes.append({**node, "occurrences": occurrences})

    for premise_id, result_id in edges:
        premise_occurrences = occurrences_by_id[premise_id]
        result_fragment_starts = fragment_starts_by_id[result_id]
        unpreceded_starts = [
            result_start
            for result_start in result_fragment_starts
            if not any(
                premise["end"] <= result_start + _EPSILON
                for premise in premise_occurrences
            )
        ]
        ordered = bool(result_fragment_starts) and not unpreceded_starts
        if not ordered:
            detail = (
                f"; earliest unpreceded output start={min(unpreceded_starts):.9g}s"
                if unpreceded_starts
                else "; no matching result fragment was retained"
            )
            findings.append(
                {
                    "code": "REQUIRED_EVIDENCE_ORDER",
                    "message": (
                        f"every retained fragment of {result_id} must follow a complete "
                        f"occurrence of {premise_id}{detail}"
                    ),
                    "node_id": result_id,
                }
            )

    return {
        "selection_status": "BLOCK" if findings else "PASS",
        "nodes": report_nodes,
        "findings": findings,
        "semantic_status": "NOT_CHECKED",
    }
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 198kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 196kUpdated Claude CodeCodexVerifiedInstall