@kolbo/kolbo-code-linux-arm64-musl 1.1.72 → 1.1.73

package/skills/subtitle-production/reference/export_srts.py

@@ -0,0 +1,127 @@
+"""
+Export SRT subtitle files for each video and each individual chapter.
+- Full video SRT: placed next to the edited MP4
+- Per-chapter SRTs: placed in each chapter's subfolder, timestamps zeroed to chapter start
+"""
+import json, os
+
+def fmt_srt_time(seconds):
+    """Format seconds as SRT timestamp: HH:MM:SS,mmm"""
+    h = int(seconds // 3600)
+    m = int((seconds % 3600) // 60)
+    s = seconds % 60
+    return f"{h:02d}:{m:02d}:{s:06.3f}".replace('.', ',')
+
+
+def sentences_to_srt(sentences, offset=0.0):
+    """Convert sentence list to SRT text, subtracting offset from all timestamps."""
+    blocks = []
+    for i, s in enumerate(sentences, 1):
+        start = max(0.0, s['start'] - offset)
+        end = max(0.0, s['end'] - offset)
+        blocks.append(f"{i}\n{fmt_srt_time(start)} --> {fmt_srt_time(end)}\n{s['text']}\n")
+    return '\n'.join(blocks)
+
+
+def get_sentences_in_range(sentences, start_time, end_time):
+    """Get all sentences that overlap with the given time range."""
+    result = []
+    for s in sentences:
+        # Include sentence if it overlaps with the range
+        if s['end'] > start_time and s['start'] < end_time:
+            result.append(s)
+    return result
+
+
+JOBS = [
+    {
+        "name": "lior_course_01",
+        "transcript": r"G:\Projects\Master Agent\ytp_jobs\lior_course_01\transcript.json",
+        "chapters_json": r"G:\Projects\Master Agent\ytp_jobs\lior_course_01\chapters.json",
+        "full_srt_path": r"G:\Projects\Kolbo.AI\Courses\Lior\Claude\1 - היכרות עם Kolbo.AI - edited.srt",
+        "chapters_dir": r"G:\Projects\Kolbo.AI\Courses\Lior\Claude\1 - היכרות עם Kolbo.AI",
+        "video_duration": 540.2,
+    },
+    {
+        "name": "lior_course_02",
+        "transcript": r"G:\Projects\Master Agent\ytp_jobs\lior_course_02\transcript.json",
+        "chapters_json": r"G:\Projects\Master Agent\ytp_jobs\lior_course_02\chapters.json",
+        "full_srt_path": r"G:\Projects\Kolbo.AI\Courses\Lior\Claude\2 - הסבר על פרוייקטים - edited.srt",
+        "chapters_dir": r"G:\Projects\Kolbo.AI\Courses\Lior\Claude\2 - הסבר על פרוייקטים",
+        "video_duration": 1643.0,
+    },
+    {
+        "name": "lior_course_03",
+        "transcript": r"G:\Projects\Master Agent\ytp_jobs\lior_course_03\transcript.json",
+        "chapters_json": r"G:\Projects\Master Agent\ytp_jobs\lior_course_03\chapters.json",
+        "full_srt_path": r"G:\Projects\Kolbo.AI\Courses\Lior\Claude\3 - כלי הצאט - edited.srt",
+        "chapters_dir": r"G:\Projects\Kolbo.AI\Courses\Lior\Claude\3 - כלי הצאט",
+        "video_duration": 2789.4,
+    },
+]
+
+for job in JOBS:
+    print(f"\n{'='*60}")
+    print(f"SRT export: {job['name']}")
+    print('='*60)
+
+    with open(job['transcript'], encoding='utf-8') as f:
+        transcript = json.load(f)
+    sentences = transcript['sentences']
+
+    with open(job['chapters_json'], encoding='utf-8') as f:
+        chapters = json.load(f)
+
+    # Compute end times
+    for i, ch in enumerate(chapters):
+        ch['end_time'] = chapters[i + 1]['start_time'] if i + 1 < len(chapters) else job['video_duration']
+
+    # ── Full video SRT ────────────────────────────────────────────────────
+    # Note: the burned video has 4s divider cards inserted before each chapter.
+    # We need to offset all timestamps to account for the accumulated divider time.
+    full_blocks = []
+    block_num = 1
+    accumulated_divider_time = 0.0
+    DIVIDER_DURATION = 4.0
+
+    for ch in chapters:
+        ch_start = ch['start_time']
+        ch_end = ch['end_time']
+        ch_sentences = get_sentences_in_range(sentences, ch_start, ch_end)
+
+        # Each chapter is preceded by a 4s divider
+        accumulated_divider_time += DIVIDER_DURATION
+
+        for s in ch_sentences:
+            start = s['start'] + accumulated_divider_time
+            end = s['end'] + accumulated_divider_time
+            full_blocks.append(
+                f"{block_num}\n{fmt_srt_time(start)} --> {fmt_srt_time(end)}\n{s['text']}\n"
+            )
+            block_num += 1
+
+    with open(job['full_srt_path'], 'w', encoding='utf-8') as f:
+        f.write('\n'.join(full_blocks))
+    print(f"  Full SRT: {block_num - 1} blocks")
+
+    # ── Per-chapter SRTs ──────────────────────────────────────────────────
+    for ch in chapters:
+        n = ch['chapter_number']
+        title = ch['title']
+        safe_title = title.replace('/', '-').replace('\\', '-').replace(':', '-').replace('"', '').replace('?', '').replace('*', '').replace('<', '').replace('>', '').replace('|', '')
+
+        ch_start = ch['start_time']
+        ch_end = ch['end_time']
+        ch_sentences = get_sentences_in_range(sentences, ch_start, ch_end)
+
+        # Offset = chapter start time (zero the timestamps to chapter-local time)
+        # Add 4s for the divider card at the beginning of each chapter clip
+        srt_text = sentences_to_srt(ch_sentences, offset=ch_start - DIVIDER_DURATION)
+
+        srt_path = os.path.join(job['chapters_dir'], f"{n:02d} - {safe_title}.srt")
+        with open(srt_path, 'w', encoding='utf-8') as f:
+            f.write(srt_text)
+
+        print(f"  Ch {n:02d}: {len(ch_sentences)} blocks")
+
+print("\nAll SRTs exported!")

package/skills/subtitle-production/reference/gen_srt.py

@@ -0,0 +1,42 @@
+"""Generate SRT from transcript.json and analyze chapters via Claude."""
+import json, os, sys
+
+# ── SRT generation ────────────────────────────────────────────────────────
+
+with open('ytp_jobs/sapir_test/transcript.json', encoding='utf-8') as f:
+    data = json.load(f)
+
+words = data['words']
+
+def fmt_time(s):
+    h = int(s // 3600)
+    m = int((s % 3600) // 60)
+    sec = s % 60
+    return f'{h:02d}:{m:02d}:{sec:06.3f}'.replace('.', ',')
+
+lines, current, cur_start = [], [], None
+for i, w in enumerate(words):
+    if not current:
+        cur_start = w['start']
+    current.append(w['text'])
+    gap = words[i + 1]['start'] - w['end'] if i + 1 < len(words) else 999
+    if len(current) >= 8 or gap > 1.5:
+        lines.append({'start': cur_start, 'end': w['end'], 'text': ' '.join(current)})
+        current, cur_start = [], None
+
+if current:
+    lines.append({'start': cur_start, 'end': words[-1]['end'], 'text': ' '.join(current)})
+
+srt_blocks = []
+for i, l in enumerate(lines, 1):
+    srt_blocks.append(f"{i}\n{fmt_time(l['start'])} --> {fmt_time(l['end'])}\n{l['text']}\n")
+
+srt_text = '\n'.join(srt_blocks)
+
+with open('ytp_jobs/sapir_test/sapir.srt', 'w', encoding='utf-8') as f:
+    f.write(srt_text)
+
+print(f"[srt] Written {len(lines)} subtitle blocks -> ytp_jobs/sapir_test/sapir.srt")
+print(f"[srt] First 3 blocks:")
+for l in lines[:3]:
+    print(f"  [{fmt_time(l['start'])} --> {fmt_time(l['end'])}] {l['text'][:70]}")

package/skills/typography-video/SKILL.md

@@ -0,0 +1,182 @@
+---
+name: typography-video
+description: >
+  Typography rules for video production: font selection and pairing, minimum readable sizes,
+  safe zones per platform, text animation timing, contrast requirements, subtitle styling.
+  Use when adding text overlays, titles, lower thirds, or captions to video.
+  Keywords: typography, font, text, title, lower third, caption, subtitle, safe zone, text size,
+  font pairing, readable, overlay, motion graphics
+---
+
+# Typography for Video Production
+
+## Quick Reference
+
+```
+TITLE SIZE:       60-90px at 1080p  |  120-180px at 4K
+BODY SIZE:        40-60px at 1080p  |  80-120px at 4K
+SUBTITLE SIZE:    42px+ at 1080p    |  3-5% of video height
+MAX CHARS/LINE:   32-42 (subtitles) |  30 (overlays)
+MAX LINES:        2 (subtitles)     |  3 (overlays)
+READING SPEED:    21 chars/sec      |  160-200 WPM
+TITLE SAFE:       80% of frame (192px margin at 1080p)
+FONT FAMILIES:    1-2 per video maximum
+CONTRAST:         4.5:1 minimum, 7:1 optimal
+FADE DURATION:    0.3s opacity  |  0.5-1.0s slide/scale
+```
+
+## Font Selection
+
+### Recommended Video Fonts
+
+| Category | Fonts | Use For |
+|----------|-------|---------|
+| **Body / Captions** | Inter, Open Sans, Roboto, Source Sans Pro, Lato, DM Sans | All body text, subtitles |
+| **Headlines** | Montserrat Bold, Bebas Neue, Oswald Bold, Poppins Bold | Titles, section headers, key stats |
+| **Editorial** | Playfair Display, Roboto Slab | Luxury, cinematic, documentary |
+| **System Safe** | Helvetica Neue, Arial, Avenir Next | When custom fonts unavailable |
+
+### Font Pairing Rules
+
+- Limit to **1-2 font families** per video
+- Pair a **display/bold heading** font with a **neutral body** font
+- Size difference between title and body: at least **50% larger**
+- **Sans-serif** for motion graphics and captions (holds up in motion)
+- **Serif** only for cinematic title cards and editorial content
+- **Script/decorative** fonts: hero titles only, never body, never in motion
+
+### Proven Pairings
+
+| Heading | Body | Style |
+|---------|------|-------|
+| Bebas Neue | Open Sans | High-impact, social ads |
+| Montserrat Bold | Lato | Clean modern |
+| Oswald Bold | Raleway | Strong contrast |
+| Playfair Display | Inter | Editorial |
+| Poppins Bold | Poppins Light | Single-family hierarchy |
+
+## Text Sizing
+
+| Element | 1080p (px) | 4K (px) |
+|---------|-----------|---------|
+| Title / Hero text | 60-90 | 120-180 |
+| Body text | 40-60 | 80-120 |
+| Subtitles | 42+ | 84+ |
+| Lower third name | 48-60 | 96-120 |
+| Lower third role | 36-44 | 72-88 |
+
+## Safe Zones
+
+### Broadcast Standard (1920x1080)
+
+| Zone | Coverage | Margin |
+|------|----------|--------|
+| **Title Safe** | 80% of frame | 192px H, 108px V |
+| **Action Safe** | 90% of frame | 96px H, 54px V |
+
+At 1920x1080: Title Safe = inner 1536x864px
+
+### Vertical (1080x1920) Platform-Specific
+
+See the `short-form-video` skill for per-platform safe zones. Universal safe: 900x1400px centered.
+
+## Reading Speed
+
+- Average viewer reads **21 characters per second** / **160-200 WPM**
+- Minimum display time: **0.5 seconds per text element**
+- Maximum display time: **5 seconds** before it feels stale
+- Formula: `display_seconds = character_count / 21 + 0.5`
+
+## Contrast Requirements (WCAG)
+
+| Element | Minimum Ratio |
+|---------|--------------|
+| Body text on background | 4.5:1 (AA) |
+| Large text (>18pt) | 3:1 (AA) |
+| Enhanced readability | 7:1 (AAA) |
+
+**Practical rule:** After color grading, any text overlays must still meet 4.5:1 contrast against the graded background.
+
+## Text Animation Timing
+
+| Animation | Duration | Easing |
+|-----------|----------|--------|
+| Fade in/out | 0.3s | ease-in-out |
+| Slide in | 0.5-0.8s | ease-out (cubic) |
+| Scale up | 0.4-0.6s | ease-out with slight overshoot |
+| Typewriter | 30-50ms per character | linear |
+| Word-by-word | 80-120ms per word | step or ease |
+
+### Animation Rules
+- Text should be **fully readable for at least 1.5 seconds** after animation completes
+- Entry animation + readable duration + exit animation = total display time
+- **Never animate body text character-by-character** — only titles and keywords
+- **Ease out, not ease in** — text should arrive quickly and settle, not start slow
+
+## RTL (Hebrew/Arabic) Text — Proven Patterns
+
+These patterns are battle-tested in Kolbo's video production pipeline.
+
+**Reference implementation:** `./reference/KineticTitleScene.tsx` (346 lines, full RTL) — read this for a complete working example of every RTL flip listed below.
+
+### Font Selection
+- **Hebrew**: Heebo (Google Fonts, free) — use Bold weight for captions
+- **Arabic**: Cairo (Google Fonts, free) — use Bold weight for captions
+- **Never** use Poppins or English-first fonts for Hebrew/Arabic body text
+
+### Remotion RTL Rules (proven)
+
+Every component receiving text must handle RTL:
+
+```tsx
+const isHebrew = language === "he" || language === "iw";
+
+<div style={{
+  direction: isHebrew ? "rtl" : "ltr",
+  fontFamily: isHebrew ? "'Heebo', sans-serif" : "'Poppins', sans-serif",
+  textTransform: isHebrew ? "none" : "uppercase",  // No uppercase in Hebrew
+  letterSpacing: isHebrew ? 0 : -2,                 // No negative kerning for Hebrew
+}}>
+```
+
+**What you must flip for RTL:**
+| Property | LTR (English) | RTL (Hebrew) |
+|----------|--------------|--------------|
+| `direction` | `ltr` | `rtl` |
+| `paddingLeft` / `paddingRight` | normal | swapped |
+| `transformOrigin` | `"top left"` | `"top right"` |
+| Gradient direction | `90deg` | `270deg` |
+| Position "left" | left side | **right side** (flip the logic) |
+| `textTransform` | `uppercase` | `none` |
+| `letterSpacing` | `-2` or custom | `0` (always) |
+| Slide-in direction | from left | from right |
+
+### FFmpeg RTL Burn-in
+
+```bash
+# Hebrew subtitles with Heebo font
+ffmpeg -i input.mp4 -vf "subtitles=subs.srt:force_style='FontName=Heebo,FontSize=22,Bold=1,Encoding=177,PrimaryColour=&H00FFFFFF,OutlineColour=&H00000000,Outline=2'" output.mp4
+```
+
+See `subtitle-production` skill for full RTL karaoke and per-word positioning patterns.
+
+---
+
+## Kolbo MCP Integration
+
+Typography rules apply to all Kolbo visual generation:
+
+| Task | Kolbo MCP Tool | Typography Rule |
+|------|---------------|----------------|
+| Title cards | `generate_image` | Add text as Remotion overlay, NOT in AI image prompt |
+| Caption generation | `transcribe_audio` | Word-level SRT → burn-in with FFmpeg |
+| Lower thirds | Remotion component | Use proven font pairings above |
+| Video with text overlay | `generate_video` + FFmpeg post | Render video first, add text in post |
+
+**Key rule:** Never ask image/video generation models to render text — they can't do it reliably. Always add text as overlays in post-production (Remotion, FFmpeg, or video editor).
+
+**Free fonts for video (Google Fonts, all free):**
+- Body: Inter, Open Sans, Roboto, Lato, DM Sans
+- Headlines: Montserrat, Bebas Neue, Oswald, Poppins
+- Hebrew: Heebo, Assistant, Rubik
+- Arabic: Cairo, Noto Sans Arabic