Przejdź do treści
Biblioteka skilli
Marketing i treści · Konwersja i formaty

talk-clipper

/talk-clipper

Tnie nagranie webinaru lub panelu na klipy tematyczne przy ciszach, z napisami i plikami .srt dla każdego fragmentu.

Licencja
MIT
Ostatnia zmiana repozytorium
30.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
14
Skrypty
7
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 30.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • 7 skryptów w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: scripts/config.py, scripts/cues.py, scripts/dry.py, scripts/index.py, scripts/probe.py, scripts/render.py, scripts/transcribe.py

Co robi i kiedy

Tnie nagranie webinaru lub panelu na klipy tematyczne przy ciszach, z napisami i plikami .srt dla każdego fragmentu.

Wyzwalacze z opisu

clips from the webinarcut the recording into clipspull Xmake shorts from this callcaption and cut this panel videocortes do webinarclipes da gravação
Oryginalny opis (EN)

Cuts a long webinar, panel or call recording into topic clips per speaker, with every cut landed on the silence between words, burned-in captions and an identification lower third, plus an .srt per clip. Use when the user asks for "clips from the webinar", "cut the recording into clips", "pull X's answers by topic", "make shorts from this call", "caption and cut this panel video", "cortes do webinar", "clipes da gravação", or hands over a one-hour recording asking for pieces for LinkedIn, Reels or YouTube.

Jak działa

  1. Flow
  2. Prerequisites
  3. The decisions that make the clip good
  4. Three ffmpeg traps this code already works around
  5. Where things live
  6. Config notes
  7. Adapting to your recording
  8. Two things to always check
  9. Swapping the transcription provider
Sekcje z nagłówków SKILL.md, w oryginale · 159 linii, 1 223 słów
Podgląd SKILL.md
---
name: talk-clipper
description: Cuts a long webinar, panel or call recording into topic clips per speaker, with every cut landed on the silence between words, burned-in captions and an identification lower third, plus an .srt per clip. Use when the user asks for "clips from the webinar", "cut the recording into clips", "pull X's answers by topic", "make shorts from this call", "caption and cut this panel video", "cortes do webinar", "clipes da gravação", or hands over a one-hour recording asking for pieces for LinkedIn, Reels or YouTube.
---

# talk-clipper

Turns a one-hour recording into 30 to 90 second clips, one per topic, ready for
the feed. Everything runs locally with ffmpeg and Pillow, except the transcription.

What each clip gets: a 1080p MP4 with the shared screen full bleed, the speaker's
camera in a PiP in the corner, large burned-in captions at the bottom, a lower
third with name and role in the first seconds, audio normalized to -16 LUFS, and
an `.srt` next to it for upload.

## Flow

```bash
cp config.example.json config.json     # point at the video, name the speakers, tune the layout
cp plan.example.json plan.json

python3 scripts/transcribe.py          # audio -> scribe.json (per-word timestamps + diarization)
python3 scripts/index.py               # -> _work/speakers.txt and _work/sentences.txt
# pick the topics by reading sentences.txt, fill plan.json with the in/out pairs
python3 scripts/dry.py                 # review cuts and captions in the terminal, no render
python3 scripts/render.py              # render everything
python3 scripts/render.py 3_analogy    # render only what matches the filter
```

`scripts/probe.py 130 900` grabs frames to measure the recording's layout.

**Working outside the skill folder.** Every path in the config (`video`,
`workdir`, `outdir`) resolves relative to the config file, and `plan.json` is read
from the config's folder. So a project folder with its own `config.json` and
`plan.json` works without touching the skill:

```bash
cd my_project
python3 <skill>/scripts/transcribe.py config.json      # positional config
python3 <skill>/scripts/index.py config.json           # positional config
python3 <skill>/scripts/dry.py --config config.json
python3 <skill>/scripts/render.py --config config.json
python3 <skill>/scripts/probe.py --config config.json --grid 12
```

## Prerequisites

- `ffmpeg` and `ffprobe` (`brew install ffmpeg`)
- Python 3 with `pillow`, `numpy`, `requests`
- `ELEVENLABS_API_KEY` in the environment (only for the transcription step)
- A TTF font. Without config it uses Manrope SemiBold (captions, names) and
  IBM Plex Mono Medium (role) from `../captions/assets/fonts/` (shipped in this
  repo with their OFL licenses), then system installs, then Arial/DejaVu.
- Default colors are the repo palette: Ink card and padding, Field text, Slate
  role, Cobalt card edge (`theme.bar`), Beacon only for the highlighted terms.

## The decisions that make the clip good

**1. Per-word timestamps, not per-sentence.** ElevenLabs Scribe with diarization
(`timestamps_granularity=word`). Local whisper gives per-word timestamps with
`-ml 1` but does not diarize, and transcripts from meeting-notes services often
come with an offset relative to the video. The cut needs the silence between two
specific words, not the middle of a sentence.

**2. The cut lands on the silence, and the speech gets a loose edge.** `snap()`
finds the word closest to the requested time and returns four numbers: the video
cut (with slack proportional to the real gap) and the speech interval (no slack,
which is what feeds the captions). Two corrections that only show up when you
watch: the cut picks up the loose conjunction of the next sentence ("...the
other one. And"), so it steps back one token when the last word is a conjunction
after a period; and the cut lands right after a glued article ("the | second
trick"), so it pulls in the little word of up to 3 letters that sits less than
0.22s before.

**3. Caption grouping by dynamic programming, not greedy.** Filling the line up to
the limit splits expressions in the middle and leaves orphan words on screen. The
DP in `cues.py` minimizes a cost that adds distance from the ideal length, a
penalty for breaking away from punctuation and a penalty for short cues.
Expressions in `lexicon.locked` and terms in `lexicon.highlight` become forbidden
boundaries: the DP cannot cut inside them.

**4. Captions are drawn as RGBA PNGs, not by an ffmpeg filter.** Homebrew's ffmpeg
usually ships without `libass` and without `drawtext`. Drawing with Pillow and
composing with `overlay` gives, for free, control over the outline, a locked line
width (the line never runs into the PiP) and painting a term in the accent color
mid-sentence.

**5. Large captions at the bottom, not inside the little box.** A first version
centered the captions inside the camera PiP, under the face. It does not read in a
phone feed. What works is a large left-aligned font at the bottom, with
`caption.max_width` stopping the line before it reaches the PiP. While the lower
third is on screen the captions rise to `caption.bottom_raised`.

## Three ffmpeg traps this code already works around

1. `scale` to a non-proportional size leaves the **SAR different from 1**, and the
   next overlay delivers a frame with an odd height. x264 dies with "height not
   divisible by 2 / Invalid argument" without ever mentioning SAR. **Always
   `setsar=1` after `scale`+`pad`.**
2. `crop` with an odd offset or height in yuv420p is also Invalid argument. Round
   everything to even.
3. A conditional overlay is `enable='between(t,a,b)'`, not `-ss` per layer. One
   overlay per cue, chained.

## Where things live

| File | Role |
|---|---|
| `config.json` | layout, colors, font, lexicon, speaker to name and role map |
| `plan.json` | one item per clip: speaker, slug, in and out in seconds of the original |
| `scripts/config.py` | merges with the defaults, resolves font and color |
| `scripts/transcribe.py` | video -> `_work/audio.mp3` -> `_work/scribe.json` |
| `scripts/index.py` | `scribe.json` -> `speakers.txt` + `sentences.txt` |
| `scripts/cues.py` | words -> caption cues (DP) |
| `scripts/render.py` | cut, composition, captions, card, `.srt` |
| `scripts/dry.py` | text review, no render |
| `scripts/probe.py` | frames to measure the layout and check the detection |

## Config notes

- `language_code` goes to Scribe and picks the per-language defaults: `eng` (or
  `en`) and `por` (or `pt`) ship with lists of orphan words (conjunctions and
  articles a cut must not end on) and a regex of hesitation fillers the captions
  drop. Any other code falls back to the English lists. Override with
  `lexicon.orphans` and `lexicon.fillers`. The built-in default is `por`; the
  example config sets `eng`.
- `num_speakers` is a hint for diarization.
- `speakers` maps each `speaker_id` from `speakers.txt` to `name` and `role`.
- `theme.logo` is an optional PNG drawn on the card after a divider.
- `lexicon.fix` maps a lowercase word to its right form, applied before grouping.

## Adapting to your recording

The default assumes a 1920x1080 call recording with a composite layout: shared
content on the left, camera tile on the right. For another layout:

1. `python3 scripts/probe.py --grid 12` and open the frames.
2. Measure the camera tile rectangle and put it in `pip.source_crop`
   (`[width, height, x, y]`).
3. `share_detect.split_x` is where the content area ends. `share_box()` decides
   between `slide_pip` and `talking_head` by checking whether there is picture
   outside the tile rectangle in the right strip.
4. If the recording is talking head only, `pip.enabled: false`.

**The layout changes during the recording.** Q&A stretches often come without
screen sharing. That is why detection runs per clip, sampling three instants.

## Two things to always check

- **Diarization gets authorship wrong on short and overlapping speech.** It gives
  another person's answer to the main speaker. Confirm in the video, by the name
  tag on the camera tile, before closing `plan.json`.
- **Proper names and acronyms come out wrong in the transcript.** Run `dry.py`,
  read the captions, and send each error to `lexicon.fix`.

## Swapping the transcription provider

Only `transcribe.py` talks to a service. Any provider works as long as it writes
the same `_work/scribe.json`:
`{"words": [{"type": "word", "text", "start", "end", "speaker_id"}]}` with times
in seconds of the original video. Entries whose `type` is not `word` (spacing,
audio events) are ignored.
Pliki w paczce (14)
  • .gitignore 1 KB
  • LICENSE 1 KB
  • README.md 3 KB
  • SKILL.md 8 KB
  • TESTED.md 4 KB
  • config.example.json 1 KB
  • plan.example.json 1 KB
  • scripts/config.py 5 KB
  • scripts/cues.py 4 KB
  • scripts/dry.py 1 KB
  • scripts/index.py 3 KB
  • scripts/probe.py 2 KB
  • scripts/render.py 14 KB
  • scripts/transcribe.py 2 KB

Wersje

W bazie nie ma innych skilli o nazwie talk-clipper.

Migawka bazy z 13.11.2026 · wersja paczki cda623e8eeab (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100amagi-clipper
    Wycina z długiego nagrania podcastu lub webinaru krótkie pionowe klipy z podpisami słowo po słowie, bez klucza API.
  • 100webinar-to-highlight-clips
    Tnie długi webinar lub nagranie demo na krótkie klipy do mediów społecznościowych, wybierając momenty z transkrypcji, np. hak lub mocną odpowiedź.
  • 100video-to-shorts-skill
    Zamienia długie wideo w pionowe klipy do TikToka, Reels i Shorts, ocenia każdy moment i publikuje je na wielu kontach.
  • 100create-post-clips
    Zamienia długie wideo (link YouTube, plik lokalny lub z biblioteki Marky) w 2 do 5 krótkich pionowych klipów 9:16 z napisami, opisuje je głosem marki i planuje publikację po akceptacji.
  • 100youtube-shorts
    Zamienia długie nagranie lub transmisję w markowe Shorts: wybiera klipy, tnie je, dodaje napisy, logo, okładkę i podpis.
  • 100clipyyy
    Zamienia długie wideo, podcast lub link z YouTube w krótkie pionowe klipy z napisami przez CLI clipyyy.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.