@hasna/skills 0.1.26 → 0.1.29

package/skills/transcript/src/providers/openai.ts

@@ -1,203 +0,0 @@
-/**
- * OpenAI Whisper Provider
- * Industry-standard speech-to-text with automatic chunking for large files
- */
-
-import type {
-  TranscriptionProvider,
-  TranscriptionOptions,
-  TranscriptionResult,
-  TranscriptionSegment,
-  OpenAITranscriptionResponse
-} from '../types';
-import {
-  needsChunking,
-  splitAudioFile,
-  mergeTranscriptions,
-  cleanupChunks,
-  compressAudio,
-  getFileSize
-} from '../chunker';
-import { dirname, join, basename, extname } from 'path';
-
-// OpenAI Whisper has a 25MB limit
-const MAX_FILE_SIZE = 25 * 1024 * 1024; // 25MB
-
-export class OpenAIProvider implements TranscriptionProvider {
-  name = 'OpenAI Whisper';
-  maxFileSize = MAX_FILE_SIZE;
-  supportedFormats = ['mp3', 'mp4', 'mpeg', 'mpga', 'm4a', 'wav', 'webm'];
-
-  private apiKey: string;
-  private baseUrl = 'https://api.openai.com/v1';
-
-  constructor() {
-    const apiKey = process.env.OPENAI_API_KEY;
-    if (!apiKey) {
-      throw new Error('OPENAI_API_KEY environment variable is required');
-    }
-    this.apiKey = apiKey;
-  }
-
-  async transcribe(options: TranscriptionOptions): Promise<TranscriptionResult> {
-    const {
-      input,
-      language,
-      model = 'whisper-1',
-      timestamps = true
-    } = options;
-
-    console.log(`[OpenAI] Transcribing: ${input}`);
-    console.log(`[OpenAI] Model: ${model}`);
-
-    // Check if file needs chunking
-    const fileSize = await getFileSize(input);
-    console.log(`[OpenAI] File size: ${(fileSize / 1024 / 1024).toFixed(2)}MB`);
-
-    if (fileSize > this.maxFileSize) {
-      console.log(`[OpenAI] File exceeds 25MB limit, chunking required`);
-      return this.transcribeWithChunking(options);
-    }
-
-    return this.transcribeSingle(options);
-  }
-
-  private async transcribeSingle(options: TranscriptionOptions): Promise<TranscriptionResult> {
-    const {
-      input,
-      language,
-      model = 'whisper-1',
-      timestamps = true
-    } = options;
-
-    // Read the file
-    const file = Bun.file(input);
-    const fileBuffer = await file.arrayBuffer();
-
-    // Create form data
-    const formData = new FormData();
-    formData.append('file', new Blob([fileBuffer]), input.split('/').pop());
-    formData.append('model', model);
-    formData.append('response_format', timestamps ? 'verbose_json' : 'json');
-
-    if (language) {
-      formData.append('language', language);
-    }
-
-    if (timestamps) {
-      formData.append('timestamp_granularities[]', 'segment');
-      formData.append('timestamp_granularities[]', 'word');
-    }
-
-    const response = await fetch(`${this.baseUrl}/audio/transcriptions`, {
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${this.apiKey}`
-      },
-      body: formData
-    });
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`OpenAI transcription failed: ${error}`);
-    }
-
-    const data = await response.json() as OpenAITranscriptionResponse;
-    console.log(`[OpenAI] Transcription complete`);
-
-    return this.formatResult(data, model);
-  }
-
-  private async transcribeWithChunking(options: TranscriptionOptions): Promise<TranscriptionResult> {
-    const { input, model = 'whisper-1' } = options;
-    const outputDir = dirname(input);
-
-    // First try compression
-    const compressedPath = join(outputDir, `.compressed_${basename(input, extname(input))}.ogg`);
-
-    try {
-      console.log('[OpenAI] Attempting compression first...');
-      await compressAudio(input, compressedPath, '32k');
-      const compressedSize = await getFileSize(compressedPath);
-
-      if (compressedSize <= this.maxFileSize) {
-        console.log('[OpenAI] Compressed file is under 25MB, transcribing directly');
-        const result = await this.transcribeSingle({
-          ...options,
-          input: compressedPath
-        });
-
-        // Cleanup compressed file
-        await Bun.write(compressedPath, '').catch(() => {});
-
-        return result;
-      }
-    } catch {
-      console.log('[OpenAI] Compression failed or still too large, falling back to chunking');
-    }
-
-    // Split into chunks
-    const chunks = await splitAudioFile(input, outputDir);
-    const transcriptions: string[] = [];
-    const allSegments: TranscriptionSegment[] = [];
-
-    try {
-      // Process chunks sequentially to maintain order
-      for (const chunk of chunks) {
-        console.log(`[OpenAI] Processing chunk ${chunk.index + 1}/${chunks.length}`);
-
-        const result = await this.transcribeSingle({
-          ...options,
-          input: chunk.path
-        });
-
-        transcriptions.push(result.text);
-
-        // Adjust segment timestamps based on chunk start time
-        if (result.segments) {
-          for (const segment of result.segments) {
-            allSegments.push({
-              ...segment,
-              id: allSegments.length,
-              start: segment.start + chunk.startTime,
-              end: segment.end + chunk.startTime
-            });
-          }
-        }
-      }
-
-      // Merge transcriptions
-      const mergedText = mergeTranscriptions(transcriptions);
-
-      return {
-        text: mergedText,
-        segments: allSegments.length > 0 ? allSegments : undefined,
-        model,
-        provider: 'openai'
-      };
-    } finally {
-      // Cleanup chunks
-      const chunkDir = join(outputDir, '.chunks');
-      await cleanupChunks(chunkDir);
-    }
-  }
-
-  private formatResult(data: OpenAITranscriptionResponse, model: string): TranscriptionResult {
-    const segments: TranscriptionSegment[] = data.segments?.map((seg, i) => ({
-      id: i,
-      start: seg.start,
-      end: seg.end,
-      text: seg.text.trim(),
-      confidence: 1 - seg.no_speech_prob
-    })) || [];
-
-    return {
-      text: data.text,
-      segments: segments.length > 0 ? segments : undefined,
-      duration: data.duration,
-      language: data.language,
-      model,
-      provider: 'openai'
-    };
-  }
-}

package/skills/transcript/src/types.ts

@@ -1,106 +0,0 @@
-/**
- * Types for transcript
- * Audio/video transcription with automatic chunking
- */
-
-export type Provider = 'elevenlabs' | 'openai' | 'gemini';
-
-export interface TranscriptionOptions {
-  input: string;
-  output?: string;
-  provider: Provider;
-  language?: string;
-  model?: string;
-  diarize?: boolean; // Speaker diarization
-  timestamps?: boolean;
-  format?: 'text' | 'srt' | 'vtt' | 'json';
-}
-
-export interface TranscriptionResult {
-  text: string;
-  segments?: TranscriptionSegment[];
-  speakers?: Speaker[];
-  duration?: number;
-  language?: string;
-  model?: string;
-  provider: Provider;
-}
-
-export interface TranscriptionSegment {
-  id: number;
-  start: number;
-  end: number;
-  text: string;
-  speaker?: string;
-  confidence?: number;
-}
-
-export interface Speaker {
-  id: string;
-  name?: string;
-  segments: number[];
-}
-
-export interface ChunkInfo {
-  index: number;
-  startTime: number;
-  endTime: number;
-  path: string;
-  size: number;
-}
-
-export interface TranscriptionProvider {
-  name: string;
-  maxFileSize: number; // in bytes
-  supportedFormats: string[];
-  transcribe(options: TranscriptionOptions): Promise<TranscriptionResult>;
-}
-
-// Provider-specific response types
-export interface ElevenLabsResponse {
-  text: string;
-  words?: Array<{
-    word: string;
-    start: number;
-    end: number;
-    speaker?: string;
-  }>;
-  speakers?: Array<{
-    speaker_id: string;
-    name?: string;
-  }>;
-}
-
-export interface OpenAITranscriptionResponse {
-  text: string;
-  task?: string;
-  language?: string;
-  duration?: number;
-  segments?: Array<{
-    id: number;
-    seek: number;
-    start: number;
-    end: number;
-    text: string;
-    tokens: number[];
-    temperature: number;
-    avg_logprob: number;
-    compression_ratio: number;
-    no_speech_prob: number;
-  }>;
-  words?: Array<{
-    word: string;
-    start: number;
-    end: number;
-  }>;
-}
-
-export interface GeminiResponse {
-  candidates: Array<{
-    content: {
-      parts: Array<{
-        text: string;
-      }>;
-    };
-  }>;
-}

package/skills/video/.env.example

@@ -1,14 +0,0 @@
-# Google Veo 2 (Vertex AI)
-# Option 1: Use API key
-GOOGLE_API_KEY=your_google_api_key_here
-
-# Option 2: Use service account
-GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
-GOOGLE_CLOUD_PROJECT=your-project-id
-GOOGLE_CLOUD_LOCATION=us-central1
-
-# OpenAI Sora
-OPENAI_API_KEY=your_openai_api_key_here
-
-# Runway
-RUNWAY_API_KEY=your_runway_api_key_here

package/skills/video/EXAMPLES.md

@@ -1,266 +0,0 @@
-# Video Generation Examples
-
-This document provides real-world examples for using the video generation skill.
-
-## Quick Start
-
-### 1. Basic Video Generation
-
-```bash
-# Simple prompt with Runway (fastest)
-bun run src/index.ts generate \
-  --provider runway \
-  --prompt "a dog running through a field" \
-  --output ./dog.mp4
-```
-
-### 2. Check Status
-
-```bash
-# After generation starts, check status with the returned job ID
-bun run src/index.ts status \
-  --provider runway \
-  --job-id <your-job-id>
-```
-
-## Provider-Specific Examples
-
-### Google Veo 2 - Cinematic Videos
-
-```bash
-# Wide-angle landscape shot
-bun run src/index.ts generate \
-  --provider google \
-  --prompt "wide-angle shot of misty mountains at dawn, slow camera dolly forward" \
-  --resolution 4k \
-  --duration 5 \
-  --output ./mountains.mp4
-
-# Close-up with specific lens
-bun run src/index.ts generate \
-  --provider google \
-  --prompt "macro lens close-up of water droplets on a leaf, shallow depth of field" \
-  --resolution 1080p \
-  --output ./droplets.mp4
-
-# Camera movement
-bun run src/index.ts generate \
-  --provider google \
-  --prompt "drone shot flying over a forest, ascending movement, golden hour lighting" \
-  --resolution 4k \
-  --output ./forest-drone.mp4
-```
-
-### OpenAI Sora - Creative Scenes
-
-```bash
-# Stylized animation
-bun run src/index.ts generate \
-  --provider openai \
-  --prompt "a person walking through a neon-lit cyberpunk city at night" \
-  --resolution 1080p \
-  --output ./cyberpunk.mp4
-
-# Natural scene
-bun run src/index.ts generate \
-  --provider openai \
-  --prompt "waves crashing on a beach during sunset, slow motion" \
-  --duration 8 \
-  --output ./waves.mp4
-```
-
-### Runway - Fast Generation
-
-```bash
-# Product shot
-bun run src/index.ts generate \
-  --provider runway \
-  --prompt "rotating product shot of a modern smartphone on a clean white background" \
-  --aspect-ratio 1:1 \
-  --output ./product.mp4
-
-# Social media content (vertical)
-bun run src/index.ts generate \
-  --provider runway \
-  --prompt "coffee being poured into a cup, steam rising" \
-  --aspect-ratio 9:16 \
-  --duration 5 \
-  --output ./coffee-vertical.mp4
-
-# Landscape (horizontal)
-bun run src/index.ts generate \
-  --provider runway \
-  --prompt "time-lapse of clouds moving over a city skyline" \
-  --aspect-ratio 16:9 \
-  --duration 10 \
-  --output ./timelapse.mp4
-```
-
-## Advanced Techniques
-
-### High-Quality Cinematic Prompts (Google Veo 2)
-
-Google Veo 2 understands professional cinematography terms. Use these for better results:
-
-```bash
-# Lens types
-- "wide-angle lens"
-- "telephoto lens"
-- "macro lens"
-- "fisheye lens"
-
-# Camera movements
-- "dolly forward/backward"
-- "pan left/right"
-- "tilt up/down"
-- "crane shot"
-- "steadicam tracking shot"
-- "drone shot ascending/descending"
-
-# Depth of field
-- "shallow depth of field" (blurred background)
-- "deep depth of field" (everything in focus)
-
-# Lighting
-- "golden hour lighting"
-- "blue hour"
-- "hard lighting"
-- "soft diffused lighting"
-- "rim lighting"
-- "dramatic side lighting"
-```
-
-Example combining multiple techniques:
-
-```bash
-bun run src/index.ts generate \
-  --provider google \
-  --prompt "telephoto lens shot of a bird in flight, shallow depth of field with blurred background, golden hour warm lighting, slow-motion, tracking camera movement following the bird" \
-  --resolution 4k \
-  --duration 5 \
-  --output ./bird-cinematic.mp4
-```
-
-### Aspect Ratios for Different Platforms
-
-```bash
-# Instagram Stories / TikTok (vertical)
---aspect-ratio 9:16
-
-# YouTube / Standard video (horizontal)
---aspect-ratio 16:9
-
-# Instagram Feed (square)
---aspect-ratio 1:1
-```
-
-### Resolution Guidelines
-
-```bash
-# Web preview / draft
---resolution 720p
-
-# Standard quality / social media
---resolution 1080p
-
-# High quality / professional (Google Veo 2)
---resolution 4k
-```
-
-## Workflow Examples
-
-### Complete Workflow with Status Checking
-
-```bash
-# 1. Start generation
-bun run src/index.ts generate \
-  --provider runway \
-  --prompt "ocean sunset with sailboat" \
-  --output ./sunset.mp4
-
-# Output: Job ID: runway_1234567890_abc
-
-# 2. Check status (wait 10-30 seconds between checks)
-bun run src/index.ts status \
-  --provider runway \
-  --job-id runway_1234567890_abc
-
-# 3. Video automatically downloads when complete
-```
-
-### Batch Generation
-
-```bash
-# Generate multiple videos with different prompts
-for prompt in "forest path" "city street" "ocean waves"; do
-  bun run src/index.ts generate \
-    --provider runway \
-    --prompt "$prompt" \
-    --output "./${prompt// /-}.mp4"
-done
-```
-
-## Tips for Best Results
-
-1. **Be Specific**: More detailed prompts yield better results
-   - Bad: "a car"
-   - Good: "a red sports car driving on a coastal highway at sunset"
-
-2. **Describe Motion**: Explicitly mention the action or movement
-   - "person walking slowly"
-   - "camera panning across the scene"
-   - "leaves falling gently"
-
-3. **Set the Scene**: Include environment and lighting details
-   - "in a modern office with natural window light"
-   - "at night with neon signs"
-   - "during golden hour with warm tones"
-
-4. **Duration**: Start with 5 seconds, increase if needed
-   - Short videos (3-5s) generate faster
-   - Longer videos (8-10s) allow more complex scenes
-
-5. **Resolution**: Match your use case
-   - Social media: 1080p is sufficient
-   - Professional work: 4k if available
-
-## Troubleshooting
-
-### Generation Takes Too Long
-- Try a shorter duration (3-5 seconds)
-- Use a different provider (Runway is typically fastest)
-- Simplify your prompt
-
-### Video Quality Issues
-- Increase resolution to 1080p or 4k
-- Add lighting details to your prompt
-- For Google Veo 2, add cinematography terms
-
-### API Errors
-- Check your API keys in `.env`
-- Verify API access for your provider
-- Check rate limits (wait and retry)
-
-## Getting API Keys
-
-### Google Veo 2
-1. Go to [Google Cloud Console](https://console.cloud.google.com)
-2. Enable Vertex AI API
-3. Create service account or API key
-4. Set `GOOGLE_CLOUD_PROJECT` environment variable
-
-### OpenAI Sora
-1. Join the [OpenAI API waitlist](https://openai.com/sora)
-2. Note: API access may be limited
-
-### Runway
-1. Sign up at [Runway](https://runwayml.com)
-2. Generate API key from dashboard
-3. Check [API documentation](https://docs.runwayml.com)
-
-## Support
-
-For issues or questions:
-- Check the README.md for setup instructions
-- Review SKILL.md for skill details
-- Verify your API keys and environment variables