ffmpeg-skill 2.2.0 → 2.2.1

package/docs/contract.md

@@ -21,7 +21,7 @@ The contract is derived from the code that runs, not maintained beside it:
 | Field | Meaning | Changes when |
 |---|---|---|
 | `contract_version` | shape of this document (`1.0`) | a key is renamed, removed or changes meaning |
-| `skill.version` | the npm / package.json version (`2.2.0`) | any release |
+| `skill.version` | the npm / package.json version (`2.2.1`) | any release |
 
 A release that adds a tool or a flag keeps `contract_version`; a breaking change to the
 ToolSpec shape bumps it. Consumers pin on `contract_version` and read `skill.version`
@@ -119,7 +119,7 @@ JSON would have been rewritten for that. The flat keys, typed per tool in `outpu
   "contract_version": "1.0",
   "deprecated": [],
   "removed": [{"what": "...", "since": "1.10.0", "replacement": "...", "removed_in": "2.0.0", "where": "cli | json | mcp | behaviour"}],
-  "skill": {"id": "ffmpeg-skill", "version": "2.2.0", "execution_mode": "local", "kind": "execution",
+  "skill": {"id": "ffmpeg-skill", "version": "2.2.1", "execution_mode": "local", "kind": "execution",
             "entrypoints": {"cli": "...", "mcp": "...", "contract": "...", "doctor": "..."},
             "not_provided": ["AI reasoning", "decisions", "production plans", "project IR", "approvals", "network access", "transcription engine"]},
   "requirements": {"python": ">=3.9 (standard library only)", "ffmpeg": ">=5.0", "ffprobe": ">=5.0"},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ffmpeg-skill",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "Agent Skill that gives coding agents (Claude Code, Cursor, Codex) a local video editor: 42 FFmpeg tools with a machine-readable contract, contract-derived MCP server, FFmpeg capability detection, probe-first / verify-last workflow. Cut, join, silence removal, fit, captions and karaoke, overlays, motion graphics, HDR to SDR, LUTs, audio clean-up and typed dynamics, sync with drift correction, multicam, loudness, delivery checks, project rendering, batch. No API keys, no cloud, no dependencies.",
   "keywords": [
     "ffmpeg",

package/scripts/caption.py

@@ -1146,6 +1146,14 @@ def main() -> int:
         die(f"--track-title given {len(args.track_title)} times for {len(srt_tracks)} --srt file(s)",
             kind="input")
     args.srt = srt_tracks[0][0] if srt_tracks else None
+    # 2.2.1: the extra --srt tracks (always inputs; the first may be written by --text or
+    # --transcribe) are checked up front, every missing one named together, before any work.
+    # Dry-run plans on files earlier steps have not written yet, as join.py does.
+    missing_srt = [{"index": i, "path": p, "reason": "missing"}
+                   for i, (p, _l) in enumerate(srt_tracks) if i > 0 and not os.path.exists(p)]
+    if missing_srt and not STATE.dry_run:
+        die(f"{len(missing_srt)} SRT file(s) not found: " + ", ".join(m["path"] for m in missing_srt),
+            kind="input", problems=missing_srt)
     srt_path = args.srt
     if args.transcribe:
         if not args.input:

package/scripts/render.py

@@ -930,13 +930,30 @@ def main() -> int:
             f'{snap_spec.get("to")!r}', kind="input")
 
     # ---- clips
+    # 2.2.1: every clip source is checked before the first one is cut, and every problem is named
+    # in one refusal -- before, clip 7's missing file surfaced after clips 0-6 had been cut, and
+    # only the first of several missing sources was reported per run.
+    problems: List[Dict[str, Any]] = []
+    for i, c in enumerate(clips):
+        src = rel(c["src"])
+        if not os.path.exists(src):  # under --dry-run too: a plan for a missing file is no plan
+            problems.append({"index": i, "path": src, "reason": "missing"})
+        elif os.path.isdir(src):
+            problems.append({"index": i, "path": src, "reason": "a directory, not a file"})
+        elif os.path.getsize(src) == 0:
+            problems.append({"index": i, "path": src, "reason": "empty (0 bytes)"})
+    if problems:
+        die(f"{len(problems)} of {len(clips)} clip sources unusable: "
+            + "; ".join(f"clip {p['index']}: {p['reason']}: {p['path']}" for p in problems),
+            kind="input", problems=problems,
+            hint="fix or remove these clips in the project; nothing was cut")
+    if not STATE.dry_run:
+        for c in clips:
+            probe(rel(c["src"]))  # an unreadable source stops the run before any clip is cut
+
     parts: List[str] = []
     for i, c in enumerate(clips):
         src = rel(c["src"])
-        if not os.path.exists(src):
-            die(f"clip {i}: source not found: {src}")  # under --dry-run too: a plan for a missing file is no plan
-        if not STATE.dry_run:
-            probe(src)
         needs_cut = c.get("in") is not None or c.get("out") is not None
         part = str(work / f"clip{i:02d}{mid}")
         if needs_cut:

package/scripts/sequence.py

@@ -37,6 +37,20 @@ def natural_key(name: str) -> list:
     return [int(t) if t.isdigit() else t.lower() for t in re.split(r"(\d+)", name)]
 
 
+def _frames_after(directory: Path, pattern: str, index: int) -> list:
+    """Files in `directory` that match printf `pattern` with a number above `index`."""
+    m = re.search(r"%0?(\d*)d", pattern)
+    if not m:
+        return []
+    rx = re.compile("^" + re.escape(pattern[:m.start()]) + r"(\d+)" + re.escape(pattern[m.end():]) + "$")
+    found = []
+    for f in directory.iterdir():
+        hit = rx.match(f.name)
+        if hit and int(hit.group(1)) > index:
+            found.append((int(hit.group(1)), f))
+    return [f for _n, f in sorted(found)]
+
+
 def main() -> int:
     ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
     ap.add_argument("--dir", required=True, help="directory containing the frames")
@@ -79,6 +93,12 @@ def main() -> int:
         if not frames:
             die(f"first frame not found: {directory / (args.pattern % args.start_number)} (check --pattern / --start-number)")
         info(f"found {len(frames)} consecutive frames from index {args.start_number}")
+        # 2.2.1: frames past a gap in the numbering (one render or export step that failed) used
+        # to be dropped silently, giving a shorter video; name the gap and what was left out
+        later = _frames_after(directory, args.pattern, i)
+        if later:
+            info(f"WARNING: frame {args.pattern % i} is missing; {len(later)} later frame(s) "
+                 f"(from {later[0].name}) are NOT in the sequence -- fill the gap or rename them")
 
     frame_meta = probe(str(frames[0]))
     if not frame_meta.get("video"):