#!/usr/bin/env python3
"""
Add voiceover to existing video
"""

import argparse
import subprocess
import sys
import os
from pathlib import Path
from dotenv import load_dotenv

load_dotenv()


def generate_audio(text, voice="alloy", output_path="voiceover.mp3"):
    """Generate audio using OpenAI TTS"""
    OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
    
    if not OPENAI_API_KEY:
        print("❌ Error: OPENAI_API_KEY not set")
        sys.exit(1)
    
    import openai
    client = openai.OpenAI(api_key=OPENAI_API_KEY)
    
    print(f"🎤 Generating voiceover...")
    
    response = client.audio.speech.create(
        model="tts-1",
        voice=voice,
        input=text
    )
    
    response.stream_to_file(output_path)
    print(f"✓ Audio saved: {output_path}")
    return output_path


def add_audio_to_video(video_path, audio_path, output_path, mix_audio=False):
    """Combine video with audio using FFmpeg"""
    
    print(f"🎞️ Adding audio to video...")
    
    if mix_audio:
        # Mix new audio with existing audio
        cmd = [
            'ffmpeg', '-y',
            '-i', video_path,
            '-i', audio_path,
            '-filter_complex', '[0:a][1:a]amix=inputs=2:duration=longest',
            '-c:v', 'copy',
            output_path
        ]
    else:
        # Replace audio
        cmd = [
            'ffmpeg', '-y',
            '-i', video_path,
            '-i', audio_path,
            '-c:v', 'copy',
            '-c:a', 'aac',
            '-map', '0:v:0',
            '-map', '1:a:0',
            '-shortest',
            output_path
        ]
    
    try:
        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
        print(f"✅ Video with audio created: {output_path}")
        return output_path
    except subprocess.CalledProcessError as e:
        print(f"❌ FFmpeg error: {e.stderr}")
        sys.exit(1)


def main():
    parser = argparse.ArgumentParser(description='Add voiceover to video')
    parser.add_argument('--video', required=True, help='Input video file')
    parser.add_argument('--text', help='Text for voiceover')
    parser.add_argument('--audio', help='Pre-existing audio file (alternative to --text)')
    parser.add_argument('--output', default='output_with_audio.mp4', help='Output video file')
    parser.add_argument('--voice', default='alloy', 
                       choices=['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer'],
                       help='OpenAI TTS voice')
    parser.add_argument('--mix', action='store_true', 
                       help='Mix with existing audio instead of replacing')
    
    args = parser.parse_args()
    
    # Validate video exists
    if not Path(args.video).exists():
        print(f"❌ Error: Video not found: {args.video}")
        sys.exit(1)
    
    # Get or generate audio
    if args.audio:
        if not Path(args.audio).exists():
            print(f"❌ Error: Audio file not found: {args.audio}")
            sys.exit(1)
        audio_path = args.audio
    elif args.text:
        audio_path = generate_audio(args.text, args.voice)
    else:
        print("❌ Error: Must provide either --text or --audio")
        sys.exit(1)
    
    # Combine video and audio
    add_audio_to_video(args.video, audio_path, args.output, args.mix)
    
    # Clean up temp audio if we generated it
    if args.text and not args.audio:
        Path(audio_path).unlink(missing_ok=True)


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
AI Video Generator - End-to-end video creation from text prompts
Supports: OpenAI DALL-E, Replicate, LumaAI, Runway, FFmpeg
"""

import os
import sys
import argparse
import json
import time
import requests
from pathlib import Path
from dotenv import load_dotenv

load_dotenv()

# API clients
OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
REPLICATE_API_TOKEN = os.getenv('REPLICATE_API_TOKEN')
LUMAAI_API_KEY = os.getenv('LUMAAI_API_KEY')
RUNWAY_API_KEY = os.getenv('RUNWAY_API_KEY')
ELEVENLABS_API_KEY = os.getenv('ELEVENLABS_API_KEY')


class VideoGenerator:
    def __init__(self, output_dir='output'):
        self.output_dir = Path(output_dir)
        self.output_dir.mkdir(exist_ok=True)
        
    def generate_image_openai(self, prompt, size="1024x1024"):
        """Generate image using DALL-E 3"""
        if not OPENAI_API_KEY:
            raise ValueError("OPENAI_API_KEY not set")
            
        import openai
        client = openai.OpenAI(api_key=OPENAI_API_KEY)
        
        print(f"🎨 Generating image with DALL-E 3: {prompt[:50]}...")
        
        response = client.images.generate(
            model="dall-e-3",
            prompt=prompt,
            size=size,
            quality="standard",
            n=1,
        )
        
        image_url = response.data[0].url
        
        # Download image
        img_path = self.output_dir / f"image_{int(time.time())}.png"
        img_data = requests.get(image_url).content
        with open(img_path, 'wb') as f:
            f.write(img_data)
            
        print(f"✓ Image saved: {img_path}")
        return str(img_path)
    
    def generate_image_replicate(self, prompt, model="stability-ai/sdxl"):
        """Generate image using Replicate (Stable Diffusion, Flux, etc.)"""
        if not REPLICATE_API_TOKEN:
            raise ValueError("REPLICATE_API_TOKEN not set")
            
        import replicate
        
        print(f"🎨 Generating image with {model}: {prompt[:50]}...")
        
        output = replicate.run(
            model,
            input={"prompt": prompt}
        )
        
        # Download image
        img_path = self.output_dir / f"image_{int(time.time())}.png"
        if isinstance(output, list):
            img_data = requests.get(output[0]).content
        else:
            img_data = requests.get(output).content
            
        with open(img_path, 'wb') as f:
            f.write(img_data)
            
        print(f"✓ Image saved: {img_path}")
        return str(img_path)
    
    def image_to_video_luma(self, image_path, prompt=None):
        """Convert image to video using LumaAI"""
        if not LUMAAI_API_KEY:
            raise ValueError("LUMAAI_API_KEY not set")
            
        print(f"🎬 Creating video from image with LumaAI...")
        
        headers = {
            "Authorization": f"Bearer {LUMAAI_API_KEY}",
            "Content-Type": "application/json"
        }
        
        # Upload image and create video
        # This is a placeholder - actual LumaAI API structure may vary
        data = {
            "image": image_path,
            "prompt": prompt or "animate this image"
        }
        
        response = requests.post(
            "https://api.lumalabs.ai/dream-machine/v1/generations",
            headers=headers,
            json=data
        )
        
        if response.status_code != 200:
            raise Exception(f"LumaAI API error: {response.text}")
            
        generation_id = response.json()['id']
        
        # Poll for completion
        while True:
            status = requests.get(
                f"https://api.lumalabs.ai/dream-machine/v1/generations/{generation_id}",
                headers=headers
            ).json()
            
            if status['state'] == 'completed':
                video_url = status['video']['url']
                break
            elif status['state'] == 'failed':
                raise Exception(f"Video generation failed: {status}")
            
            print("⏳ Waiting for video generation...")
            time.sleep(5)
        
        # Download video
        video_path = self.output_dir / f"video_{int(time.time())}.mp4"
        video_data = requests.get(video_url).content
        with open(video_path, 'wb') as f:
            f.write(video_data)
            
        print(f"✓ Video saved: {video_path}")
        return str(video_path)
    
    def add_audio_openai(self, text, voice="alloy"):
        """Generate audio using OpenAI TTS"""
        if not OPENAI_API_KEY:
            raise ValueError("OPENAI_API_KEY not set")
            
        import openai
        client = openai.OpenAI(api_key=OPENAI_API_KEY)
        
        print(f"🎤 Generating voiceover: {text[:50]}...")
        
        response = client.audio.speech.create(
            model="tts-1",
            voice=voice,
            input=text
        )
        
        audio_path = self.output_dir / f"audio_{int(time.time())}.mp3"
        response.stream_to_file(str(audio_path))
        
        print(f"✓ Audio saved: {audio_path}")
        return str(audio_path)
    
    def combine_video_audio(self, video_path, audio_path, output_path):
        """Combine video and audio using FFmpeg"""
        import subprocess
        
        print(f"🎞️ Combining video and audio...")
        
        cmd = [
            'ffmpeg', '-y',
            '-i', video_path,
            '-i', audio_path,
            '-c:v', 'copy',
            '-c:a', 'aac',
            '-shortest',
            output_path
        ]
        
        result = subprocess.run(cmd, capture_output=True, text=True)
        
        if result.returncode != 0:
            raise Exception(f"FFmpeg error: {result.stderr}")
            
        print(f"✓ Final video saved: {output_path}")
        return output_path


def main():
    parser = argparse.ArgumentParser(description='Generate AI videos from text prompts')
    parser.add_argument('--prompt', required=True, help='Text prompt for video generation')
    parser.add_argument('--voiceover', help='Text for voiceover narration')
    parser.add_argument('--output', default='output.mp4', help='Output video file')
    parser.add_argument('--image-model', choices=['dalle', 'replicate'], default='dalle', help='Image generation model')
    parser.add_argument('--video-model', choices=['luma', 'runway'], default='luma', help='Video generation model')
    parser.add_argument('--voice', default='alloy', help='Voice for TTS (alloy, echo, fable, onyx, nova, shimmer)')
    
    args = parser.parse_args()
    
    try:
        generator = VideoGenerator()
        
        # Step 1: Generate image
        if args.image_model == 'dalle':
            image_path = generator.generate_image_openai(args.prompt)
        else:
            image_path = generator.generate_image_replicate(args.prompt)
        
        # Step 2: Convert to video
        if args.video_model == 'luma':
            video_path = generator.image_to_video_luma(image_path, args.prompt)
        else:
            print("⚠️ Runway support coming soon. Using Luma for now.")
            video_path = generator.image_to_video_luma(image_path, args.prompt)
        
        # Step 3: Add voiceover if requested
        if args.voiceover:
            audio_path = generator.add_audio_openai(args.voiceover, args.voice)
            final_path = generator.combine_video_audio(video_path, audio_path, args.output)
        else:
            # Just rename/move the video
            os.rename(video_path, args.output)
            final_path = args.output
        
        print(f"\n✅ SUCCESS! Video created: {final_path}")
        
    except Exception as e:
        print(f"\n❌ ERROR: {str(e)}")
        sys.exit(1)


if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
Convert image sequence to video using FFmpeg
"""

import argparse
import subprocess
import sys
from pathlib import Path


def images_to_video(image_files, output_path, fps=24, quality='high'):
    """Convert list of images to video"""
    
    # Quality presets
    crf_values = {
        'low': 28,
        'medium': 23,
        'high': 18,
        'ultra': 15
    }
    crf = crf_values.get(quality, 18)
    
    print(f"🎬 Creating video from {len(image_files)} images at {fps} fps...")
    
    # Create temporary file list
    file_list_path = Path('filelist.txt')
    with open(file_list_path, 'w') as f:
        for img in image_files:
            duration = 1.0 / fps
            f.write(f"file '{Path(img).absolute()}'\n")
            f.write(f"duration {duration}\n")
    
    # FFmpeg command
    cmd = [
        'ffmpeg', '-y',
        '-f', 'concat',
        '-safe', '0',
        '-i', str(file_list_path),
        '-vsync', 'vfr',
        '-pix_fmt', 'yuv420p',
        '-crf', str(crf),
        output_path
    ]
    
    try:
        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
        print(f"✅ Video created: {output_path}")
        return output_path
    except subprocess.CalledProcessError as e:
        print(f"❌ FFmpeg error: {e.stderr}")
        sys.exit(1)
    finally:
        # Clean up temp file
        if file_list_path.exists():
            file_list_path.unlink()


def main():
    parser = argparse.ArgumentParser(description='Convert images to video')
    parser.add_argument('--images', nargs='+', required=True, help='Input image files')
    parser.add_argument('--output', default='output.mp4', help='Output video file')
    parser.add_argument('--fps', type=int, default=24, help='Frames per second')
    parser.add_argument('--quality', choices=['low', 'medium', 'high', 'ultra'], 
                       default='high', help='Output quality')
    
    args = parser.parse_args()
    
    # Validate images exist
    for img in args.images:
        if not Path(img).exists():
            print(f"❌ Error: Image not found: {img}")
            sys.exit(1)
    
    images_to_video(args.images, args.output, args.fps, args.quality)


if __name__ == '__main__':
    main()

# Quick Start - Get Your First Video in 5 Minutes

## Step 1: Get OpenAI API Key (Required)

1. Go to https://platform.openai.com/api-keys
2. Sign up / Log in
3. Click "Create new secret key"
4. Copy the key (starts with `sk-`)

**Cost:** You'll need ~$5 credit. First video costs ~$0.10

## Step 2: Get LumaAI Key (Optional but Recommended)

1. Go to https://lumalabs.ai
2. Sign up (has free tier!)
3. Get API key from dashboard

**Cost:** FREE for first 30 videos/month

## Step 3: Configure

Create `.env` file:

```bash
cd skills/ai-video-gen
copy .env.example .env
```

Edit `.env` and add:
```
OPENAI_API_KEY=sk-your-actual-key-here
LUMAAI_API_KEY=luma_your-actual-key-here
```

## Step 4: Generate Video!

```bash
python generate_video.py --prompt "A peaceful forest with sunlight filtering through trees" --output forest.mp4
```

With narration:
```bash
python generate_video.py \
  --prompt "A robot walking through a futuristic city" \
  --voiceover "In the year 2050, robots walk among us" \
  --output robot.mp4
```

## What Happens

1. 🎨 Generates image from your prompt (DALL-E 3)
2. 🎬 Converts image to 5-second video (LumaAI)
3. 🎤 Creates voiceover if requested (OpenAI TTS)
4. ✅ Combines everything into final MP4

**Time:** 30-60 seconds per video
**Cost:** $0.05-0.15 per video

## Without LumaAI Key

If you don't have LumaAI yet, you can still:

**Create image + audio:**
```bash
python generate_video.py --prompt "sunset" --output sunset.mp4
# (Will fail at video step, but you'll have the image!)
```

**Convert images to video:**
```bash
python images_to_video.py --images img1.png img2.png img3.png --output result.mp4
```

## Next Steps

- Try different prompts
- Experiment with voices (alloy, echo, fable, onyx, nova, shimmer)
- Create longer videos by chaining scenes
- Add music and effects

Need help? Check `README.md` for full docs!

# AI Video Generator

Complete end-to-end AI video creation system.

## ✅ Installation Status

- [x] FFmpeg installed
- [x] Python 3.11.9 available
- [ ] Python dependencies (run `setup.bat`)
- [ ] API keys configured

## Quick Start

### 1. Install Dependencies

```bash
cd skills/ai-video-gen
pip install -r requirements.txt
```

Or run `setup.bat`

### 2. Configure API Keys

Copy `.env.example` to `.env` and add your keys:

```bash
copy .env.example .env
notepad .env
```

**Minimum required:**
- `OPENAI_API_KEY` - For both image (DALL-E) and voice (TTS)

**Optional but recommended:**
- `LUMAAI_API_KEY` - For video generation (has free tier!)
- `REPLICATE_API_TOKEN` - Alternative for images/video

### 3. Generate Your First Video

```bash
python generate_video.py --prompt "A serene mountain landscape at sunset" --output test.mp4
```

With voiceover:

```bash
python generate_video.py \
  --prompt "A futuristic city with flying cars" \
  --voiceover "Welcome to the future" \
  --output future.mp4
```

## What You Need to Sign Up For

### Free/Cheap Options (Start Here)

1. **OpenAI** - https://platform.openai.com
   - Get API key for DALL-E + TTS
   - Cost: ~$0.05-0.10 per video (image + voice)
   
2. **LumaAI** - https://lumalabs.ai
   - Free tier: 30 generations/month
   - Then $1-2 per video

**Total cost to start: $0-0.15 per video**

### Premium Options (Better Quality)

3. **Runway** - https://runwayml.com
   - Higher quality video generation
   - ~$0.50-1.00 per 5-second video

4. **ElevenLabs** - https://elevenlabs.io
   - Best voice quality
   - ~$0.30 per 1K characters

5. **Replicate** - https://replicate.com
   - Multiple AI models
   - Pay-per-use, very cheap

## Examples

### Simple Video
```bash
python generate_video.py --prompt "Ocean waves crashing" --output waves.mp4
```

### Multi-Image to Video
```bash
python images_to_video.py --images img1.png img2.png img3.png --output slideshow.mp4
```

### Add Narration to Existing Video
```bash
python add_voiceover.py --video input.mp4 --text "Your narration here" --output final.mp4
```

## Workflow

```
Text Prompt → DALL-E Image → LumaAI Video → + Voiceover → Final MP4
```

All automated in one command!

## Cost Calculator

**Budget Video (5 seconds):**
- Image (DALL-E): $0.04
- Video (LumaAI free): $0
- Voice (OpenAI TTS): $0.01
- **Total: $0.05**

**Quality Video (5 seconds):**
- Image (DALL-E): $0.08
- Video (Runway): $0.50
- Voice (ElevenLabs): $0.30
- **Total: $0.88**

## Troubleshooting

### FFmpeg not found
Restart your terminal after installation, or add to PATH manually.

### API Key errors
Make sure `.env` file exists and has valid keys (no quotes needed).

### Python module errors
Run `pip install -r requirements.txt`

## What's Next

The scripts are modular - you can:
- Use just image generation
- Use just video assembly from images
- Add effects and transitions
- Batch process multiple videos
- Create longer videos with scene transitions

Need help? Check the examples or ask!

openai>=1.0.0
replicate>=0.20.0
requests>=2.31.0
pillow>=10.0.0
python-dotenv>=1.0.0

---
name: ai-video-gen
description: End-to-end AI video generation - create videos from text prompts using image generation, video synthesis, voice-over, and editing. Supports OpenAI DALL-E, Replicate models, LumaAI, Runway, and FFmpeg editing.
---

# AI Video Generation Skill

Generate complete videos from text descriptions using AI.

## Capabilities

1. **Image Generation** - DALL-E 3, Stable Diffusion, Flux
2. **Video Generation** - LumaAI, Runway, Replicate models
3. **Voice-over** - OpenAI TTS, ElevenLabs
4. **Video Editing** - FFmpeg assembly, transitions, overlays

## Quick Start

```bash
# Generate a complete video
python skills/ai-video-gen/generate_video.py --prompt "A sunset over mountains" --output sunset.mp4

# Just images to video
python skills/ai-video-gen/images_to_video.py --images img1.png img2.png --output result.mp4

# Add voiceover
python skills/ai-video-gen/add_voiceover.py --video input.mp4 --text "Your narration" --output final.mp4
```

## Setup

### Required API Keys

Add to your environment or `.env` file:

```bash
# Image Generation (pick one)
OPENAI_API_KEY=sk-...              # DALL-E 3
REPLICATE_API_TOKEN=r8_...         # Stable Diffusion, Flux

# Video Generation (pick one)
LUMAAI_API_KEY=luma_...           # LumaAI Dream Machine
RUNWAY_API_KEY=...                # Runway ML
REPLICATE_API_TOKEN=r8_...        # Multiple models

# Voice (optional)
OPENAI_API_KEY=sk-...             # OpenAI TTS
ELEVENLABS_API_KEY=...            # ElevenLabs

# Or use FREE local options (no API needed)
```

### Install Dependencies

```bash
pip install openai requests pillow replicate python-dotenv
```

### FFmpeg

Already installed via winget.

## Usage Examples

### 1. Text to Video (Full Pipeline)

```bash
python skills/ai-video-gen/generate_video.py \
  --prompt "A futuristic city at night with flying cars" \
  --duration 5 \
  --voiceover "Welcome to the future" \
  --output future_city.mp4
```

### 2. Multiple Scenes

```bash
python skills/ai-video-gen/multi_scene.py \
  --scenes "Morning sunrise" "Busy city street" "Peaceful night" \
  --duration 3 \
  --output day_in_life.mp4
```

### 3. Image Sequence to Video

```bash
python skills/ai-video-gen/images_to_video.py \
  --images frame1.png frame2.png frame3.png \
  --fps 24 \
  --output animation.mp4
```

## Workflow Options

### Budget Mode (FREE)
- Image: Stable Diffusion (local or free API)
- Video: Open source models
- Voice: OpenAI TTS (cheap) or free TTS
- Edit: FFmpeg

### Quality Mode (Paid)
- Image: DALL-E 3 or Midjourney
- Video: Runway Gen-3 or LumaAI
- Voice: ElevenLabs
- Edit: FFmpeg + effects

## Scripts Reference

- `generate_video.py` - Main end-to-end generator
- `images_to_video.py` - Convert image sequence to video
- `add_voiceover.py` - Add narration to existing video
- `multi_scene.py` - Create multi-scene videos
- `edit_video.py` - Apply effects, transitions, overlays

## API Cost Estimates

- **DALL-E 3**: ~$0.04-0.08 per image
- **Replicate**: ~$0.01-0.10 per generation
- **LumaAI**: $0-0.50 per 5sec (free tier available)
- **Runway**: ~$0.05 per second
- **OpenAI TTS**: ~$0.015 per 1K characters
- **ElevenLabs**: ~$0.30 per 1K characters (better quality)

## Examples

See `examples/` folder for sample outputs and prompts.

{
  "ownerId": "kn747x18c43nyxamce13qxa0hn8043pt",
  "slug": "ai-video-gen",
  "version": "1.0.0",
  "publishedAt": 1769686950506
}