@hasna/skills 0.1.59 → 0.1.61

package/skills/emoji/src/image-processor.ts

@@ -1,143 +0,0 @@
-import { spawn } from 'child_process';
-import { writeFile, mkdir, readFile, unlink, readdir } from 'fs/promises';
-import { join, dirname } from 'path';
-import type { EmojiResult } from './types';
-
-export class ImageProcessor {
-  private targetSize: number;
-
-  constructor(targetSize: number = 128) {
-    this.targetSize = targetSize;
-  }
-
-  /**
-   * Resize an image buffer to the target size using sips (macOS built-in)
-   */
-  async resize(buffer: Buffer, name: string): Promise<Buffer> {
-    // Create temp files for processing
-    const tempDir = '/tmp/emoji';
-    await mkdir(tempDir, { recursive: true });
-
-    const inputPath = join(tempDir, `${name}-input.png`);
-    const outputPath = join(tempDir, `${name}-output.png`);
-
-    try {
-      // Write input buffer to temp file
-      await writeFile(inputPath, buffer);
-
-      // Use sips (macOS) to resize the image
-      await this.runCommand('sips', [
-        '-z', String(this.targetSize), String(this.targetSize),
-        inputPath,
-        '--out', outputPath,
-      ]);
-
-      // Read the resized image
-      const resizedBuffer = await readFile(outputPath);
-
-      return resizedBuffer;
-    } finally {
-      // Cleanup temp files
-      try {
-        await unlink(inputPath);
-        await unlink(outputPath);
-      } catch {
-        // Ignore cleanup errors
-      }
-    }
-  }
-
-  /**
-   * Save emoji results to a directory
-   */
-  async saveToDirectory(results: EmojiResult[], outputDir: string): Promise<string[]> {
-    await mkdir(outputDir, { recursive: true });
-
-    const savedPaths: string[] = [];
-
-    for (const result of results) {
-      const filename = `${result.name}.png`;
-      const filepath = join(outputDir, filename);
-      await writeFile(filepath, result.buffer);
-      result.path = filepath;
-      savedPaths.push(filepath);
-    }
-
-    return savedPaths;
-  }
-
-  /**
-   * Create a zip file from emoji results
-   */
-  async createZip(results: EmojiResult[], outputPath: string): Promise<string> {
-    const tempDir = '/tmp/emoji-zip';
-    await mkdir(tempDir, { recursive: true });
-
-    // Save all images to temp directory
-    const savedPaths = await this.saveToDirectory(results, tempDir);
-
-    // Ensure output directory exists
-    await mkdir(dirname(outputPath), { recursive: true });
-
-    // Create zip using built-in zip command
-    const filenames = results.map(r => `${r.name}.png`);
-    await this.runCommand('zip', ['-j', outputPath, ...savedPaths], tempDir);
-
-    // Cleanup temp directory
-    for (const path of savedPaths) {
-      try {
-        await unlink(path);
-      } catch {
-        // Ignore cleanup errors
-      }
-    }
-
-    return outputPath;
-  }
-
-  /**
-   * Create a manifest JSON file with metadata
-   */
-  async createManifest(
-    results: EmojiResult[],
-    theme: string,
-    outputPath: string
-  ): Promise<void> {
-    const manifest = {
-      theme,
-      count: results.length,
-      size: this.targetSize,
-      generated: new Date().toISOString(),
-      emojis: results.map(r => ({
-        name: r.name,
-        filename: `${r.name}.png`,
-        prompt: r.prompt,
-      })),
-    };
-
-    await writeFile(outputPath, JSON.stringify(manifest, null, 2));
-  }
-
-  private runCommand(command: string, args: string[], cwd?: string): Promise<void> {
-    return new Promise((resolve, reject) => {
-      const proc = spawn(command, args, { cwd });
-
-      let stderr = '';
-      proc.stderr?.on('data', (data) => {
-        stderr += data.toString();
-      });
-
-      proc.on('close', (code) => {
-        if (code === 0) {
-          resolve();
-        } else {
-          reject(new Error(`${command} failed with code ${code}: ${stderr}`));
-        }
-      });
-
-      proc.on('error', (err) => {
-        reject(err);
-      });
-    });
-  }
-}

package/skills/emoji/src/index.ts

@@ -1,282 +0,0 @@
-#!/usr/bin/env bun
-
-import { resolve } from 'path';
-import type { GenerateOptions, EmojiPrompt, EmojiResult, ImageProvider } from './types';
-import { PromptGenerator } from './prompt-generator';
-import { OpenAIProvider } from './providers/openai';
-import { GeminiProvider } from './providers/gemini';
-import { ImageProcessor } from './image-processor';
-
-function parseArgs(): GenerateOptions | null {
-  const args = process.argv.slice(2);
-
-  if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
-    printHelp();
-    return null;
-  }
-
-  if (args[0] !== 'generate') {
-    console.error(`Unknown command: ${args[0]}`);
-    console.error('Run with --help for usage information');
-    process.exit(1);
-  }
-
-  const options: Partial<GenerateOptions> = {
-    count: 5,
-    provider: 'openai',
-    size: 128,
-    style: 'flat',
-    format: 'directory',
-    concurrency: 3,
-  };
-
-  for (let i = 1; i < args.length; i++) {
-    const arg = args[i];
-
-    switch (arg) {
-      case '--theme':
-      case '-t':
-        options.theme = args[++i];
-        break;
-      case '--count':
-      case '-c':
-        options.count = parseInt(args[++i], 10);
-        break;
-      case '--provider':
-      case '-p':
-        options.provider = args[++i] as 'openai' | 'gemini';
-        break;
-      case '--size':
-      case '-s':
-        options.size = parseInt(args[++i], 10);
-        break;
-      case '--style':
-        options.style = args[++i] as GenerateOptions['style'];
-        break;
-      case '--output':
-      case '-o':
-        options.output = args[++i];
-        break;
-      case '--format':
-      case '-f':
-        options.format = args[++i] as 'zip' | 'directory';
-        break;
-      case '--concurrency':
-        options.concurrency = parseInt(args[++i], 10);
-        break;
-      default:
-        console.error(`Unknown option: ${arg}`);
-        process.exit(1);
-    }
-  }
-
-  // Validate required options
-  if (!options.theme) {
-    console.error('Error: --theme is required');
-    process.exit(1);
-  }
-
-  if (!options.output) {
-    // Default output based on format
-    options.output = options.format === 'zip'
-      ? `./emoji-${options.theme.toLowerCase().replace(/\s+/g, '-')}.zip`
-      : `./emoji-${options.theme.toLowerCase().replace(/\s+/g, '-')}`;
-  }
-
-  // Validate provider
-  if (!['openai', 'gemini'].includes(options.provider!)) {
-    console.error('Error: Invalid provider. Choose from: openai, gemini');
-    process.exit(1);
-  }
-
-  // Validate style
-  if (!['flat', '3d', 'outline', 'gradient'].includes(options.style!)) {
-    console.error('Error: Invalid style. Choose from: flat, 3d, outline, gradient');
-    process.exit(1);
-  }
-
-  // Validate count
-  if (options.count! < 1 || options.count! > 50) {
-    console.error('Error: Count must be between 1 and 50');
-    process.exit(1);
-  }
-
-  return options as GenerateOptions;
-}
-
-function printHelp(): void {
-  console.log(`
-Emoji Pack Generator Skill
-
-Generate emoji packs using AI-powered prompt generation and image creation.
-
-USAGE:
-  bun run src/index.ts generate [OPTIONS]
-
-OPTIONS:
-  --theme, -t <theme>        Theme for emoji pack (e.g., "Christmas", "Food") [required]
-  --count, -c <number>       Number of emojis to generate (1-50, default: 5)
-  --provider, -p <provider>  Image provider: openai, gemini (default: openai)
-  --size, -s <pixels>        Output size in pixels (default: 128)
-  --style <style>            Emoji style: flat, 3d, outline, gradient (default: flat)
-  --output, -o <path>        Output path (directory or zip file)
-  --format, -f <format>      Output format: directory, zip (default: directory)
-  --concurrency <number>     Concurrent image generations (default: 3)
-
-EXAMPLES:
-  # Generate 10 Christmas emojis
-  bun run src/index.ts generate --theme "Christmas" --count 10
-
-  # Generate food emojis as a zip file
-  bun run src/index.ts generate -t "Food and Drinks" -c 15 -f zip -o ./food-emojis.zip
-
-  # Generate 3D style emojis with Gemini
-  bun run src/index.ts generate -t "Animals" -c 8 -p gemini --style 3d
-
-  # Generate high-res emojis (256px)
-  bun run src/index.ts generate -t "Weather" -c 6 -s 256
-
-ENVIRONMENT VARIABLES:
-  OPENAI_API_KEY            API key for OpenAI (required for openai provider)
-  GEMINI_API_KEY            API key for Google Gemini (required for gemini provider)
-  GOOGLE_PROJECT_ID         Google Cloud project ID (required for Gemini image generation)
-
-WORKFLOW:
-  1. AI generates creative prompts based on your theme
-  2. Images are generated asynchronously using the selected provider
-  3. Images are resized to the specified size
-  4. Output is saved as a directory or zip file with manifest
-
-OUTPUT:
-  - Individual PNG files for each emoji
-  - manifest.json with metadata and prompts
-`);
-}
-
-function getImageProvider(provider: string): ImageProvider {
-  switch (provider) {
-    case 'openai':
-      return new OpenAIProvider();
-    case 'gemini':
-      return new GeminiProvider();
-    default:
-      throw new Error(`Unknown provider: ${provider}`);
-  }
-}
-
-async function generateWithConcurrency(
-  prompts: EmojiPrompt[],
-  provider: ImageProvider,
-  concurrency: number,
-  onProgress: (current: number, total: number, name: string) => void
-): Promise<EmojiResult[]> {
-  const results: EmojiResult[] = [];
-  const queue = [...prompts];
-  let completed = 0;
-
-  const worker = async (): Promise<void> => {
-    while (queue.length > 0) {
-      const prompt = queue.shift();
-      if (!prompt) break;
-
-      try {
-        const buffer = await provider.generate(prompt.prompt);
-        results.push({
-          name: prompt.name,
-          prompt: prompt.prompt,
-          buffer,
-        });
-        completed++;
-        onProgress(completed, prompts.length, prompt.name);
-      } catch (error) {
-        console.error(`  Failed to generate "${prompt.name}": ${error}`);
-        // Continue with other emojis
-      }
-    }
-  };
-
-  // Start concurrent workers
-  const workers = Array(Math.min(concurrency, prompts.length))
-    .fill(null)
-    .map(() => worker());
-
-  await Promise.all(workers);
-
-  return results;
-}
-
-async function main(): Promise<void> {
-  const options = parseArgs();
-
-  if (!options) {
-    return;
-  }
-
-  try {
-    console.log('\n=== Emoji Pack Generator ===\n');
-    console.log(`Theme: ${options.theme}`);
-    console.log(`Count: ${options.count}`);
-    console.log(`Provider: ${options.provider}`);
-    console.log(`Style: ${options.style}`);
-    console.log(`Size: ${options.size}px`);
-    console.log(`Format: ${options.format}`);
-    console.log('');
-
-    // Step 1: Generate prompts using AI
-    console.log('Step 1/4: Generating emoji prompts...');
-    const promptGenerator = new PromptGenerator(options.provider, options.style);
-    const prompts = await promptGenerator.generate(options.theme, options.count);
-    console.log(`  Generated ${prompts.length} prompts\n`);
-
-    // Display generated prompts
-    console.log('Generated emojis:');
-    prompts.forEach((p, i) => {
-      console.log(`  ${i + 1}. ${p.name}: ${p.description}`);
-    });
-    console.log('');
-
-    // Step 2: Generate images
-    console.log('Step 2/4: Generating images...');
-    const imageProvider = getImageProvider(options.provider);
-    const results = await generateWithConcurrency(
-      prompts,
-      imageProvider,
-      options.concurrency,
-      (current, total, name) => {
-        console.log(`  [${current}/${total}] Generated: ${name}`);
-      }
-    );
-    console.log(`  Generated ${results.length} images\n`);
-
-    // Step 3: Resize images
-    console.log('Step 3/4: Resizing images...');
-    const processor = new ImageProcessor(options.size);
-    for (const result of results) {
-      result.buffer = await processor.resize(result.buffer, result.name);
-    }
-    console.log(`  Resized to ${options.size}x${options.size}px\n`);
-
-    // Step 4: Save output
-    console.log('Step 4/4: Saving output...');
-    const outputPath = resolve(options.output);
-
-    if (options.format === 'zip') {
-      await processor.createZip(results, outputPath);
-      console.log(`  Created zip: ${outputPath}`);
-    } else {
-      await processor.saveToDirectory(results, outputPath);
-      await processor.createManifest(results, options.theme, resolve(outputPath, 'manifest.json'));
-      console.log(`  Saved to directory: ${outputPath}`);
-    }
-
-    console.log('\n=== Done! ===\n');
-    console.log(`Generated ${results.length} emojis for theme "${options.theme}"`);
-    console.log(`Output: ${outputPath}`);
-    console.log('');
-  } catch (error) {
-    console.error('\nError:', error instanceof Error ? error.message : error);
-    process.exit(1);
-  }
-}
-
-main();

package/skills/emoji/src/prompt-generator.ts

@@ -1,181 +0,0 @@
-import type { EmojiPrompt, OpenAIChatResponse, GeminiChatResponse } from './types';
-
-const EMOJI_SYSTEM_PROMPT = `Generate emoji image prompts. Each emoji should be:
-- Square format, single centered subject
-- Simple, clean design suitable for small sizes
-- No text, no words, no letters
-- Solid or transparent background
-- Vibrant colors, clear silhouette
-
-Return a JSON array with objects containing:
-- "name": short filename (lowercase, no spaces, use hyphens)
-- "description": what the emoji represents
-- "prompt": detailed image generation prompt
-
-Example output:
-[
-  {"name": "santa-hat", "description": "Red Santa hat with white trim", "prompt": "A red Santa Claus hat with white fluffy trim, centered on solid background, emoji style, simple clean design, vibrant colors"},
-  {"name": "gift-box", "description": "Wrapped present with bow", "prompt": "A wrapped gift box with red ribbon bow, centered on solid background, emoji style, simple clean design, festive colors"}
-]
-
-Only output valid JSON array, no other text.`;
-
-export class PromptGenerator {
-  private provider: 'openai' | 'gemini';
-  private apiKey: string;
-  private style: string;
-
-  constructor(provider: 'openai' | 'gemini', style: string = 'flat') {
-    this.provider = provider;
-    this.style = style;
-
-    if (provider === 'openai') {
-      this.apiKey = process.env.OPENAI_API_KEY || '';
-      if (!this.apiKey) {
-        throw new Error('OPENAI_API_KEY environment variable is required');
-      }
-    } else {
-      this.apiKey = process.env.GEMINI_API_KEY || '';
-      if (!this.apiKey) {
-        throw new Error('GEMINI_API_KEY environment variable is required');
-      }
-    }
-  }
-
-  async generate(theme: string, count: number): Promise<EmojiPrompt[]> {
-    const styleDescription = this.getStyleDescription();
-    const userPrompt = `Create ${count} unique emoji prompts for the theme: "${theme}"
-
-Style requirements: ${styleDescription}
-
-Generate exactly ${count} emojis. Make them diverse and cover different aspects of the theme.`;
-
-    console.log(`Generating ${count} emoji prompts for theme: "${theme}"...`);
-
-    if (this.provider === 'openai') {
-      return this.generateWithOpenAI(userPrompt);
-    } else {
-      return this.generateWithGemini(userPrompt);
-    }
-  }
-
-  private getStyleDescription(): string {
-    switch (this.style) {
-      case 'flat':
-        return 'Flat design, solid colors, no shadows, minimal detail';
-      case '3d':
-        return 'Soft 3D style, subtle shadows and highlights, rounded shapes';
-      case 'outline':
-        return 'Line art style, clean outlines, minimal fill colors';
-      case 'gradient':
-        return 'Gradient colors, smooth transitions, modern look';
-      default:
-        return 'Clean emoji style';
-    }
-  }
-
-  private async generateWithOpenAI(userPrompt: string): Promise<EmojiPrompt[]> {
-    const response = await fetch('https://api.openai.com/v1/chat/completions', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${this.apiKey}`,
-      },
-      body: JSON.stringify({
-        model: 'gpt-4o-mini',
-        messages: [
-          { role: 'system', content: EMOJI_SYSTEM_PROMPT },
-          { role: 'user', content: userPrompt },
-        ],
-        temperature: 0.8,
-        response_format: { type: 'json_object' },
-      }),
-    });
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`OpenAI API error: ${response.status} - ${error}`);
-    }
-
-    const data = (await response.json()) as OpenAIChatResponse;
-    const content = data.choices[0]?.message?.content;
-
-    if (!content) {
-      throw new Error('No content in OpenAI response');
-    }
-
-    return this.parsePrompts(content);
-  }
-
-  private async generateWithGemini(userPrompt: string): Promise<EmojiPrompt[]> {
-    const response = await fetch(
-      `https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=${this.apiKey}`,
-      {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-          contents: [
-            {
-              parts: [
-                { text: EMOJI_SYSTEM_PROMPT + '\n\n' + userPrompt },
-              ],
-            },
-          ],
-          generationConfig: {
-            temperature: 0.8,
-            responseMimeType: 'application/json',
-          },
-        }),
-      }
-    );
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Gemini API error: ${response.status} - ${error}`);
-    }
-
-    const data = (await response.json()) as GeminiChatResponse;
-    const content = data.candidates?.[0]?.content?.parts?.[0]?.text;
-
-    if (!content) {
-      throw new Error('No content in Gemini response');
-    }
-
-    return this.parsePrompts(content);
-  }
-
-  private parsePrompts(content: string): EmojiPrompt[] {
-    try {
-      // Try to parse the content directly
-      let parsed = JSON.parse(content);
-
-      // Handle if the response is wrapped in an object
-      if (parsed.emojis && Array.isArray(parsed.emojis)) {
-        parsed = parsed.emojis;
-      }
-
-      if (!Array.isArray(parsed)) {
-        throw new Error('Expected array of prompts');
-      }
-
-      // Validate and clean up each prompt
-      return parsed.map((item: unknown, index: number) => {
-        const obj = item as Record<string, unknown>;
-        return {
-          name: String(obj.name || `emoji-${index + 1}`).toLowerCase().replace(/\s+/g, '-'),
-          description: String(obj.description || ''),
-          prompt: String(obj.prompt || ''),
-        };
-      });
-    } catch (error) {
-      // Try to extract JSON from the content
-      const jsonMatch = content.match(/\[[\s\S]*\]/);
-      if (jsonMatch) {
-        return this.parsePrompts(jsonMatch[0]);
-      }
-      throw new Error(`Failed to parse prompts: ${error}`);
-    }
-  }
-}

package/skills/emoji/src/providers/gemini.ts

@@ -1,58 +0,0 @@
-import type { ImageProvider } from '../types';
-
-interface GeminiImageResponse {
-  predictions?: Array<{
-    bytesBase64Encoded: string;
-  }>;
-}
-
-export class GeminiProvider implements ImageProvider {
-  private apiKey: string;
-  private projectId: string;
-  private location = 'us-central1';
-
-  constructor(apiKey?: string, projectId?: string) {
-    this.apiKey = apiKey || process.env.GEMINI_API_KEY || '';
-    this.projectId = projectId || process.env.GOOGLE_PROJECT_ID || '';
-
-    if (!this.apiKey) {
-      throw new Error('GEMINI_API_KEY environment variable is required');
-    }
-    if (!this.projectId) {
-      throw new Error('GOOGLE_PROJECT_ID environment variable is required for image generation');
-    }
-  }
-
-  async generate(prompt: string): Promise<Buffer> {
-    const model = 'imagen-3.0-generate-001';
-    const endpoint = `https://${this.location}-aiplatform.googleapis.com/v1/projects/${this.projectId}/locations/${this.location}/publishers/google/models/${model}:predict`;
-
-    const response = await fetch(endpoint, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${this.apiKey}`,
-      },
-      body: JSON.stringify({
-        instances: [{ prompt }],
-        parameters: {
-          sampleCount: 1,
-          aspectRatio: '1:1',
-        },
-      }),
-    });
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Gemini API error: ${response.status} - ${error}`);
-    }
-
-    const data = (await response.json()) as GeminiImageResponse;
-
-    if (!data.predictions || data.predictions.length === 0 || !data.predictions[0].bytesBase64Encoded) {
-      throw new Error('No image data returned from Gemini API');
-    }
-
-    return Buffer.from(data.predictions[0].bytesBase64Encoded, 'base64');
-  }
-}