@hasna/skills 0.0.2

package/skills/skill-video/src/installer.ts

@@ -0,0 +1,324 @@
+#!/usr/bin/env bun
+
+/**
+ * Skill Installer Module
+ *
+ * Universal installer for skills to integrate with AI code assistants
+ * Usage: skill-[name] install [claude|codex|windsurf|cursor]
+ */
+
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from 'fs';
+import { resolve, join } from 'path';
+import { homedir } from 'os';
+
+export interface SkillConfig {
+  name: string;
+  description: string;
+  version: string;
+  commands: Array<{
+    name: string;
+    description: string;
+    usage: string;
+    examples: string[];
+  }>;
+  requiredEnvVars?: string[];
+  optionalEnvVars?: string[];
+}
+
+export type AssistantType = 'claude' | 'codex' | 'windsurf' | 'cursor';
+
+const ASSISTANT_PATHS: Record<AssistantType, string> = {
+  claude: '.claude/skills',
+  codex: '.codex/skills',
+  windsurf: '.windsurf/skills',
+  cursor: '.cursor/skills',
+};
+
+export class SkillInstaller {
+  private config: SkillConfig;
+  private skillPath: string;
+
+  constructor(config: SkillConfig, currentFilePath: string) {
+    this.config = config;
+    // Get the root directory of the skill (where package.json is)
+    this.skillPath = resolve(currentFilePath, '..');
+  }
+
+  /**
+   * Install the skill to specified AI assistant
+   */
+  async install(assistant: AssistantType): Promise<void> {
+    console.log(`📦 Installing ${this.config.name} for ${assistant}...`);
+    console.log('');
+
+    const assistantPath = ASSISTANT_PATHS[assistant];
+    if (!assistantPath) {
+      throw new Error(`Unknown assistant: ${assistant}`);
+    }
+
+    // Create skill directory
+    const skillDir = join(homedir(), assistantPath, this.config.name);
+    mkdirSync(skillDir, { recursive: true });
+    console.log(`✓ Created: ${skillDir}`);
+
+    // Generate and write SKILL.md
+    const skillMd = this.generateSkillMd();
+    writeFileSync(join(skillDir, 'SKILL.md'), skillMd);
+    console.log(`✓ Created: SKILL.md`);
+
+    // Generate and write README.md
+    const readme = this.generateReadme();
+    writeFileSync(join(skillDir, 'README.md'), readme);
+    console.log(`✓ Created: README.md`);
+
+    // Create log file
+    const logFile = join(skillDir, `${this.config.name}.log`);
+    if (!existsSync(logFile)) {
+      writeFileSync(logFile, `# ${this.config.name} execution log\n# Created: ${new Date().toISOString()}\n\n`);
+      console.log(`✓ Created: ${this.config.name}.log`);
+    }
+
+    // Update MCP config
+    this.updateMcpConfig(assistant, skillDir);
+
+    console.log('');
+    console.log(`✅ ${this.config.name} installed successfully!`);
+    console.log('');
+    console.log('Location:', skillDir);
+    console.log('');
+    console.log('Usage:');
+    this.config.commands.slice(0, 3).forEach(cmd => {
+      console.log(`  ${this.config.name} ${cmd.usage}`);
+    });
+  }
+
+  /**
+   * Generate SKILL.md documentation
+   */
+  private generateSkillMd(): string {
+    const envVarsSection = this.config.requiredEnvVars?.length || this.config.optionalEnvVars?.length ? `
+
+## Environment Variables
+
+${this.config.requiredEnvVars?.length ? `### Required
+${this.config.requiredEnvVars.map(v => `- \`${v}\``).join('\n')}
+` : ''}
+${this.config.optionalEnvVars?.length ? `### Optional
+${this.config.optionalEnvVars.map(v => `- \`${v}\``).join('\n')}
+` : ''}` : '';
+
+    return `# ${this.config.name}
+
+${this.config.description}
+
+## Version
+${this.config.version}
+
+## Commands
+
+${this.config.commands.map(cmd => `### ${cmd.name}
+
+${cmd.description}
+
+**Usage:**
+\`\`\`bash
+${this.config.name} ${cmd.usage}
+\`\`\`
+
+**Examples:**
+${cmd.examples.map(ex => `\`\`\`bash
+${ex}
+\`\`\``).join('\n')}
+`).join('\n')}
+${envVarsSection}
+
+## Installation
+
+This skill is installed at:
+\`~/.claude/skills/${this.config.name}/\`
+
+## Logs
+
+Execution logs are written to:
+\`~/.claude/skills/${this.config.name}/${this.config.name}.log\`
+
+## Support
+
+For issues, visit: https://github.com/hasnaxyz/${this.config.name}/issues
+`;
+  }
+
+  /**
+   * Generate README.md
+   */
+  private generateReadme(): string {
+    return `# ${this.config.name}
+
+${this.config.description}
+
+## Quick Start
+
+\`\`\`bash
+${this.config.commands[0] ? `${this.config.name} ${this.config.commands[0].usage}` : `${this.config.name} --help`}
+\`\`\`
+
+## Documentation
+
+See [SKILL.md](./SKILL.md) for complete documentation.
+
+## Version
+
+${this.config.version}
+`;
+  }
+
+  /**
+   * Update MCP config to register the skill
+   */
+  private updateMcpConfig(assistant: AssistantType, skillDir: string): void {
+    const configPaths: Record<AssistantType, string> = {
+      claude: join(homedir(), '.config/claude-code/claude_mcp_config.json'),
+      codex: join(homedir(), '.config/codex/mcp_config.json'),
+      windsurf: join(homedir(), '.config/windsurf/mcp_config.json'),
+      cursor: join(homedir(), '.config/cursor/mcp_config.json'),
+    };
+
+    const configPath = configPaths[assistant];
+
+    // Read existing config or create new
+    let config: any = { mcpServers: {} };
+    if (existsSync(configPath)) {
+      const content = readFileSync(configPath, 'utf8');
+      config = JSON.parse(content);
+    }
+
+    if (!config.mcpServers) {
+      config.mcpServers = {};
+    }
+
+    // Add or update this skill
+    config.mcpServers[this.config.name] = {
+      command: 'bun',
+      args: ['run', join(this.skillPath, 'src/index.ts')],
+      env: this.getEnvConfig(),
+    };
+
+    // Write config
+    mkdirSync(resolve(configPath, '..'), { recursive: true });
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+    console.log(`✓ Updated: ${assistant} MCP config`);
+  }
+
+  /**
+   * Get environment variables config
+   */
+  private getEnvConfig(): Record<string, string> {
+    const env: Record<string, string> = {
+      SKILL_API_KEY: process.env.SKILL_API_KEY || '',
+    };
+
+    // Add required env vars
+    this.config.requiredEnvVars?.forEach(key => {
+      env[key] = process.env[key] || '';
+    });
+
+    // Add optional env vars
+    this.config.optionalEnvVars?.forEach(key => {
+      env[key] = process.env[key] || '';
+    });
+
+    return env;
+  }
+
+  /**
+   * Uninstall the skill from specified AI assistant
+   */
+  async uninstall(assistant: AssistantType): Promise<void> {
+    console.log(`🗑️  Uninstalling ${this.config.name} from ${assistant}...`);
+    console.log('');
+
+    const assistantPath = ASSISTANT_PATHS[assistant];
+    const skillDir = join(homedir(), assistantPath, this.config.name);
+
+    if (existsSync(skillDir)) {
+      // Remove from MCP config first
+      this.removeFromMcpConfig(assistant);
+
+      // Note: We don't delete the directory to preserve logs and user data
+      console.log(`✓ Removed from ${assistant} MCP config`);
+      console.log('');
+      console.log(`⚠️  Directory preserved: ${skillDir}`);
+      console.log('   (contains logs and configuration)');
+      console.log('   Delete manually if needed.');
+    } else {
+      console.log(`⚠️  ${this.config.name} is not installed for ${assistant}`);
+    }
+  }
+
+  /**
+   * Remove skill from MCP config
+   */
+  private removeFromMcpConfig(assistant: AssistantType): void {
+    const configPaths: Record<AssistantType, string> = {
+      claude: join(homedir(), '.config/claude-code/claude_mcp_config.json'),
+      codex: join(homedir(), '.config/codex/mcp_config.json'),
+      windsurf: join(homedir(), '.config/windsurf/mcp_config.json'),
+      cursor: join(homedir(), '.config/cursor/mcp_config.json'),
+    };
+
+    const configPath = configPaths[assistant];
+
+    if (existsSync(configPath)) {
+      const content = readFileSync(configPath, 'utf8');
+      const config = JSON.parse(content);
+
+      if (config.mcpServers && config.mcpServers[this.config.name]) {
+        delete config.mcpServers[this.config.name];
+        writeFileSync(configPath, JSON.stringify(config, null, 2));
+      }
+    }
+  }
+}
+
+/**
+ * Helper to run installer from skill CLI
+ */
+export async function runInstaller(
+  config: SkillConfig,
+  currentFilePath: string,
+  args: string[]
+): Promise<void> {
+  const installer = new SkillInstaller(config, currentFilePath);
+
+  const command = args[0];
+  const assistant = args[1] as AssistantType;
+
+  if (command === 'install') {
+    if (!assistant || !['claude', 'codex', 'windsurf', 'cursor'].includes(assistant)) {
+      console.error('❌ Error: Please specify an assistant');
+      console.error('');
+      console.error('Usage:');
+      console.error(`  ${config.name} install [claude|codex|windsurf|cursor]`);
+      console.error('');
+      console.error('Examples:');
+      console.error(`  ${config.name} install claude`);
+      console.error(`  ${config.name} install codex`);
+      process.exit(1);
+    }
+
+    await installer.install(assistant);
+  } else if (command === 'uninstall') {
+    if (!assistant || !['claude', 'codex', 'windsurf', 'cursor'].includes(assistant)) {
+      console.error('❌ Error: Please specify an assistant');
+      console.error('');
+      console.error('Usage:');
+      console.error(`  ${config.name} uninstall [claude|codex|windsurf|cursor]`);
+      process.exit(1);
+    }
+
+    await installer.uninstall(assistant);
+  } else {
+    console.error(`❌ Unknown installer command: ${command}`);
+    process.exit(1);
+  }
+}

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

@@ -0,0 +1,126 @@
+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/skill-video/src/providers/index.ts

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

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

@@ -0,0 +1,164 @@
+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';
+  }
+}