@kolbo/kolbo-code-linux-arm64-musl 0.0.0-dev-202604161628

package/skills/remotion-best-practices/rules/videos.md

@@ -0,0 +1,171 @@
+---
+name: videos
+description: Embedding videos in Remotion - trimming, volume, speed, looping, pitch
+metadata:
+  tags: video, media, trim, volume, speed, loop, pitch
+---
+
+# Using videos in Remotion
+
+## Prerequisites
+
+First, the @remotion/media package needs to be installed.  
+If it is not, use the following command:
+
+```bash
+npx remotion add @remotion/media # If project uses npm
+bunx remotion add @remotion/media # If project uses bun
+yarn remotion add @remotion/media # If project uses yarn
+pnpm exec remotion add @remotion/media # If project uses pnpm
+```
+
+Use `<Video>` from `@remotion/media` to embed videos into your composition.
+
+```tsx
+import { Video } from "@remotion/media";
+import { staticFile } from "remotion";
+
+export const MyComposition = () => {
+  return <Video src={staticFile("video.mp4")} />;
+};
+```
+
+Remote URLs are also supported:
+
+```tsx
+<Video src="https://remotion.media/video.mp4" />
+```
+
+## Trimming
+
+Use `trimBefore` and `trimAfter` to remove portions of the video. Values are in seconds.
+
+```tsx
+const { fps } = useVideoConfig();
+
+return (
+  <Video
+    src={staticFile("video.mp4")}
+    trimBefore={2 * fps} // Skip the first 2 seconds
+    trimAfter={10 * fps} // End at the 10 second mark
+  />
+);
+```
+
+## Delaying
+
+Wrap the video in a `<Sequence>` to delay when it appears:
+
+```tsx
+import { Sequence, staticFile } from "remotion";
+import { Video } from "@remotion/media";
+
+const { fps } = useVideoConfig();
+
+return (
+  <Sequence from={1 * fps}>
+    <Video src={staticFile("video.mp4")} />
+  </Sequence>
+);
+```
+
+The video will appear after 1 second.
+
+## Sizing and Position
+
+Use the `style` prop to control size and position:
+
+```tsx
+<Video
+  src={staticFile("video.mp4")}
+  style={{
+    width: 500,
+    height: 300,
+    position: "absolute",
+    top: 100,
+    left: 50,
+    objectFit: "cover",
+  }}
+/>
+```
+
+## Volume
+
+Set a static volume (0 to 1):
+
+```tsx
+<Video src={staticFile("video.mp4")} volume={0.5} />
+```
+
+Or use a callback for dynamic volume based on the current frame:
+
+```tsx
+import { interpolate } from "remotion";
+
+const { fps } = useVideoConfig();
+
+return (
+  <Video
+    src={staticFile("video.mp4")}
+    volume={(f) =>
+      interpolate(f, [0, 1 * fps], [0, 1], { extrapolateRight: "clamp" })
+    }
+  />
+);
+```
+
+Use `muted` to silence the video entirely:
+
+```tsx
+<Video src={staticFile("video.mp4")} muted />
+```
+
+## Speed
+
+Use `playbackRate` to change the playback speed:
+
+```tsx
+<Video src={staticFile("video.mp4")} playbackRate={2} /> {/* 2x speed */}
+<Video src={staticFile("video.mp4")} playbackRate={0.5} /> {/* Half speed */}
+```
+
+Reverse playback is not supported.
+
+## Looping
+
+Use `loop` to loop the video indefinitely:
+
+```tsx
+<Video src={staticFile("video.mp4")} loop />
+```
+
+Use `loopVolumeCurveBehavior` to control how the frame count behaves when looping:
+
+- `"repeat"`: Frame count resets to 0 each loop (for `volume` callback)
+- `"extend"`: Frame count continues incrementing
+
+```tsx
+<Video
+  src={staticFile("video.mp4")}
+  loop
+  loopVolumeCurveBehavior="extend"
+  volume={(f) => interpolate(f, [0, 300], [1, 0])} // Fade out over multiple loops
+/>
+```
+
+## Pitch
+
+Use `toneFrequency` to adjust the pitch without affecting speed. Values range from 0.01 to 2:
+
+```tsx
+<Video
+  src={staticFile("video.mp4")}
+  toneFrequency={1.5} // Higher pitch
+/>
+<Video
+  src={staticFile("video.mp4")}
+  toneFrequency={0.8} // Lower pitch
+/>
+```
+
+Pitch shifting only works during server-side rendering, not in the Remotion Studio preview or in the `<Player />`.

package/skills/remotion-best-practices/rules/voiceover.md

@@ -0,0 +1,99 @@
+---
+name: voiceover
+description: Adding AI-generated voiceover to Remotion compositions using TTS
+metadata:
+  tags: voiceover, audio, elevenlabs, tts, speech, calculateMetadata, dynamic duration
+---
+
+# Adding AI voiceover to a Remotion composition
+
+Use ElevenLabs TTS to generate speech audio per scene, then use [`calculateMetadata`](./calculate-metadata) to dynamically size the composition to match the audio.
+
+## Prerequisites
+
+By default this guide uses **ElevenLabs** as the TTS provider (`ELEVENLABS_API_KEY` environment variable). Users may substitute any TTS service that can produce an audio file.
+
+If the user has not specified a TTS provider, recommend ElevenLabs and ask for their API key.
+
+Ensure the environment variable is available when running the generation script:
+
+```bash
+node --strip-types generate-voiceover.ts
+```
+
+## Generating audio with ElevenLabs
+
+Create a script that reads the config, calls the ElevenLabs API for each scene, and writes MP3 files to the `public/` directory so Remotion can access them via `staticFile()`.
+
+The core API call for a single scene:
+
+```ts title="generate-voiceover.ts"
+const response = await fetch(
+  `https://api.elevenlabs.io/v1/text-to-speech/${voiceId}`,
+  {
+    method: "POST",
+    headers: {
+      "xi-api-key": process.env.ELEVENLABS_API_KEY!,
+      "Content-Type": "application/json",
+      Accept: "audio/mpeg",
+    },
+    body: JSON.stringify({
+      text: "Welcome to the show.",
+      model_id: "eleven_multilingual_v2",
+      voice_settings: {
+        stability: 0.5,
+        similarity_boost: 0.75,
+        style: 0.3,
+      },
+    }),
+  },
+);
+
+const audioBuffer = Buffer.from(await response.arrayBuffer());
+writeFileSync(`public/voiceover/${compositionId}/${scene.id}.mp3`, audioBuffer);
+```
+
+## Dynamic composition duration with calculateMetadata
+
+Use [`calculateMetadata`](./calculate-metadata.md) to measure the [audio durations](./get-audio-duration.md) and set the composition length accordingly.
+
+```tsx
+import { CalculateMetadataFunction, staticFile } from "remotion";
+import { getAudioDuration } from "./get-audio-duration";
+
+const FPS = 30;
+
+const SCENE_AUDIO_FILES = [
+  "voiceover/my-comp/scene-01-intro.mp3",
+  "voiceover/my-comp/scene-02-main.mp3",
+  "voiceover/my-comp/scene-03-outro.mp3",
+];
+
+export const calculateMetadata: CalculateMetadataFunction<Props> = async ({
+  props,
+}) => {
+  const durations = await Promise.all(
+    SCENE_AUDIO_FILES.map((file) => getAudioDuration(staticFile(file))),
+  );
+
+  const sceneDurations = durations.map((durationInSeconds) => {
+    return durationInSeconds * FPS;
+  });
+
+  return {
+    durationInFrames: Math.ceil(sceneDurations.reduce((sum, d) => sum + d, 0)),
+  };
+};
+```
+
+The computed `sceneDurations` are passed into the component via a `voiceover` prop so the component knows how long each scene should be.
+
+If the composition uses [`<TransitionSeries>`](./transitions.md), subtract the overlap from total duration: [./transitions.md#calculating-total-composition-duration](./transitions.md#calculating-total-composition-duration)
+
+## Rendering audio in the component
+
+See [audio.md](./audio.md) for more information on how to render audio in the component.
+
+## Delaying audio start
+
+See [audio.md#delaying](./audio.md#delaying) for more information on how to delay the audio start.

package/skills/requesting-code-review/SKILL.md

@@ -0,0 +1,105 @@
+---
+name: requesting-code-review
+description: Use when completing tasks, implementing major features, or before merging to verify work meets requirements
+---
+
+# Requesting Code Review
+
+Dispatch superpowers:code-reviewer subagent to catch issues before they cascade. The reviewer gets precisely crafted context for evaluation — never your session's history. This keeps the reviewer focused on the work product, not your thought process, and preserves your own context for continued work.
+
+**Core principle:** Review early, review often.
+
+## When to Request Review
+
+**Mandatory:**
+- After each task in subagent-driven development
+- After completing major feature
+- Before merge to main
+
+**Optional but valuable:**
+- When stuck (fresh perspective)
+- Before refactoring (baseline check)
+- After fixing complex bug
+
+## How to Request
+
+**1. Get git SHAs:**
+```bash
+BASE_SHA=$(git rev-parse HEAD~1)  # or origin/main
+HEAD_SHA=$(git rev-parse HEAD)
+```
+
+**2. Dispatch code-reviewer subagent:**
+
+Use Task tool with superpowers:code-reviewer type, fill template at `code-reviewer.md`
+
+**Placeholders:**
+- `{WHAT_WAS_IMPLEMENTED}` - What you just built
+- `{PLAN_OR_REQUIREMENTS}` - What it should do
+- `{BASE_SHA}` - Starting commit
+- `{HEAD_SHA}` - Ending commit
+- `{DESCRIPTION}` - Brief summary
+
+**3. Act on feedback:**
+- Fix Critical issues immediately
+- Fix Important issues before proceeding
+- Note Minor issues for later
+- Push back if reviewer is wrong (with reasoning)
+
+## Example
+
+```
+[Just completed Task 2: Add verification function]
+
+You: Let me request code review before proceeding.
+
+BASE_SHA=$(git log --oneline | grep "Task 1" | head -1 | awk '{print $1}')
+HEAD_SHA=$(git rev-parse HEAD)
+
+[Dispatch superpowers:code-reviewer subagent]
+  WHAT_WAS_IMPLEMENTED: Verification and repair functions for conversation index
+  PLAN_OR_REQUIREMENTS: Task 2 from docs/superpowers/plans/deployment-plan.md
+  BASE_SHA: a7981ec
+  HEAD_SHA: 3df7661
+  DESCRIPTION: Added verifyIndex() and repairIndex() with 4 issue types
+
+[Subagent returns]:
+  Strengths: Clean architecture, real tests
+  Issues:
+    Important: Missing progress indicators
+    Minor: Magic number (100) for reporting interval
+  Assessment: Ready to proceed
+
+You: [Fix progress indicators]
+[Continue to Task 3]
+```
+
+## Integration with Workflows
+
+**Subagent-Driven Development:**
+- Review after EACH task
+- Catch issues before they compound
+- Fix before moving to next task
+
+**Executing Plans:**
+- Review after each batch (3 tasks)
+- Get feedback, apply, continue
+
+**Ad-Hoc Development:**
+- Review before merge
+- Review when stuck
+
+## Red Flags
+
+**Never:**
+- Skip review because "it's simple"
+- Ignore Critical issues
+- Proceed with unfixed Important issues
+- Argue with valid technical feedback
+
+**If reviewer wrong:**
+- Push back with technical reasoning
+- Show code/tests that prove it works
+- Request clarification
+
+See template at: requesting-code-review/code-reviewer.md

package/skills/requesting-code-review/code-reviewer.md

@@ -0,0 +1,146 @@
+# Code Review Agent
+
+You are reviewing code changes for production readiness.
+
+**Your task:**
+1. Review {WHAT_WAS_IMPLEMENTED}
+2. Compare against {PLAN_OR_REQUIREMENTS}
+3. Check code quality, architecture, testing
+4. Categorize issues by severity
+5. Assess production readiness
+
+## What Was Implemented
+
+{DESCRIPTION}
+
+## Requirements/Plan
+
+{PLAN_REFERENCE}
+
+## Git Range to Review
+
+**Base:** {BASE_SHA}
+**Head:** {HEAD_SHA}
+
+```bash
+git diff --stat {BASE_SHA}..{HEAD_SHA}
+git diff {BASE_SHA}..{HEAD_SHA}
+```
+
+## Review Checklist
+
+**Code Quality:**
+- Clean separation of concerns?
+- Proper error handling?
+- Type safety (if applicable)?
+- DRY principle followed?
+- Edge cases handled?
+
+**Architecture:**
+- Sound design decisions?
+- Scalability considerations?
+- Performance implications?
+- Security concerns?
+
+**Testing:**
+- Tests actually test logic (not mocks)?
+- Edge cases covered?
+- Integration tests where needed?
+- All tests passing?
+
+**Requirements:**
+- All plan requirements met?
+- Implementation matches spec?
+- No scope creep?
+- Breaking changes documented?
+
+**Production Readiness:**
+- Migration strategy (if schema changes)?
+- Backward compatibility considered?
+- Documentation complete?
+- No obvious bugs?
+
+## Output Format
+
+### Strengths
+[What's well done? Be specific.]
+
+### Issues
+
+#### Critical (Must Fix)
+[Bugs, security issues, data loss risks, broken functionality]
+
+#### Important (Should Fix)
+[Architecture problems, missing features, poor error handling, test gaps]
+
+#### Minor (Nice to Have)
+[Code style, optimization opportunities, documentation improvements]
+
+**For each issue:**
+- File:line reference
+- What's wrong
+- Why it matters
+- How to fix (if not obvious)
+
+### Recommendations
+[Improvements for code quality, architecture, or process]
+
+### Assessment
+
+**Ready to merge?** [Yes/No/With fixes]
+
+**Reasoning:** [Technical assessment in 1-2 sentences]
+
+## Critical Rules
+
+**DO:**
+- Categorize by actual severity (not everything is Critical)
+- Be specific (file:line, not vague)
+- Explain WHY issues matter
+- Acknowledge strengths
+- Give clear verdict
+
+**DON'T:**
+- Say "looks good" without checking
+- Mark nitpicks as Critical
+- Give feedback on code you didn't review
+- Be vague ("improve error handling")
+- Avoid giving a clear verdict
+
+## Example Output
+
+```
+### Strengths
+- Clean database schema with proper migrations (db.ts:15-42)
+- Comprehensive test coverage (18 tests, all edge cases)
+- Good error handling with fallbacks (summarizer.ts:85-92)
+
+### Issues
+
+#### Important
+1. **Missing help text in CLI wrapper**
+   - File: index-conversations:1-31
+   - Issue: No --help flag, users won't discover --concurrency
+   - Fix: Add --help case with usage examples
+
+2. **Date validation missing**
+   - File: search.ts:25-27
+   - Issue: Invalid dates silently return no results
+   - Fix: Validate ISO format, throw error with example
+
+#### Minor
+1. **Progress indicators**
+   - File: indexer.ts:130
+   - Issue: No "X of Y" counter for long operations
+   - Impact: Users don't know how long to wait
+
+### Recommendations
+- Add progress reporting for user experience
+- Consider config file for excluded projects (portability)
+
+### Assessment
+
+**Ready to merge: With fixes**
+
+**Reasoning:** Core implementation is solid with good architecture and tests. Important issues (help text, date validation) are easily fixed and don't affect core functionality.
+```

package/skills/short-form-video/SKILL.md

@@ -0,0 +1,168 @@
+---
+name: short-form-video
+description: >
+  Short-form video optimization for TikTok, Instagram Reels, YouTube Shorts, and Facebook Reels.
+  Platform safe zones, upload specs, hook techniques, pacing rules, duration strategy, retention
+  benchmarks, caption requirements. Use when creating vertical video content or optimizing for
+  social platforms.
+  Keywords: tiktok, reels, shorts, vertical video, 9:16, hook, retention, pacing, safe zone,
+  caption, short form, social media, viral
+---
+
+# Short-Form Video (TikTok / Reels / Shorts)
+
+## Quick Reference
+
+```
+ASPECT RATIO:     9:16 vertical (1080x1920)
+SAFE ZONE:        900x1400px centered (universal cross-platform)
+DURATION:         15s (highest completion) | 30s (best engagement) | 60s (most flexible)
+HOOK:             First 1-2 seconds — visual or text pattern interrupt
+CAPTIONS:         Mandatory (85% watch muted on mobile)
+TEXT SIZE:         42px+ minimum, bold sans-serif
+PACING:           Visual change every 1-3 seconds
+TARGET LUFS:      -14 LUFS, true peak -1 dBTP
+MUSIC:            120-140 BPM for energetic, 90-110 for explainers
+CODEC:            H.264 High Profile, 8-15 Mbps VBR
+```
+
+## Platform Safe Zones (1080x1920)
+
+| Platform | Safe Zone | Top Dead | Bottom Dead | Right Dead |
+|----------|-----------|----------|-------------|------------|
+| TikTok | 900x1492 | 108px | 320px | 120px |
+| Instagram Reels | 996x1400 | 210px | 310px | 84px |
+| YouTube Shorts | 984x1500 | 120px | 300px | 96px |
+| Facebook Reels | 1080x1520 | 100px | 300px | 60px |
+
+**Universal safe zone: 900x1400px centered** — works across all platforms.
+
+**Bottom dead zones are critical** — platform UI (comments, share, captions) covers the bottom 300-320px. Never put important content there.
+
+## Duration Strategy
+
+| Duration | Avg Completion | Best For |
+|----------|---------------|----------|
+| 0-15s | 92% | Single fact, quick tip, visual gag |
+| 16-30s | 84% | One concept explained, before/after |
+| 31-60s | 68% | Mini tutorial, step-by-step, story arc |
+| 60s+ | 48% | Deep explainer (only with strong retention structure) |
+
+**Platform sweet spots:**
+- TikTok: 21-34s for completion; 60-180s for maximum total watch time
+- Reels: 15-30s for viral reach; 60-90s for highest engagement
+- Shorts: Bimodal — ~13s OR full 60s
+
+**Key formula:** A 45s video with 70% completion (31.5s watch time) outperforms a 15s video with 40% completion (6s). Total watch time is what the algorithm rewards.
+
+## The 1-Second Hook
+
+70%+ of TikTok users decide to scroll or stay within 3 seconds (average decision: 1.7s).
+
+### 3-Second Retention Impact
+
+| 3-Second Retention | Algorithmic Effect | View Multiplier |
+|-------------------|-------------------|-----------------|
+| Below 60% | Minimal promotion | 1.0x |
+| 60-70% | Average distribution | 1.6x |
+| 70-85% | Optimal reach | 2.2x |
+| 85%+ | Viral potential | 2.8x |
+
+### Hook Techniques
+
+| Technique | Example | When to Use |
+|-----------|---------|-------------|
+| **Bold text on screen** | "STOP doing this..." (frame 1) | Always — works even muted |
+| **Pattern interrupt** | Unexpected visual, jump cut, color flash | Attention-grabbing |
+| **Question** | "Why does X happen?" (text + voiceover) | Educational |
+| **Result first** | Show finished result, then explain how | Tutorial/how-to |
+| **Controversy** | "Everyone gets this wrong" | Engagement bait |
+
+### Hook Rules
+
+1. **Frame 1 must have visual interest** — no blank intros, no logos, no "hey guys"
+2. **Text appears in the first 0.5 seconds** — viewers scan text before listening
+3. **Voice starts immediately** — no silent buildup
+4. **Movement in frame 1** — static opening frames get scrolled past
+
+## Pacing Rules
+
+- Visual change every **1-3 seconds** minimum
+- New information every **3-5 seconds**
+- No static shot longer than **2 seconds** without text overlay or motion
+- Scene transitions should be **hard cuts** (no slow fades on short-form)
+
+## Retention Checkpoints
+
+| Timestamp | Target Retention |
+|-----------|-----------------|
+| 3 seconds | 70%+ |
+| 15 seconds | 60%+ |
+| 30 seconds | 50%+ |
+
+## Upload Specs
+
+```
+CODEC:       H.264 High Profile, Level 4.2
+BITRATE:     8-15 Mbps VBR (below 5 Mbps triggers quality downgrade)
+FORMAT:      .mp4 preferred
+MAX SIZE:    500 MB (desktop), 287.6 MB (iOS), 72 MB (Android)
+```
+
+## Caption Requirements
+
+- **85% of social video is watched on mute** — captions are mandatory
+- Max 3-4 words per cue on vertical (narrow screen)
+- Max 20 characters per line
+- 42px+ minimum font size
+- Bold sans-serif font (Arial, Inter, Montserrat)
+- Thick outline (3px) for readability on varied backgrounds
+- Position in bottom 20% but above the platform dead zone
+
+## 9:16 Conversion (from 16:9 source)
+
+Blurred background + centered content — never crop the original:
+
+```bash
+ffmpeg -i input.mp4 -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" \
+  -c:v libx264 -crf 18 -c:a aac output_vertical.mp4
+```
+
+---
+
+## Kolbo MCP Integration
+
+| Task | Kolbo MCP Tool | Notes |
+|------|---------------|-------|
+| Generate vertical video | `generate_video` | Specify "9:16 vertical" in prompt |
+| Image-to-video hook | `generate_video_from_image` | Animate a striking frame for the hook |
+| Batch clips from long-form | `generate_creative_director` | Extract highlights |
+| Add captions | `transcribe_audio` | Get word-level SRT, then burn-in with FFmpeg |
+| Background music | `generate_music` | 120-140 BPM for energetic, instrumental=true |
+| Sound effects | `generate_sound` | Whooshes, pops for transitions |
+| Style consistency | `create_visual_dna` | Same look across a series |
+
+**Short-form production workflow:**
+1. Script using the `storytelling` skill (hook → content → close)
+2. `generate_speech` → narration
+3. `generate_video` or `generate_video_from_image` → visual clips
+4. `generate_music` → background track (120-140 BPM, instrumental)
+5. `transcribe_audio` → get word-level SRT for captions
+6. FFmpeg: compose 9:16 video + burn-in captions + mix audio
+7. Review with `production-review` skill checklist
+
+---
+
+## Local / Free Options
+
+> **IMPORTANT:** Always use Kolbo MCP tools by default. FFmpeg is the only tool safe to use without asking — it's standard software. For anything else, confirm with the user first.
+
+**FFmpeg (safe, standard):** Handles 9:16 conversion, caption burn-in, audio mixing, silence removal — all commands in this skill and the `ffmpeg-patterns` skill.
+
+**Transcription:** Kolbo's `transcribe_audio` is easiest. If the user explicitly wants offline transcription, `faster-whisper` runs on CPU with no GPU needed (`pip install faster-whisper`) — but confirm before installing.