video-edit

Files (11)

• LICENSE.upstream
• SKILL.md
• brand.example.json
• pack_transcript.py · scripts/
• render.py · scripts/
• subtitles.py · scripts/
• timeline_view.py · scripts/
• transcribe.sh · scripts/
• verify.py · scripts/
• index.html · templates/endcard/
• index.html · templates/title/

SKILL.md (first lines)

# Video edit

Edit by reading, not watching. Footage becomes a word-level transcript; cuts
are decided from words and pauses; frames are pulled only where a decision
needs eyes; every render is checked by numbers and by a contact sheet. A human
makes the final pass by eye in an editor. Method adapted from
[video-use](https://github.com/browser-use/video-use) ([MIT](LICENSE.upstream)),
with local transcription instead of a paid API.

Defaults and checks follow published standards where they exist (Netflix and
BBC subtitle guides, EBU R128, ITU-R BS.1770, YouTube upload specs, Murch on
cutting); [references/standards.md](references/standards.md) lists each one
with its source, marks what is only convention, and says where the skill
applies it. Read it before changing a default.

Scripts live in `scripts/`; run them with `bash` and `python3`. `final.otio`
needs a Python with `opentimelineio`; without it the render skips that file.

## Workflow

1. **Project.** One directory per edit, for example `~/Videos/Edits/<name>/`.
   Never modify sources.
2. **Transcribe.** `bash scripts/transcribe.sh <lang> <project>/transcripts <videos...>`.
   Always pass the language; ask the user if unsure. It also measures the
   audio pauses (`<stem>.pauses`), because Whisper often runs words together.
3. **Read.** `python3 scripts/pack_transcript.py <project>/transcripts`. Each
   pause shows its `cut` time (the middle of the silence): use those as segment
   starts and ends. Add `--gap 0.25` for the tighter pace of a short. Words
   marked `(?)` need a human ear. `<REF>` marks a line that points elsewhere
   ("previous video"), `<REPEAT>` a stutter or a Whisper hallucination. Use
   `scripts/timeline_view.py` at decision points only.
4. **Plan, then ask.** Propose the cut in plain words: what stays, what goes
   and why, cards, bleeps, subtitles, length. Wait for approval before
   rendering.
5. **EDL.** Write `<project>/edl.json` (format below).
6. **Preview.** `python3 scripts/render.py <project>/edl.json --preview` writes
   `work/preview.png` in seconds: the first and last frame of every planned
   segment through the real layout (crops, panels, the caption band on a
   short). Fix crops, scrolled screens and stale panels here, not after a render.
7. **Render.** `python3 scripts/render.py <project>/edl.json`.
8. **Verify.** `python3 scripts/verify.py <project>/edl.json`, then look at
   `work/review.png` and play every `LISTEN` cut (too little quiet kept around
   it in the source, so a word or breath may be clipped). `NOTE` lines compare
   subtitle cues with the reading-speed and duration limits. Fix and
   re-render, at most 3 passes; then report what is left.
9. **Hand over.** `final.mp4` + `final.srt` (upload the SRT separately),
   `final_subs.mp4` (subtitles burned in, for social), `final.otio` (Kdenlive or
   Resolve for the pass by eye). Record decisions in `<project>/project.md`.

## EDL

```json
{
  "name": "launch-demo", "language": "en", "fps": 30, "width": 1920, "height": 1080,
  "brand": "brand.json",
  "sources": {"a": "/abs/take1.mp4", "b": "/abs/take2.mp4"},
  "segments": [
    {"card": "title", "duration": 2.5, "vars": {"title": "Launch Demo", "subtitle": "Behind the scenes", "header": "Episode 4"}},
    {"source": "a", "start": 0.0, "end": 12.4, "quote": "Today we ship...", "reason": "clean intro take"},
    {"source": "b", "start": 3.1, "end": 41.0, "quote": "Here is how...", "reason": "take 1 stumbled here"},
    {"card": "endcard", "duration": 2.5}
  ],
  "bleeps": [{"source": "b", "start": 20.06, "end": 20.41, "mask": "****"}]
}
```

Times are source seconds from the transcript; render snaps them to whole
frames. `fps` is the target rate (sources are converted). Cards are
`templates/title` (`title`, `subtitle`, `header`) and `templates/endcard`
(`url`), rendered with HyperFrames.

Optional keys (full reference in the `render.py` docstring):

- `corrections`: `[{"source", "start", "end", "text"}]` replaces the words in
  the window with `text` in the subtitles (a name Whisper misheard); `""`
  drops them (stutters). The audio is untouched.
- `jumpcut`: `{"min_pause": 0.3, "keep": 0.1, "punch": 1.12}` splits every
  media segment at pauses, keeping `keep` seconds of air on each side; `punch`
  zooms every other piece to hide the jump (panels marked `"punch": true`).

## Vertical shorts

`"format": "short"` renders 1080x1920 from 16:9 footage. Cards are not
allowed; open cold on the hook.

```json
{
  "format": "short", "fps": 25,
  "short": {"title": "DON'T START WITH DISTINCT", "subtitle": "Check the data model first",
            "highlight": ["distinct", "data model"], "caption_y": 1460},
  "views": {
    "face": [{"crop": [452, 0, 576, 720], "at": [16, 322], "width": 1040, "border": "accent", "punch": true}],
    "code": [{"crop": [40, 28, 640, 382], "at": [16, 322], "width": 1040, "border": "accent"},
             {"crop": [1060, 505, 220, 220], "at": [350, 1180], "width": 380, "shape": "circle"}]
  },
  "jumpcut": {"min_pause": 0.3, "keep": 0.1, "punch": 1.12},
  "segments": [{"source": "a", "start": 1725.86, "end": 1730.81, "view": "face"}]
}
```

- A view is a list of panels: a source `crop` (x, y, w, h in source pixels)
  placed `at` a canvas position, scaled to `width`; `rect` or `circle` (a
  webcam bubble), with an optional `border`. Measure crops on a full-size
  frame; screen recordings scroll, so check `review.png` for every segment.
- The canvas is drawn once: brand `canvas` colour and a header at
  `header_y` (default 140, below the player's mute button). With a brand
  `mark` the header is one row, the mark on the left and `title` over
  `subtitle` beside it (about 150 px tall, so panels can start at y 320);
  without one, the logo sits on a light pill above a centred title. Segments
  may override `title`, `subtitle` and `caption_y`.
- Captions are chunks of one to three words in the brand font (Black weight,
  fetched from Google Fonts into `~/.cache/video-edit/fonts`), `highlight`
  phrases in the accent colour. A chunk never spans a cut. `final.srt` keeps
  the standard cues for upload.
- The Shorts player draws over three areas of the 1080x1920 frame (measured
  on the mobile site at phone size): mute/play at the top left (about
  200x130), like/comment/share on the right (x > 960 from y 1480 down), and
  channel, Subscribe and title at the bottom (y > 1760). `verify.py` outlines
  them in red on `review.png`; keep text and code out of them. To check an

From krzysztofbury/llm-powerup, MIT.

More from krzysztofbury/llm-powerup