@hasna/skills 0.1.27 → 0.1.30

package/skills/video/src/cli.ts

@@ -1,155 +0,0 @@
-import type { GenerateOptions, StatusOptions } from './types';
-
-export function parseArgs(): { command: string; options: any } {
-  const args = process.argv.slice(2);
-
-  if (args.length === 0) {
-    showHelp();
-    process.exit(0);
-  }
-
-  const command = args[0];
-
-  if (command === 'help' || command === '--help' || command === '-h') {
-    showHelp();
-    process.exit(0);
-  }
-
-  const options: any = {};
-
-  for (let i = 1; i < args.length; i++) {
-    const arg = args[i];
-
-    if (arg.startsWith('--')) {
-      const key = arg.slice(2);
-      const value = args[i + 1];
-
-      if (!value || value.startsWith('--')) {
-        options[key] = true;
-      } else {
-        options[key] = value;
-        i++;
-      }
-    }
-  }
-
-  return { command, options };
-}
-
-export function validateGenerateOptions(options: any): GenerateOptions {
-  if (!options.provider) {
-    throw new Error('--provider is required (google, openai, or runway)');
-  }
-
-  if (!['google', 'openai', 'runway'].includes(options.provider)) {
-    throw new Error('Invalid provider. Use: google, openai, or runway');
-  }
-
-  if (!options.prompt) {
-    throw new Error('--prompt is required');
-  }
-
-  const validated: GenerateOptions = {
-    provider: options.provider,
-    prompt: options.prompt,
-    output: options.output,
-  };
-
-  if (options.duration) {
-    validated.duration = parseInt(options.duration);
-    if (isNaN(validated.duration) || validated.duration < 1) {
-      throw new Error('Invalid duration. Must be a positive number.');
-    }
-  }
-
-  if (options.resolution) {
-    if (!['720p', '1080p', '4k'].includes(options.resolution)) {
-      throw new Error('Invalid resolution. Use: 720p, 1080p, or 4k');
-    }
-    validated.resolution = options.resolution;
-  }
-
-  if (options.aspectRatio || options['aspect-ratio']) {
-    const ratio = options.aspectRatio || options['aspect-ratio'];
-    if (!['16:9', '9:16', '1:1'].includes(ratio)) {
-      throw new Error('Invalid aspect ratio. Use: 16:9, 9:16, or 1:1');
-    }
-    validated.aspectRatio = ratio;
-  }
-
-  return validated;
-}
-
-export function validateStatusOptions(options: any): StatusOptions {
-  if (!options.provider) {
-    throw new Error('--provider is required');
-  }
-
-  if (!['google', 'openai', 'runway'].includes(options.provider)) {
-    throw new Error('Invalid provider. Use: google, openai, or runway');
-  }
-
-  if (!options.jobId && !options['job-id']) {
-    throw new Error('--job-id is required');
-  }
-
-  return {
-    provider: options.provider,
-    jobId: options.jobId || options['job-id'],
-  };
-}
-
-function showHelp() {
-  console.log(`
-Video Generation CLI
-
-USAGE:
-  bun run src/index.ts <command> [options]
-
-COMMANDS:
-  generate    Generate a new video
-  status      Check the status of a video generation job
-  help        Show this help message
-
-GENERATE OPTIONS:
-  --provider <name>      Provider to use (google, openai, runway) [required]
-  --prompt <text>        Text prompt for video generation [required]
-  --output <path>        Output file path (default: ./output.mp4)
-  --duration <seconds>   Video duration in seconds (default: 5)
-  --resolution <size>    Video resolution (720p, 1080p, 4k)
-  --aspect-ratio <ratio> Aspect ratio (16:9, 9:16, 1:1)
-
-STATUS OPTIONS:
-  --provider <name>      Provider to use (google, openai, runway) [required]
-  --job-id <id>          Job ID to check [required]
-
-EXAMPLES:
-  # Generate a video with Google Veo 2
-  bun run src/index.ts generate \\
-    --provider google \\
-    --prompt "a cat walking on a beach at sunset" \\
-    --output ./cat.mp4
-
-  # Generate with Runway
-  bun run src/index.ts generate \\
-    --provider runway \\
-    --prompt "ocean waves crashing on rocks" \\
-    --duration 10 \\
-    --resolution 1080p
-
-  # Check generation status
-  bun run src/index.ts status \\
-    --provider runway \\
-    --job-id abc123xyz
-
-ENVIRONMENT VARIABLES:
-  GOOGLE_API_KEY               Google Cloud API key
-  GOOGLE_APPLICATION_CREDENTIALS  Path to Google service account JSON
-  GOOGLE_CLOUD_PROJECT         Google Cloud project ID
-  GOOGLE_CLOUD_LOCATION        Google Cloud location (default: us-central1)
-  OPENAI_API_KEY               OpenAI API key
-  RUNWAY_API_KEY               Runway API key
-
-For more information, see SKILL.md
-`);
-}

package/skills/video/src/index-local.ts

@@ -1,148 +0,0 @@
-#!/usr/bin/env bun
-
-import { parseArgs, validateGenerateOptions, validateStatusOptions } from './cli';
-import { getProvider } from './providers';
-import { resolve } from 'path';
-import { handleInstallCommand } from '../../_common';
-
-
-// Handle install/uninstall commands
-const SKILL_META = {
-  name: 'video',
-  description: 'Claude Code skill for AI video generation',
-  version: '1.0.0',
-  commands: `Use: video --help`,
-  requiredEnvVars: ['SKILL_API_KEY'],
-};
-
-if (await handleInstallCommand(SKILL_META, process.argv.slice(2))) {
-  process.exit(0);
-}
-
-async function main() {
-  try {
-    const { command, options } = parseArgs();
-
-    switch (command) {
-      case 'generate': {
-        const generateOptions = validateGenerateOptions(options);
-        const provider = getProvider(generateOptions.provider);
-
-        console.log('\n=== Video Generation ===');
-        console.log(`Provider: ${provider.name}`);
-        console.log(`Prompt: "${generateOptions.prompt}"\n`);
-
-        // Start generation
-        const job = await provider.generate(generateOptions);
-
-        console.log(`\n=== Generation Started ===`);
-        console.log(`Job ID: ${job.jobId}`);
-        console.log(`Status: ${job.status}`);
-
-        // If already completed (synchronous providers)
-        if (job.status === 'completed' && job.videoUrl) {
-          console.log(`\nVideo is ready!`);
-
-          if (generateOptions.output) {
-            const outputPath = resolve(generateOptions.output);
-            await provider.download(job.videoUrl, outputPath);
-            console.log(`\nSaved to: ${outputPath}`);
-          } else {
-            console.log(`\nVideo URL: ${job.videoUrl}`);
-            console.log(`Use --output to download automatically.`);
-          }
-        } else {
-          // Async generation - poll for status
-          console.log(`\nVideo generation in progress...`);
-          console.log(`\nTo check status, run:`);
-          console.log(`bun run src/index.ts status --provider ${generateOptions.provider} --job-id ${job.jobId}`);
-
-          // Auto-poll if output path is specified
-          if (generateOptions.output) {
-            console.log(`\nAuto-polling for completion...`);
-            await pollUntilComplete(provider, job.jobId, generateOptions.output);
-          }
-        }
-
-        break;
-      }
-
-      case 'status': {
-        const statusOptions = validateStatusOptions(options);
-        const provider = getProvider(statusOptions.provider);
-
-        console.log('\n=== Checking Status ===');
-        console.log(`Provider: ${provider.name}`);
-        console.log(`Job ID: ${statusOptions.jobId}\n`);
-
-        const job = await provider.getStatus(statusOptions.jobId);
-
-        console.log(`Status: ${job.status}`);
-        if (job.progress !== undefined) {
-          console.log(`Progress: ${job.progress}%`);
-        }
-        if (job.error) {
-          console.log(`Error: ${job.error}`);
-        }
-        if (job.videoUrl) {
-          console.log(`Video URL: ${job.videoUrl}`);
-        }
-
-        // Offer to download if completed
-        if (job.status === 'completed' && job.videoUrl && options.output) {
-          const outputPath = resolve(options.output);
-          console.log(`\nDownloading video...`);
-          await provider.download(job.videoUrl, outputPath);
-          console.log(`Saved to: ${outputPath}`);
-        }
-
-        break;
-      }
-
-      default:
-        console.error(`Unknown command: ${command}`);
-        console.log(`Run "bun run src/index.ts help" for usage information.`);
-        process.exit(1);
-    }
-
-  } catch (error) {
-    console.error('\nError:', error instanceof Error ? error.message : error);
-    process.exit(1);
-  }
-}
-
-async function pollUntilComplete(
-  provider: any,
-  jobId: string,
-  outputPath: string,
-  maxAttempts: number = 60,
-  intervalMs: number = 10000
-): Promise<void> {
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    await new Promise(resolve => setTimeout(resolve, intervalMs));
-
-    const job = await provider.getStatus(jobId);
-
-    if (job.progress !== undefined) {
-      console.log(`Progress: ${job.progress}%`);
-    }
-
-    if (job.status === 'completed') {
-      if (job.videoUrl) {
-        console.log(`\nVideo generation complete!`);
-        const resolvedPath = resolve(outputPath);
-        await provider.download(job.videoUrl, resolvedPath);
-        console.log(`Saved to: ${resolvedPath}`);
-      }
-      return;
-    }
-
-    if (job.status === 'failed') {
-      throw new Error(`Video generation failed: ${job.error || 'Unknown error'}`);
-    }
-  }
-
-  throw new Error('Video generation timed out. Use status command to check manually.');
-}
-
-main();

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.`);
-  }
-}