@hasna/skills 0.1.26 → 0.1.29

package/skills/video/src/index.ts

@@ -1,96 +0,0 @@
-#!/usr/bin/env bun
-
-import { executeAndSave, executeSkill, handleInstallCommand } from "../../_common";
-
-const SKILL = "video";
-
-const SKILL_META = {
-  name: "video",
-  description: "Generate videos using provider-cost AI backends",
-  version: "1.0.0",
-  commands: "video generate --provider <provider> --prompt <prompt> --output <file>",
-  requiredEnvVars: ["SKILL_API_KEY"],
-};
-
-if (await handleInstallCommand(SKILL_META, process.argv.slice(2))) {
-  process.exit(0);
-}
-
-function parseArgs(): Record<string, string | boolean> {
-  const parsed: Record<string, string | boolean> = {};
-  const args = process.argv.slice(2);
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg.startsWith("--")) {
-      const key = arg.slice(2);
-      const next = args[i + 1];
-      if (next && !next.startsWith("--")) {
-        parsed[key] = next;
-        i++;
-      } else {
-        parsed[key] = true;
-      }
-    } else if (!parsed.command) {
-      parsed.command = arg;
-    }
-  }
-  return parsed;
-}
-
-function printHelp() {
-  console.log(`Skill Video CLI
-
-USAGE:
-  video generate --provider <provider> --prompt <prompt> [options]
-
-PROVIDERS:
-  openai     sora-2, sora-2-pro
-  minimax    MiniMax-Hailuo-2.3-Fast, MiniMax-Hailuo-2.3
-  gemini     veo-3.1-fast-generate-preview, veo-3.1-generate-preview
-  seedance   dreamina-seedance-2.0, dreamina-seedance-2.0-fast
-
-OPTIONS:
-  --model <model>        Provider model override
-  --duration <seconds>   Requested duration
-  --image <path-or-url>  Optional reference image
-  --size <value>         Provider-specific size/aspect ratio
-  --output <path>        Save generated video
-
-EXAMPLES:
-  video generate --provider seedance --prompt "cinematic product reveal" --duration 6 --output ./video.mp4
-  video generate --provider openai --model sora-2 --prompt "aerial city sunrise" --output ./video.mp4`);
-}
-
-async function main() {
-  const args = parseArgs();
-  const command = (args.command as string) || "help";
-
-  if (command === "help" || args.help) {
-    printHelp();
-    return;
-  }
-
-  const { command: _command, ...params } = args;
-  if (params.output) {
-    const success = await executeAndSave({ skill: SKILL, command, ...params });
-    process.exit(success ? 0 : 1);
-  }
-
-  const result = await executeSkill({ skill: SKILL, command, ...params });
-  if (result instanceof Blob) {
-    console.error("Unexpected binary response. Pass --output to save video output.");
-    process.exit(1);
-  }
-  if (result.success && result.output) {
-    console.log(result.output);
-    return;
-  }
-  console.error(`Error: ${result.error || "Video generation failed"}`);
-  if (result.details) console.error(result.details);
-  process.exit(1);
-}
-
-main().catch((error) => {
-  console.error(`Fatal error: ${(error as Error).message}`);
-  process.exit(1);
-});

package/skills/video/src/providers/google-veo.ts

@@ -1,126 +0,0 @@
-import { VertexAI } from '@google-cloud/vertexai';
-import type { VideoProvider, GenerateOptions, VideoJob } from '../types';
-import { writeFile } from 'fs/promises';
-
-export class GoogleVeoProvider implements VideoProvider {
-  name = 'Google Veo 3.1';
-  private vertexAI: VertexAI;
-  private jobs: Map<string, VideoJob> = new Map();
-
-  constructor() {
-    // Initialize Vertex AI
-    const projectId = process.env.GOOGLE_CLOUD_PROJECT || 'your-project-id';
-    const location = process.env.GOOGLE_CLOUD_LOCATION || 'us-central1';
-
-    this.vertexAI = new VertexAI({
-      project: projectId,
-      location: location,
-    });
-  }
-
-  async generate(options: GenerateOptions): Promise<VideoJob> {
-    console.log(`[${this.name}] Starting video generation...`);
-    console.log(`Prompt: "${options.prompt}"`);
-
-    try {
-      // Generate a unique job ID
-      const jobId = `veo_${Date.now()}_${Math.random().toString(36).substring(7)}`;
-
-      // Initialize job status
-      const job: VideoJob = {
-        jobId,
-        status: 'processing',
-        progress: 0,
-      };
-      this.jobs.set(jobId, job);
-
-      // Get the generative model
-      // Veo 3.1 - Google's latest video generation model
-      const model = this.vertexAI.preview.getGenerativeModel({
-        model: 'veo-3.1',
-      });
-
-      // Prepare the prompt with cinematography hints if applicable
-      let enhancedPrompt = options.prompt;
-
-      // Add resolution hint
-      if (options.resolution) {
-        const resMap = { '720p': '1280x720', '1080p': '1920x1080', '4k': '3840x2160' };
-        enhancedPrompt += ` (${resMap[options.resolution]} resolution)`;
-      }
-
-      // Generate video
-      console.log(`[${this.name}] Sending request to Vertex AI...`);
-
-      // Note: This is a placeholder for the actual API call
-      // The real implementation depends on the final Veo 2 API structure
-      const result = await model.generateContent({
-        contents: [{
-          role: 'user',
-          parts: [{
-            text: enhancedPrompt,
-          }],
-        }],
-        generationConfig: {
-          temperature: 0.7,
-        },
-      });
-
-      // Update job with result
-      // In reality, Veo 2 will likely return a job ID for async processing
-      job.status = 'completed';
-      job.progress = 100;
-
-      // Extract video URL from response
-      // This is a placeholder - actual implementation will depend on API response structure
-      const response = result.response;
-      job.videoUrl = 'https://storage.googleapis.com/generated-video-url'; // Placeholder
-
-      this.jobs.set(jobId, job);
-
-      console.log(`[${this.name}] Video generation initiated. Job ID: ${jobId}`);
-      console.log(`Note: Google Veo 2 API is in preview. This is a reference implementation.`);
-
-      return job;
-
-    } catch (error) {
-      console.error(`[${this.name}] Error:`, error);
-      throw new Error(`Failed to generate video: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-
-  async getStatus(jobId: string): Promise<VideoJob> {
-    const job = this.jobs.get(jobId);
-
-    if (!job) {
-      throw new Error(`Job ${jobId} not found`);
-    }
-
-    // In a real implementation, this would query the Vertex AI API
-    // for the actual job status
-    console.log(`[${this.name}] Job ${jobId} status: ${job.status}`);
-
-    return job;
-  }
-
-  async download(videoUrl: string, outputPath: string): Promise<void> {
-    console.log(`[${this.name}] Downloading video to ${outputPath}...`);
-
-    try {
-      const response = await fetch(videoUrl);
-
-      if (!response.ok) {
-        throw new Error(`Failed to download: ${response.statusText}`);
-      }
-
-      const arrayBuffer = await response.arrayBuffer();
-      const buffer = Buffer.from(arrayBuffer);
-
-      await writeFile(outputPath, buffer);
-
-      console.log(`[${this.name}] Video downloaded successfully!`);
-    } catch (error) {
-      throw new Error(`Download failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-}

package/skills/video/src/providers/index.ts

@@ -1,22 +0,0 @@
-import type { Provider, VideoProvider } from '../types';
-import { MinimaxProvider } from './minimax';
-import { GoogleVeoProvider } from './google-veo';
-import { OpenAISoraProvider } from './openai-sora';
-import { RunwayProvider } from './runway';
-
-export function getProvider(provider: Provider): VideoProvider {
-  switch (provider) {
-    case 'minimax':
-      return new MinimaxProvider();
-    case 'google':
-      return new GoogleVeoProvider();
-    case 'openai':
-      return new OpenAISoraProvider();
-    case 'runway':
-      return new RunwayProvider();
-    default:
-      throw new Error(`Unknown provider: ${provider}`);
-  }
-}
-
-export { MinimaxProvider, GoogleVeoProvider, OpenAISoraProvider, RunwayProvider };

package/skills/video/src/providers/minimax.ts

@@ -1,100 +0,0 @@
-import type { VideoProvider, GenerateOptions, VideoJob } from '../types';
-import { writeFile } from 'fs/promises';
-
-export class MinimaxProvider implements VideoProvider {
-  name = 'Minimax Video-01';
-  private apiKey: string;
-  private baseUrl = 'https://api.minimax.chat/v1';
-
-  constructor() {
-    this.apiKey = process.env.MINIMAX_API_KEY || '';
-    if (!this.apiKey) {
-      throw new Error('MINIMAX_API_KEY environment variable is required');
-    }
-  }
-
-  async generate(options: GenerateOptions): Promise<VideoJob> {
-    console.log(`[${this.name}] Starting video generation...`);
-    console.log(`Prompt: "${options.prompt}"`);
-
-    const body: Record<string, unknown> = {
-      model: 'T2V-01',
-      prompt: options.prompt,
-      prompt_optimizer: true,
-    };
-
-    const response = await fetch(`${this.baseUrl}/video_generation`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${this.apiKey}`,
-      },
-      body: JSON.stringify(body),
-    });
-
-    if (!response.ok) {
-      const err = await response.text();
-      throw new Error(`Minimax API error: ${response.status} - ${err}`);
-    }
-
-    const data = await response.json() as { task_id: string };
-
-    return {
-      jobId: data.task_id,
-      status: 'processing',
-      progress: 0,
-    };
-  }
-
-  async getStatus(jobId: string): Promise<VideoJob> {
-    const response = await fetch(
-      `${this.baseUrl}/query/video_generation?task_id=${jobId}`,
-      { headers: { 'Authorization': `Bearer ${this.apiKey}` } }
-    );
-
-    const data = await response.json() as {
-      task_id: string;
-      status: string;
-      file_id?: string;
-      base_resp?: { status_msg: string };
-    };
-
-    if (data.status === 'Success' && data.file_id) {
-      const fileRes = await fetch(
-        `${this.baseUrl}/files/retrieve?file_id=${data.file_id}`,
-        { headers: { 'Authorization': `Bearer ${this.apiKey}` } }
-      );
-      const fileData = await fileRes.json() as { file: { download_url: string } };
-
-      return {
-        jobId,
-        status: 'completed',
-        progress: 100,
-        videoUrl: fileData.file.download_url,
-      };
-    }
-
-    if (data.status === 'Fail') {
-      return {
-        jobId,
-        status: 'failed',
-        error: data.base_resp?.status_msg || 'Unknown error',
-      };
-    }
-
-    return {
-      jobId,
-      status: 'processing',
-      progress: data.status === 'Processing' ? 50 : 10,
-    };
-  }
-
-  async download(videoUrl: string, outputPath: string): Promise<void> {
-    console.log(`[${this.name}] Downloading video to ${outputPath}...`);
-    const response = await fetch(videoUrl);
-    if (!response.ok) throw new Error(`Download failed: ${response.statusText}`);
-    const buffer = Buffer.from(await response.arrayBuffer());
-    await writeFile(outputPath, buffer);
-    console.log(`[${this.name}] Video downloaded.`);
-  }
-}

package/skills/video/src/providers/openai-sora.ts

@@ -1,164 +0,0 @@
-import type { VideoProvider, GenerateOptions, VideoJob } from '../types';
-import { writeFile } from 'fs/promises';
-
-export class OpenAISoraProvider implements VideoProvider {
-  name = 'OpenAI Sora';
-  private apiKey: string;
-  private baseUrl = 'https://api.openai.com/v1';
-  private jobs: Map<string, VideoJob> = new Map();
-
-  constructor() {
-    const apiKey = process.env.OPENAI_API_KEY;
-    if (!apiKey) {
-      throw new Error('OPENAI_API_KEY environment variable is required');
-    }
-    this.apiKey = apiKey;
-  }
-
-  async generate(options: GenerateOptions): Promise<VideoJob> {
-    console.log(`[${this.name}] Starting video generation...`);
-    console.log(`Prompt: "${options.prompt}"`);
-
-    try {
-      // Generate a unique job ID
-      const jobId = `sora_${Date.now()}_${Math.random().toString(36).substring(7)}`;
-
-      // Note: OpenAI Sora API structure is not publicly documented yet
-      // This is a reference implementation based on expected patterns
-      const response = await fetch(`${this.baseUrl}/videos/generations`, {
-        method: 'POST',
-        headers: {
-          'Authorization': `Bearer ${this.apiKey}`,
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-          model: 'sora-1.0', // Placeholder model name
-          prompt: options.prompt,
-          duration: options.duration || 5,
-          resolution: options.resolution || '1080p',
-          aspect_ratio: options.aspectRatio || '16:9',
-        }),
-      });
-
-      if (!response.ok) {
-        const error = await response.text();
-        throw new Error(`API request failed: ${response.status} - ${error}`);
-      }
-
-      const data = await response.json() as {
-        id: string;
-        status: string;
-        video_url?: string;
-      };
-
-      const job: VideoJob = {
-        jobId: data.id || jobId,
-        status: this.mapStatus(data.status),
-        progress: data.status === 'completed' ? 100 : 0,
-        videoUrl: data.video_url,
-      };
-
-      this.jobs.set(job.jobId, job);
-
-      console.log(`[${this.name}] Video generation initiated. Job ID: ${job.jobId}`);
-      console.log(`Note: OpenAI Sora API access may be limited. Check API availability.`);
-
-      return job;
-
-    } catch (error) {
-      console.error(`[${this.name}] Error:`, error);
-
-      // If API is not available, provide helpful message
-      if (error instanceof Error && error.message.includes('404')) {
-        throw new Error('OpenAI Sora API is not yet publicly available. Please check API access or try another provider.');
-      }
-
-      throw new Error(`Failed to generate video: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-
-  async getStatus(jobId: string): Promise<VideoJob> {
-    console.log(`[${this.name}] Checking status for job ${jobId}...`);
-
-    try {
-      const response = await fetch(`${this.baseUrl}/videos/generations/${jobId}`, {
-        headers: {
-          'Authorization': `Bearer ${this.apiKey}`,
-        },
-      });
-
-      if (!response.ok) {
-        const error = await response.text();
-        throw new Error(`API request failed: ${response.status} - ${error}`);
-      }
-
-      const data = await response.json() as {
-        id: string;
-        status: string;
-        progress?: number;
-        video_url?: string;
-        error?: string;
-      };
-
-      const job: VideoJob = {
-        jobId: data.id,
-        status: this.mapStatus(data.status),
-        progress: data.progress || (data.status === 'completed' ? 100 : 0),
-        videoUrl: data.video_url,
-        error: data.error,
-      };
-
-      this.jobs.set(jobId, job);
-
-      return job;
-
-    } catch (error) {
-      // Return cached job if API fails
-      const cachedJob = this.jobs.get(jobId);
-      if (cachedJob) {
-        return cachedJob;
-      }
-
-      throw new Error(`Failed to get status: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-
-  async download(videoUrl: string, outputPath: string): Promise<void> {
-    console.log(`[${this.name}] Downloading video to ${outputPath}...`);
-
-    try {
-      const response = await fetch(videoUrl, {
-        headers: {
-          'Authorization': `Bearer ${this.apiKey}`,
-        },
-      });
-
-      if (!response.ok) {
-        throw new Error(`Failed to download: ${response.statusText}`);
-      }
-
-      const arrayBuffer = await response.arrayBuffer();
-      const buffer = Buffer.from(arrayBuffer);
-
-      await writeFile(outputPath, buffer);
-
-      console.log(`[${this.name}] Video downloaded successfully!`);
-    } catch (error) {
-      throw new Error(`Download failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-
-  private mapStatus(status: string): VideoJob['status'] {
-    const statusMap: Record<string, VideoJob['status']> = {
-      'pending': 'pending',
-      'processing': 'processing',
-      'in_progress': 'processing',
-      'completed': 'completed',
-      'succeeded': 'completed',
-      'failed': 'failed',
-      'error': 'failed',
-    };
-
-    return statusMap[status.toLowerCase()] || 'pending';
-  }
-}

package/skills/video/src/providers/runway.ts

@@ -1,159 +0,0 @@
-import type { VideoProvider, GenerateOptions, VideoJob } from '../types';
-import { writeFile } from 'fs/promises';
-
-export class RunwayProvider implements VideoProvider {
-  name = 'Runway';
-  private apiKey: string;
-  private baseUrl = 'https://api.runwayml.com/v1';
-
-  constructor() {
-    const apiKey = process.env.RUNWAY_API_KEY;
-    if (!apiKey) {
-      throw new Error('RUNWAY_API_KEY environment variable is required');
-    }
-    this.apiKey = apiKey;
-  }
-
-  async generate(options: GenerateOptions): Promise<VideoJob> {
-    console.log(`[${this.name}] Starting video generation...`);
-    console.log(`Prompt: "${options.prompt}"`);
-
-    try {
-      // Create generation request
-      const response = await fetch(`${this.baseUrl}/text_to_video`, {
-        method: 'POST',
-        headers: {
-          'Authorization': `Bearer ${this.apiKey}`,
-          'Content-Type': 'application/json',
-          'X-Runway-Version': '2024-11-06',
-        },
-        body: JSON.stringify({
-          model: 'gen3a_turbo',
-          prompt_text: options.prompt,
-          duration: options.duration || 5,
-          ratio: this.mapAspectRatio(options.aspectRatio),
-          watermark: false,
-        }),
-      });
-
-      if (!response.ok) {
-        const error = await response.text();
-        throw new Error(`API request failed: ${response.status} - ${error}`);
-      }
-
-      const data = await response.json() as {
-        id: string;
-        status: string;
-      };
-
-      const job: VideoJob = {
-        jobId: data.id,
-        status: 'processing',
-        progress: 0,
-      };
-
-      console.log(`[${this.name}] Video generation initiated. Job ID: ${job.jobId}`);
-      console.log(`Use "status" command to check progress.`);
-
-      return job;
-
-    } catch (error) {
-      console.error(`[${this.name}] Error:`, error);
-      throw new Error(`Failed to generate video: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-
-  async getStatus(jobId: string): Promise<VideoJob> {
-    console.log(`[${this.name}] Checking status for job ${jobId}...`);
-
-    try {
-      const response = await fetch(`${this.baseUrl}/tasks/${jobId}`, {
-        headers: {
-          'Authorization': `Bearer ${this.apiKey}`,
-          'X-Runway-Version': '2024-11-06',
-        },
-      });
-
-      if (!response.ok) {
-        const error = await response.text();
-        throw new Error(`API request failed: ${response.status} - ${error}`);
-      }
-
-      const data = await response.json() as {
-        id: string;
-        status: string;
-        progress?: number;
-        output?: string[];
-        failure?: string;
-        failure_code?: string;
-      };
-
-      const job: VideoJob = {
-        jobId: data.id,
-        status: this.mapStatus(data.status),
-        progress: data.progress ? Math.round(data.progress * 100) : undefined,
-        videoUrl: data.output?.[0],
-        error: data.failure || data.failure_code,
-      };
-
-      // Display progress
-      if (job.progress !== undefined) {
-        console.log(`Progress: ${job.progress}%`);
-      }
-      console.log(`Status: ${job.status}`);
-
-      if (job.status === 'completed' && job.videoUrl) {
-        console.log(`Video ready! URL: ${job.videoUrl}`);
-      }
-
-      return job;
-
-    } catch (error) {
-      throw new Error(`Failed to get status: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-
-  async download(videoUrl: string, outputPath: string): Promise<void> {
-    console.log(`[${this.name}] Downloading video to ${outputPath}...`);
-
-    try {
-      const response = await fetch(videoUrl);
-
-      if (!response.ok) {
-        throw new Error(`Failed to download: ${response.statusText}`);
-      }
-
-      const arrayBuffer = await response.arrayBuffer();
-      const buffer = Buffer.from(arrayBuffer);
-
-      await writeFile(outputPath, buffer);
-
-      const sizeMB = (buffer.length / 1024 / 1024).toFixed(2);
-      console.log(`[${this.name}] Video downloaded successfully! (${sizeMB} MB)`);
-    } catch (error) {
-      throw new Error(`Download failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-
-  private mapStatus(status: string): VideoJob['status'] {
-    const statusMap: Record<string, VideoJob['status']> = {
-      'PENDING': 'pending',
-      'RUNNING': 'processing',
-      'SUCCEEDED': 'completed',
-      'FAILED': 'failed',
-      'CANCELLED': 'failed',
-    };
-
-    return statusMap[status.toUpperCase()] || 'pending';
-  }
-
-  private mapAspectRatio(ratio?: string): string {
-    const ratioMap: Record<string, string> = {
-      '16:9': '1280:768',
-      '9:16': '768:1280',
-      '1:1': '1024:1024',
-    };
-
-    return ratioMap[ratio || '16:9'] || '1280:768';
-  }
-}

package/skills/video/src/types.ts

@@ -1,35 +0,0 @@
-export type Provider = 'minimax' | 'google' | 'openai' | 'runway';
-
-export interface GenerateOptions {
-  provider: Provider;
-  prompt: string;
-  output?: string;
-  duration?: number; // seconds
-  resolution?: '720p' | '1080p' | '4k';
-  aspectRatio?: '16:9' | '9:16' | '1:1';
-}
-
-export interface StatusOptions {
-  provider: Provider;
-  jobId: string;
-}
-
-export interface VideoJob {
-  jobId: string;
-  status: 'pending' | 'processing' | 'completed' | 'failed';
-  progress?: number; // 0-100
-  videoUrl?: string;
-  error?: string;
-  metadata?: {
-    duration?: number;
-    resolution?: string;
-    size?: number;
-  };
-}
-
-export interface VideoProvider {
-  name: string;
-  generate(options: GenerateOptions): Promise<VideoJob>;
-  getStatus(jobId: string): Promise<VideoJob>;
-  download(videoUrl: string, outputPath: string): Promise<void>;
-}