@kolbo-cli/kolbo-linux-x64 0.0.0-dev-202604101332 → 0.0.0-dev-202604101600

package/skills/video-production/SKILL.md

@@ -0,0 +1,152 @@
+---
+name: video-production
+description: >
+  Full-stack video production assistant. Analyzes talking head footage,
+  generates transcriptions/SRT subtitles, plans and creates motion graphics (Remotion),
+  generates B-roll images/videos, produces timeline XMLs for Premiere/DaVinci.
+  Use for: video analysis, transcription, subtitles, motion graphics, B-roll, shorts,
+  timeline XML, clip cutting, silence removal, After Effects, Premiere Pro, DaVinci Resolve.
+  Keywords: video edit, ffmpeg, remotion, after effects, premiere, davinci, shorts, subtitles,
+  motion graphics, clip, render, transcribe, xml, timeline, b-roll, talking head, analyze
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Glob
+  - Grep
+  - Agent
+  - AskUserQuestion
+  - TaskCreate
+  - TaskUpdate
+  - WebFetch
+---
+
+# Video Production — Strategy Map
+
+## Pipeline
+
+```
+Input video → Transcribe → Analyze → Plan segments
+  → Generate: Remotion compositions | B-roll | SRT subtitles
+  → Output: Premiere XML / DaVinci EDL / individual MP4s / SRT
+```
+
+## APIs & Capabilities
+
+| Service | Use |
+|---------|-----|
+| ElevenLabs Scribe | Primary transcription — word-level SRT, multilingual |
+| Claude | Content analysis, edit planning |
+| Google Gemini | Video understanding, visual analysis |
+| fal.ai (MCP) | Image & video B-roll generation |
+| Runway | Image-to-video, video-to-video |
+| FLUX / BFL | High quality still image generation |
+| ElevenLabs | TTS, voice cloning, SFX |
+| Suno | Background music generation |
+| Remotion Lambda | Cloud render motion graphics |
+
+> Load API keys from the project's `.env` file or environment variables.
+
+## Key Rules
+
+- **FFmpeg on Windows**: always copy inputs to `tempfile.mkdtemp()` first (handles spaces in paths)
+- **9:16 shorts**: blurred background + centered content — never crop the original
+- **Hebrew / RTL subtitles**: ASS format, Heebo Bold font, `\pos()` for RTL rendering
+- **Video quality standard**: `-c:v libx264 -crf 18 -c:a aac -b:a 128k`
+- **Image generation**: prefer fal MCP server over Python scripts when available
+- **Silence removal**: `silencedetect -35dB:d=0.4` → trim+concat → `atempo=1.14`
+
+## Transcription
+
+Use ElevenLabs Scribe for word-level SRT with speaker diarization:
+```python
+import requests
+
+def transcribe(audio_path, api_key, language="he"):
+    with open(audio_path, "rb") as f:
+        response = requests.post(
+            "https://api.elevenlabs.io/v1/speech-to-text",
+            headers={"xi-api-key": api_key},
+            files={"file": f},
+            data={"model_id": "scribe_v1", "language_code": language,
+                  "timestamps_granularity": "word", "diarize": True}
+        )
+    return response.json()
+```
+
+## 9:16 Shorts — Blurred Background
+
+```python
+filter_complex = (
+    "[0:v]split[bg][fg];"
+    "[bg]scale=1080:1920:force_original_aspect_ratio=increase,"
+    "crop=1080:1920,gblur=sigma=40[blurred];"
+    "[fg]scale=1080:1920:force_original_aspect_ratio=decrease,"
+    "pad=1080:1920:(ow-iw)/2:(oh-ih)/2:color=black@0[front];"
+    "[blurred][front]overlay=0:0"
+)
+```
+
+## Silence Removal
+
+```python
+import subprocess, json
+
+def detect_silence(video_path, noise_db=-35, duration=0.4):
+    result = subprocess.run([
+        "ffmpeg", "-i", video_path,
+        "-af", f"silencedetect=noise={noise_db}dB:d={duration}",
+        "-f", "null", "-"
+    ], capture_output=True, text=True)
+    # Parse silence_start/silence_end from stderr
+    ...
+```
+
+## RTL (Hebrew/Arabic) Subtitles
+
+SRT with `subtitles` filter works for basic burn. For per-word karaoke highlighting with RTL:
+
+- Each word gets its own ASS `Dialogue` line with explicit `\pos(x,y)`
+- Use PIL to measure word widths: apply `~0.74` scale factor (PIL→libass calibration)
+- Use `Alignment=7` (top-left anchor) so `\pos` sets exact top-left of each word
+- Set `Encoding=177` (Hebrew) in ASS style
+- Strip punctuation and render as separate positioned elements
+- Two ASS styles (e.g., White + Yellow) instead of inline `\c` color tags
+
+**CRITICAL**: Any inline ASS tag (`\c`, `\K`, `\1c`, etc.) between RTL words breaks Unicode bidirectional algorithm in libass — words render LTR. Use separate Dialogue lines instead.
+
+## Remotion Motion Graphics
+
+For motion graphics rendering, use the `remotion-best-practices` skill for detailed Remotion patterns.
+
+For cloud rendering via Remotion Lambda:
+```bash
+npx remotion lambda render <serve-url> <composition-id> --out output.mp4
+```
+
+## Premiere Pro XML Timeline
+
+```python
+def generate_premiere_xml(clips, output_path, fps=30):
+    # Generate FCP7 XML compatible with Premiere Pro
+    ...
+```
+
+## Output Structure
+
+Organize outputs per project:
+```
+<project>/
+├── raw/          # original footage
+├── transcripts/  # SRT, word-level JSON
+├── clips/        # cut segments
+├── shorts/       # 9:16 vertical versions
+├── b-roll/       # generated B-roll images/videos
+├── motion/       # Remotion compositions
+└── export/       # final deliverables + XML timelines
+```
+
+## Check Before Writing New Scripts
+
+Before writing a new script, ask the user if they already have one for the task — they may have existing tools for clipping, silence removal, or subtitle burning.

package/skills/youtube-clipper/SKILL.md

@@ -0,0 +1,187 @@
+---
+name: youtube-clipper
+description: >
+  YouTube video smart clipping tool. Downloads video and subtitles, uses AI to analyze
+  and generate fine-grained chapters (2-5 minute segments), lets user select clips,
+  then auto-clips, translates subtitles to bilingual format, burns subtitles, and generates
+  summary copy. Use when: clipping YouTube videos, generating short clips, making bilingual
+  subtitle versions, creating Shorts/Reels/TikTok from long-form video.
+  Keywords: video clip, YouTube, subtitle translation, bilingual subtitles, video download,
+  shorts, reels, tiktok, yt-dlp, ffmpeg, clip video
+allowed-tools:
+  - Read
+  - Write
+  - Bash
+  - Glob
+  - AskUserQuestion
+---
+
+# YouTube Video Smart Clipper
+
+## Workflow — 6 Phases
+
+### Phase 1: Environment Check
+
+Verify required tools are installed:
+
+```bash
+yt-dlp --version
+ffmpeg -version
+ffmpeg -filters 2>&1 | grep subtitles   # verify libass for subtitle burn
+python3 -c "import pysrt; print('ok')"
+```
+
+**If missing**:
+- yt-dlp: `brew install yt-dlp` or `pip install yt-dlp`
+- FFmpeg without libass (macOS): `brew install ffmpeg-full`
+- Python deps: `pip install pysrt`
+
+> **Note**: Standard Homebrew FFmpeg lacks libass. On macOS install `ffmpeg-full`. On Windows, gyan.dev FFmpeg builds include libass.
+
+---
+
+### Phase 2: Download Video
+
+Ask user for YouTube URL, then download video + English subtitles:
+
+```bash
+yt-dlp -f "bestvideo[height<=1080][ext=mp4]+bestaudio/best" \
+  --write-auto-sub --sub-lang en --convert-subs srt \
+  -o "%(id)s.%(ext)s" <youtube_url>
+```
+
+Show user: title, duration, file size, download path.
+
+**Output**: `<id>.mp4` + `<id>.en.srt`
+
+**If 429 rate limit on subtitles**: download video first (`--no-write-subs`), then retry subtitle download separately after a delay.
+
+---
+
+### Phase 3: AI Chapter Analysis
+
+Parse the subtitle file and analyze content semantically:
+
+1. Read full subtitle text with timestamps
+2. Identify natural topic transitions
+3. Generate chapters at **2-5 minute granularity** (not coarse 30-minute cuts)
+
+For each chapter provide:
+- **Title**: concise topic summary (10-20 words)
+- **Time range**: start → end (MM:SS or HH:MM:SS)
+- **Summary**: 1-2 sentences on what this segment covers
+- **Keywords**: 3-5 key concepts
+
+Show numbered chapter list with all segments covered, no gaps.
+
+---
+
+### Phase 4: User Selection
+
+Ask user which chapters to clip (multi-select by number).
+
+Also ask:
+- Generate bilingual subtitles? (original + translated)
+- Burn subtitles into video? (hardcoded)
+- Generate summary copy for social media?
+
+---
+
+### Phase 5: Process Selected Clips
+
+For each selected chapter:
+
+#### 5.1 — Cut clip
+```bash
+ffmpeg -i input.mp4 -ss <start> -to <end> -c copy clip.mp4
+```
+
+#### 5.2 — Extract subtitle segment
+Filter subtitle entries within the time range, reset timestamps to start from 00:00:00.
+
+#### 5.3 — Translate subtitles (if requested)
+Batch translate in groups of 20 entries to minimize API calls. Target language: user's preferred language. Keep technical terms accurate; use natural spoken language suitable for short video.
+
+#### 5.4 — Generate bilingual SRT (if requested)
+Merge original + translated lines into dual-language SRT (original on top, translation below).
+
+#### 5.5 — Burn subtitles (if requested)
+```bash
+ffmpeg -i clip.mp4 -vf "subtitles=subs.srt:force_style='FontSize=24,MarginV=30,Bold=1'" \
+  -c:v libx264 -crf 18 -c:a copy output_with_subs.mp4
+```
+
+> **Windows path fix**: copy files to `tempfile.mkdtemp()` before running FFmpeg to avoid subtitle filter failures on paths with spaces.
+
+#### 5.6 — Generate summary copy (if requested)
+Based on chapter title, summary, and keywords — generate social media copy (title, key points, platform-appropriate format).
+
+---
+
+### Phase 6: Output Results
+
+Organize output under `./youtube-clips/<datetime>/`:
+```
+<chapter-title>/
+├── clip.mp4                  # raw cut
+├── clip_with_subtitles.mp4   # burned subtitle version
+├── bilingual.srt             # bilingual subtitle file
+└── summary.md                # social media copy
+```
+
+Show file list with sizes and quick-open commands. Ask if user wants to clip more chapters.
+
+---
+
+## 9:16 Vertical (Shorts / Reels / TikTok)
+
+When user requests vertical format — use blurred background fill, never crop:
+
+```
+[0:v]split[bg][fg];
+[bg]scale=1080:1920:force_original_aspect_ratio=increase,crop=1080:1920,gblur=sigma=40[blurred];
+[fg]scale=1080:1920:force_original_aspect_ratio=decrease,pad=1080:1920:(ow-iw)/2:(oh-ih)/2:color=black@0[front];
+[blurred][front]overlay=0:0,subtitles=subs.srt:force_style='FontSize=28,MarginV=120,Bold=1'
+```
+
+**Rules**:
+- Never crop original content — presenter/slides must be fully visible
+- Place subtitles in the lower blurred area (MarginV=120)
+- Black letterbox padding is not acceptable — blurred background only
+
+---
+
+## RTL Subtitles (Hebrew / Arabic)
+
+Basic burn with SRT works for simple subtitles. For per-word karaoke highlight with RTL:
+
+- Each word needs its own ASS `Dialogue` line with `\pos(x,y)` — no inline tags within a text run
+- Use PIL to measure word widths with `~0.74` scale factor (PIL→libass calibration)
+- Use `Alignment=7` and `Encoding=177` (Hebrew) in ASS style
+- Render punctuation as separate positioned elements to the left of the last word
+- Use two named ASS styles (e.g., White + Yellow) instead of inline `\c` color tags
+
+**Critical**: Inline ASS tags (`\c`, `\K`, etc.) between RTL words break Unicode bidi in libass — causing words to render left-to-right. Always use separate Dialogue lines per word.
+
+---
+
+## Shorts Mode (~40s clips)
+
+When user wants highlights rather than full chapters, identify:
+
+1. **Strong hook** — opening line that grabs attention immediately
+2. **Pain point** — relatable problem statement
+3. **WOW moment** — impressive demo or revelation
+4. **Core value prop** — clear, concise statement of the main idea
+5. **Counter-intuitive insight** — breaks common assumptions
+
+For each candidate clip provide: timestamps, content summary, why it works as a short, suggested title.
+
+---
+
+## Key Technical Notes
+
+- **Batch translation** (20 entries/call) saves ~95% API calls vs per-entry
+- **Chapter granularity**: semantic topic transitions, not mechanical time splits
+- **File naming**: strip special chars (`/ \ : * ? " < > |`), replace spaces with `_`, max 100 chars
+- **Windows encoding**: set `PYTHONIOENCODING=utf-8` when running Python scripts that print Unicode