@hasna/skills 0.1.26 → 0.1.29

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

@@ -1,206 +0,0 @@
-#!/usr/bin/env bun
-
-import { writeFile } from 'fs/promises';
-import { resolve, dirname } from 'path';
-import { mkdir } from 'fs/promises';
-import type { GenerateOptions, ImageProvider } from './types';
-import { MinimaxProvider } from './providers/minimax';
-import { OpenAIProvider } from './providers/openai';
-import { GoogleProvider } from './providers/google';
-import { XAIProvider } from './providers/xai';
-import { handleInstallCommand } from '../../_common';
-
-
-// Handle install/uninstall commands
-const SKILL_META = {
-  name: 'image',
-  description: 'Generate images using AI providers (OpenAI, Google Gemini 3.0, xAI Aurora)',
-  version: '1.0.0',
-  commands: `Use: image --help`,
-  requiredEnvVars: ['SKILL_API_KEY'],
-};
-
-if (await handleInstallCommand(SKILL_META, process.argv.slice(2))) {
-  process.exit(0);
-}
-
-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> = {};
-
-  for (let i = 1; i < args.length; i++) {
-    const arg = args[i];
-
-    switch (arg) {
-      case '--provider':
-      case '-p':
-        options.provider = args[++i] as GenerateOptions['provider'];
-        break;
-      case '--prompt':
-        options.prompt = args[++i];
-        break;
-      case '--output':
-      case '-o':
-        options.output = args[++i];
-        break;
-      case '--model':
-      case '-m':
-        options.model = args[++i];
-        break;
-      case '--size':
-      case '-s':
-        options.size = args[++i];
-        break;
-      default:
-        console.error(`Unknown option: ${arg}`);
-        process.exit(1);
-    }
-  }
-
-  // Validate required options
-  if (!options.provider) {
-    options.provider = 'minimax';
-  }
-
-  if (!options.prompt) {
-    console.error('Error: --prompt is required');
-    process.exit(1);
-  }
-
-  if (!options.output) {
-    console.error('Error: --output is required');
-    process.exit(1);
-  }
-
-  // Validate provider
-  const validProviders = ['minimax', 'openai', 'google', 'xai'];
-  if (!validProviders.includes(options.provider)) {
-    console.error(
-      `Error: Invalid provider. Choose from: ${validProviders.join(', ')}`
-    );
-    process.exit(1);
-  }
-
-  return options as GenerateOptions;
-}
-
-function printHelp() {
-  console.log(`
-Image Generation Skill
-
-Generate images using AI providers (OpenAI, Google Imagen, xAI Aurora)
-
-USAGE:
-  bun run src/index.ts generate [OPTIONS]
-
-OPTIONS:
-  --provider, -p <provider>   Provider to use (openai, google, xai) [required]
-  --prompt <text>             Text prompt for image generation [required]
-  --output, -o <path>         Output file path [required]
-  --model, -m <model>         Specific model to use (optional)
-  --size, -s <size>           Image size (provider-specific, optional)
-
-EXAMPLES:
-  # OpenAI DALL-E 3
-  bun run src/index.ts generate --provider openai --prompt "a cat" --output ./cat.png
-
-  # OpenAI with custom size
-  bun run src/index.ts generate -p openai --prompt "a landscape" -o ./landscape.png --size 1792x1024
-
-  # Google Imagen 3
-  bun run src/index.ts generate --provider google --prompt "a dog" --output ./dog.png
-
-  # xAI Aurora
-  bun run src/index.ts generate --provider xai --prompt "a bird" --output ./bird.png
-
-ENVIRONMENT VARIABLES:
-  OPENAI_API_KEY              API key for OpenAI
-  GEMINI_API_KEY              API key for Google Gemini
-  GOOGLE_PROJECT_ID           Google Cloud project ID
-  XAI_API_KEY                 API key for xAI
-
-PROVIDER-SPECIFIC OPTIONS:
-
-  OpenAI:
-    Models: dall-e-3 (default), gpt-image-1
-    Sizes: 1024x1024 (default), 1792x1024, 1024x1792
-
-  Google Imagen 3:
-    Models: imagen-3.0-generate-001 (default)
-    Sizes: 1:1 (default), 3:4, 4:3, 9:16, 16:9
-
-  xAI Grok-2 Image:
-    Models: grok-2-image-1212 (default)
-    Sizes: Provider-specific
-`);
-}
-
-function getProvider(provider: string): ImageProvider {
-  switch (provider) {
-    case 'minimax':
-      return new MinimaxProvider();
-    case 'openai':
-      return new OpenAIProvider();
-    case 'google':
-      return new GoogleProvider();
-    case 'xai':
-      return new XAIProvider();
-    default:
-      throw new Error(`Unknown provider: ${provider}`);
-  }
-}
-
-async function ensureDirectory(filePath: string): Promise<void> {
-  const dir = dirname(filePath);
-  try {
-    await mkdir(dir, { recursive: true });
-  } catch (error) {
-    // Directory might already exist, ignore error
-  }
-}
-
-async function main() {
-  const options = parseArgs();
-
-  if (!options) {
-    return;
-  }
-
-  try {
-    console.log('\n=== Image Generation ===\n');
-
-    const provider = getProvider(options.provider);
-
-    const imageBuffer = await provider.generate(options.prompt, {
-      model: options.model,
-      size: options.size,
-    });
-
-    // Ensure output directory exists
-    const outputPath = resolve(options.output);
-    await ensureDirectory(outputPath);
-
-    // Write image to file
-    await writeFile(outputPath, imageBuffer);
-
-    console.log(`\nImage saved to: ${outputPath}`);
-    console.log('\nDone!\n');
-  } catch (error) {
-    console.error('\nError:', error instanceof Error ? error.message : error);
-    process.exit(1);
-  }
-}
-
-main();

package/skills/image/src/index.ts

@@ -1,96 +0,0 @@
-#!/usr/bin/env bun
-
-import { executeAndSave, executeSkill, handleInstallCommand } from "../../_common";
-
-const SKILL = "image";
-
-const SKILL_META = {
-  name: "image",
-  description: "Generate images using provider-cost AI backends",
-  version: "1.0.0",
-  commands: "image 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 Image CLI
-
-USAGE:
-  image generate --provider <provider> --prompt <prompt> [options]
-
-PROVIDERS:
-  openai    gpt-image-1.5, dall-e-3
-  minimax   image-01
-  gemini    imagen-4.0-generate-001, imagen-4.0-fast-generate-001, imagen-4.0-ultra-generate-001, gemini-2.5-flash-image
-
-OPTIONS:
-  --model <model>    Provider model override
-  --prompt <prompt>  Text prompt
-  --size <size>      Provider-specific size or aspect ratio
-  --count <count>    Number of images
-  --output <path>    Save generated image
-
-EXAMPLES:
-  image generate --provider openai --prompt "a cat" --output ./output.png
-  image generate --provider minimax --prompt "a dog" --output ./output.png
-  image generate --provider gemini --model imagen-4.0-fast-generate-001 --prompt "a bird" --output ./output.png`);
-}
-
-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 image output.");
-    process.exit(1);
-  }
-  if (result.success && result.output) {
-    console.log(result.output);
-    return;
-  }
-  console.error(`Error: ${result.error || "Image 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/image/src/providers/google.ts

@@ -1,79 +0,0 @@
-import type { ImageProvider, GoogleImagenResponse } from '../types';
-
-export class GoogleProvider 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');
-    }
-  }
-
-  async generate(
-    prompt: string,
-    options?: {
-      model?: string;
-      size?: string;
-    }
-  ): Promise<Buffer> {
-    // Gemini 3.0 (Nano Banana) - Google's latest image generation model
-    const model = options?.model || 'gemini-3.0-generate-001';
-
-    console.log(`Generating image with Google Gemini 3.0 (${model})...`);
-    console.log(`Prompt: ${prompt}`);
-
-    // Construct the Vertex AI endpoint
-    const endpoint = `https://${this.location}-aiplatform.googleapis.com/v1/projects/${this.projectId}/locations/${this.location}/publishers/google/models/${model}:predict`;
-
-    const requestBody = {
-      instances: [
-        {
-          prompt,
-        },
-      ],
-      parameters: {
-        sampleCount: 1,
-        aspectRatio: '1:1', // Options: 1:1, 3:4, 4:3, 9:16, 16:9
-        ...(options?.size && { aspectRatio: options.size }),
-      },
-    };
-
-    const response = await fetch(endpoint, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${this.apiKey}`,
-      },
-      body: JSON.stringify(requestBody),
-    });
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Google Imagen API error: ${response.status} - ${error}`);
-    }
-
-    const data: GoogleImagenResponse = await response.json();
-
-    if (
-      !data.predictions ||
-      data.predictions.length === 0 ||
-      !data.predictions[0].bytesBase64Encoded
-    ) {
-      throw new Error('No image data returned from Google Imagen API');
-    }
-
-    console.log('Image generated successfully!');
-
-    // Decode base64 image
-    const base64Image = data.predictions[0].bytesBase64Encoded;
-    return Buffer.from(base64Image, 'base64');
-  }
-}

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

@@ -1,94 +0,0 @@
-import type { ImageProvider } from '../types';
-
-export class MinimaxProvider implements ImageProvider {
-  private apiKey: string;
-  private baseUrl = 'https://api.minimax.chat/v1';
-
-  constructor(apiKey?: string) {
-    this.apiKey = apiKey || process.env.MINIMAX_API_KEY || '';
-    if (!this.apiKey) {
-      throw new Error('MINIMAX_API_KEY environment variable is required');
-    }
-  }
-
-  async generate(
-    prompt: string,
-    options?: { model?: string; size?: string }
-  ): Promise<Buffer> {
-    const aspectRatio = this.sizeToAspectRatio(options?.size);
-
-    console.log(`Generating image with Minimax image-01...`);
-    console.log(`Prompt: ${prompt}`);
-    console.log(`Aspect ratio: ${aspectRatio}`);
-
-    const response = await fetch(`${this.baseUrl}/image_generation`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${this.apiKey}`,
-      },
-      body: JSON.stringify({
-        model: options?.model || 'image-01',
-        prompt,
-        aspect_ratio: aspectRatio,
-        n: 1,
-        prompt_optimizer: true,
-      }),
-    });
-
-    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 };
-
-    for (let i = 0; i < 60; i++) {
-      await new Promise(r => setTimeout(r, 3000));
-
-      const statusRes = await fetch(
-        `${this.baseUrl}/query/image_generation?task_id=${data.task_id}`,
-        { headers: { 'Authorization': `Bearer ${this.apiKey}` } }
-      );
-      const status = await statusRes.json() as {
-        status: string;
-        file_id?: string;
-        base_resp?: { status_msg: string };
-      };
-
-      if (status.status === 'Success' && status.file_id) {
-        const fileRes = await fetch(
-          `${this.baseUrl}/files/retrieve?file_id=${status.file_id}`,
-          { headers: { 'Authorization': `Bearer ${this.apiKey}` } }
-        );
-        const fileData = await fileRes.json() as { file: { download_url: string } };
-
-        console.log('Image generated. Downloading...');
-        const imgRes = await fetch(fileData.file.download_url);
-        if (!imgRes.ok) throw new Error(`Download failed: ${imgRes.status}`);
-        return Buffer.from(await imgRes.arrayBuffer());
-      }
-
-      if (status.status === 'Fail') {
-        throw new Error(`Image generation failed: ${status.base_resp?.status_msg || 'Unknown'}`);
-      }
-    }
-
-    throw new Error('Image generation timed out');
-  }
-
-  private sizeToAspectRatio(size?: string): string {
-    if (!size) return '1:1';
-    const map: Record<string, string> = {
-      '1024x1024': '1:1',
-      '1792x1024': '16:9',
-      '1024x1792': '9:16',
-      '1:1': '1:1',
-      '16:9': '16:9',
-      '9:16': '9:16',
-      '4:3': '4:3',
-      '3:4': '3:4',
-    };
-    return map[size] || '1:1';
-  }
-}

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

@@ -1,80 +0,0 @@
-import type { ImageProvider, OpenAIImageResponse } from '../types';
-
-export class OpenAIProvider implements ImageProvider {
-  private apiKey: string;
-  private baseUrl = 'https://api.openai.com/v1';
-
-  constructor(apiKey?: string) {
-    this.apiKey = apiKey || process.env.OPENAI_API_KEY || '';
-    if (!this.apiKey) {
-      throw new Error('OPENAI_API_KEY environment variable is required');
-    }
-  }
-
-  async generate(
-    prompt: string,
-    options?: {
-      model?: string;
-      size?: string;
-    }
-  ): Promise<Buffer> {
-    const model = options?.model || 'dall-e-3';
-    const size = options?.size || '1024x1024';
-
-    // Validate size for DALL-E 3
-    const validSizes = ['1024x1024', '1792x1024', '1024x1792'];
-    if (!validSizes.includes(size)) {
-      throw new Error(
-        `Invalid size for DALL-E 3. Valid sizes: ${validSizes.join(', ')}`
-      );
-    }
-
-    console.log(`Generating image with OpenAI ${model}...`);
-    console.log(`Prompt: ${prompt}`);
-    console.log(`Size: ${size}`);
-
-    const response = await fetch(`${this.baseUrl}/images/generations`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${this.apiKey}`,
-      },
-      body: JSON.stringify({
-        model,
-        prompt,
-        n: 1,
-        size,
-        response_format: 'url',
-      }),
-    });
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`OpenAI API error: ${response.status} - ${error}`);
-    }
-
-    const data: OpenAIImageResponse = await response.json();
-
-    if (!data.data || data.data.length === 0 || !data.data[0].url) {
-      throw new Error('No image URL returned from OpenAI API');
-    }
-
-    const imageUrl = data.data[0].url;
-    console.log(`Image generated successfully!`);
-
-    if (data.data[0].revised_prompt) {
-      console.log(`Revised prompt: ${data.data[0].revised_prompt}`);
-    }
-
-    // Download the image
-    console.log('Downloading image...');
-    const imageResponse = await fetch(imageUrl);
-
-    if (!imageResponse.ok) {
-      throw new Error(`Failed to download image: ${imageResponse.status}`);
-    }
-
-    const arrayBuffer = await imageResponse.arrayBuffer();
-    return Buffer.from(arrayBuffer);
-  }
-}

package/skills/image/src/providers/xai.ts

@@ -1,73 +0,0 @@
-import type { ImageProvider, XAIImageResponse } from '../types';
-
-export class XAIProvider implements ImageProvider {
-  private apiKey: string;
-  private baseUrl = 'https://api.x.ai/v1';
-
-  constructor(apiKey?: string) {
-    this.apiKey = apiKey || process.env.XAI_API_KEY || '';
-    if (!this.apiKey) {
-      throw new Error('XAI_API_KEY environment variable is required');
-    }
-  }
-
-  async generate(
-    prompt: string,
-    options?: {
-      model?: string;
-      size?: string;
-    }
-  ): Promise<Buffer> {
-    const model = options?.model || 'grok-2-image-1212';
-
-    console.log(`Generating image with xAI ${model}...`);
-    console.log(`Prompt: ${prompt}`);
-
-    // xAI Grok-2 Image API endpoint (following OpenAI-compatible format)
-    const response = await fetch(`${this.baseUrl}/images/generations`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${this.apiKey}`,
-      },
-      body: JSON.stringify({
-        model,
-        prompt,
-        n: 1,
-        ...(options?.size && { size: options.size }),
-        response_format: 'url',
-      }),
-    });
-
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`xAI API error: ${response.status} - ${error}`);
-    }
-
-    const data: XAIImageResponse = await response.json();
-
-    if (!data.data || data.data.length === 0) {
-      throw new Error('No image data returned from xAI API');
-    }
-
-    console.log('Image generated successfully!');
-
-    // Handle both URL and base64 responses
-    if (data.data[0].url) {
-      const imageUrl = data.data[0].url;
-      console.log('Downloading image...');
-
-      const imageResponse = await fetch(imageUrl);
-      if (!imageResponse.ok) {
-        throw new Error(`Failed to download image: ${imageResponse.status}`);
-      }
-
-      const arrayBuffer = await imageResponse.arrayBuffer();
-      return Buffer.from(arrayBuffer);
-    } else if (data.data[0].b64_json) {
-      return Buffer.from(data.data[0].b64_json, 'base64');
-    } else {
-      throw new Error('No image URL or base64 data in response');
-    }
-  }
-}

package/skills/image/src/types.ts

@@ -1,37 +0,0 @@
-export interface GenerateOptions {
-  provider: 'minimax' | 'openai' | 'google' | 'xai';
-  prompt: string;
-  output: string;
-  model?: string;
-  size?: string;
-}
-
-export interface ImageProvider {
-  generate(prompt: string, options?: {
-    model?: string;
-    size?: string;
-  }): Promise<Buffer>;
-}
-
-export interface OpenAIImageResponse {
-  created: number;
-  data: Array<{
-    url?: string;
-    b64_json?: string;
-    revised_prompt?: string;
-  }>;
-}
-
-export interface GoogleImagenResponse {
-  predictions: Array<{
-    bytesBase64Encoded: string;
-    mimeType: string;
-  }>;
-}
-
-export interface XAIImageResponse {
-  data: Array<{
-    url?: string;
-    b64_json?: string;
-  }>;
-}

package/skills/logo-design/CLAUDE.md

@@ -1,30 +0,0 @@
-# logo-design
-
-AI logo design generator using the connectors REST API.
-
-## Tech Stack
-
-- Runtime: Bun
-- Language: TypeScript
-- CLI: Commander.js
-- Backend: connectors REST API (plain fetch, no SDK dependency)
-
-## CLI
-
-```bash
-logo-design generate <prompt> [options]
-logo-design providers
-logo-design tips
-```
-
-## Architecture
-
-Calls the connectors REST API directly via `fetch()`:
-- `POST /api/connectors/openai/operations/run` → `images generate` (gpt-image-1)
-- `POST /api/connectors/googlegemini/operations/run` → `image generate` (Nano Banana)
-
-The connectors server must be running on port 19426 (default).
-
-## Environment
-
-No direct API keys needed — keys are managed by the connectors server.