@hasna/skills 0.0.2

package/skills/skill-email-campaign/src/index.ts

@@ -0,0 +1,339 @@
+#!/usr/bin/env bun
+
+import { existsSync, mkdirSync, appendFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { randomUUID } from "crypto";
+import { parseArgs } from "util";
+
+// Constants
+const SKILL_NAME = "skill-email-campaign";
+const SESSION_ID = randomUUID().slice(0, 8);
+const SESSION_TIMESTAMP = new Date().toISOString().replace(/[:.]/g, "_").slice(0, 19);
+
+// Environment
+const SKILLS_OUTPUT_DIR = process.env.SKILLS_OUTPUT_DIR || join(process.cwd(), ".skills");
+const EXPORTS_DIR = join(SKILLS_OUTPUT_DIR, "exports", SKILL_NAME, SESSION_ID);
+const LOGS_DIR = join(SKILLS_OUTPUT_DIR, "logs", SKILL_NAME);
+
+const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
+const OPENAI_API_URL = "https://api.openai.com/v1/chat/completions";
+const OPENAI_IMAGE_URL = "https://api.openai.com/v1/images/generations";
+
+// Types
+interface Email {
+  sequence: number;
+  subject: string[];
+  previewText: string;
+  body: string;
+  cta: { primary: string; secondary?: string };
+  imagePrompt: string;
+  imagePath?: string;
+  sendTiming?: string;
+}
+
+interface Campaign {
+  type: string;
+  emailCount: number;
+  emails: Email[];
+}
+
+interface Options {
+  topic: string;
+  type: string;
+  emails: number;
+  variants: number;
+  brand: string;
+  tone: string;
+  cta: string;
+  audience: string;
+  format: string;
+  noImages: boolean;
+  verbose: boolean;
+}
+
+// Campaign type configs
+const CAMPAIGN_TYPES: Record<string, { emails: number; timing: string[] }> = {
+  single: { emails: 1, timing: ["immediately"] },
+  launch: { emails: 5, timing: ["Day -3", "Day -1", "Day 0", "Day 2", "Day 5"] },
+  welcome: { emails: 4, timing: ["Day 0", "Day 2", "Day 4", "Day 7"] },
+  nurture: { emails: 6, timing: ["Day 0", "Day 3", "Day 7", "Day 14", "Day 21", "Day 30"] },
+  reengagement: { emails: 3, timing: ["Day 0", "Day 3", "Day 7"] },
+  newsletter: { emails: 1, timing: ["weekly"] },
+  sale: { emails: 3, timing: ["Day 0", "Day 2", "Last day"] },
+  abandoned: { emails: 3, timing: ["1 hour", "24 hours", "48 hours"] },
+};
+
+// Utilities
+function ensureDir(dir: string): void {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+
+function log(message: string, level: "info" | "error" | "success" = "info"): void {
+  ensureDir(LOGS_DIR);
+  appendFileSync(join(LOGS_DIR, `log_${SESSION_TIMESTAMP}_${SESSION_ID}.log`), `[${new Date().toISOString()}] [${level.toUpperCase()}] ${message}\n`);
+  
+  const prefixes = { 
+    info: "ℹ️ ", 
+    error: "❌ ", 
+    success: "✅ " 
+  };
+
+  if (level === "error") {
+    console.error(`${prefixes[level]} ${message}`);
+  } else {
+    console.log(`${prefixes[level]} ${message}`);
+  }
+}
+
+function parseArguments(): Options {
+  const { values, positionals } = parseArgs({
+    args: process.argv.slice(2),
+    options: {
+      type: { type: "string", default: "single" },
+      emails: { type: "string", default: "0" },
+      variants: { type: "string", default: "2" },
+      brand: { type: "string", default: "neutral" },
+      tone: { type: "string", default: "friendly" },
+      cta: { type: "string", default: "auto" },
+      audience: { type: "string", default: "general" },
+      format: { type: "string", default: "markdown" },
+      "no-images": { type: "boolean", default: false },
+      verbose: { type: "boolean", default: false },
+      help: { type: "boolean", short: "h" },
+    },
+    allowPositionals: true,
+  });
+
+  if (values.help) {
+    printHelp();
+    process.exit(0);
+  }
+
+  const topic = positionals.join(" ");
+  
+  let emails = parseInt(values.emails as string, 10);
+  const type = values.type as string;
+
+  // Set default email count based on type
+  if (emails === 0) {
+    emails = CAMPAIGN_TYPES[type]?.emails || 1;
+  }
+
+  return {
+    topic,
+    type,
+    emails,
+    variants: parseInt(values.variants as string, 10),
+    brand: values.brand as string,
+    tone: values.tone as string,
+    cta: values.cta as string,
+    audience: values.audience as string,
+    format: values.format as string,
+    noImages: values["no-images"] as boolean,
+    verbose: values.verbose as boolean,
+  };
+}
+
+function printHelp(): void {
+  console.log(`
+Email Campaign Generator - Create email sequences with copy and images
+
+Usage:
+  skills run email-campaign -- "<campaign topic>" [options]
+
+Options:
+  --type <type>         Campaign type: single, launch, welcome, nurture, reengagement, newsletter, sale, abandoned
+  --emails <n>          Number of emails in sequence
+  --variants <n>        Subject line variants for A/B testing (default: 2)
+  --brand <desc>        Brand voice description
+  --tone <tone>         Tone: professional, friendly, urgent, exclusive
+  --cta <text>          Primary call-to-action
+  --audience <desc>     Target audience description
+  --format <format>     Output: markdown, json, html
+  --no-images           Skip hero image generation
+  --verbose             Show detailed progress
+  --help, -h            Show this help
+
+Examples:
+  skills run email-campaign -- "Summer sale: 30% off all products"
+  skills run email-campaign -- "New product launch" --type launch
+  skills run email-campaign -- "Welcome to membership" --type welcome --emails 4
+`);
+}
+
+async function generateEmailCampaign(options: Options): Promise<Campaign> {
+  const typeConfig = CAMPAIGN_TYPES[options.type] || CAMPAIGN_TYPES.single;
+
+  const systemPrompt = `You are an expert email marketing copywriter. Create compelling email campaigns that convert.
+Brand voice: ${options.brand}
+Target audience: ${options.audience}
+Tone: ${options.tone}
+
+Best practices:
+- Subject lines: 30-50 characters, curiosity-inducing
+- Preview text: Complements subject, 40-90 characters
+- Body: Scannable, benefit-focused, single CTA focus
+- Avoid spam trigger words`;
+
+  const userPrompt = `Create a ${options.type} email campaign for:
+"${options.topic}"
+
+Campaign details:
+- Number of emails: ${options.emails}
+- Subject line variants per email: ${options.variants}
+- Timing: ${typeConfig.timing.slice(0, options.emails).join(", ")}
+${options.cta !== "auto" ? `- Preferred CTA: ${options.cta}` : ""}
+
+Return JSON:
+{
+  "type": "${options.type}",
+  "emailCount": ${options.emails},
+  "emails": [{
+    "sequence": 1,
+    "subject": ["Subject A", "Subject B"],
+    "previewText": "Preview text here",
+    "body": "Full email body with [Name] merge tags, formatted with paragraphs",
+    "cta": { "primary": "CTA text", "secondary": "Optional secondary" },
+    "imagePrompt": "DALL-E prompt for hero image",
+    "sendTiming": "timing description"
+  }]
+}`;
+
+  const response = await fetch(OPENAI_API_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${OPENAI_API_KEY}` },
+    body: JSON.stringify({
+      model: "gpt-4o",
+      messages: [{ role: "system", content: systemPrompt }, { role: "user", content: userPrompt }],
+      max_tokens: 4096,
+      temperature: 0.7,
+    }),
+  });
+
+  if (!response.ok) throw new Error(`OpenAI API error: ${response.status}`);
+
+  const result = await response.json();
+  let content = result.choices[0]?.message?.content || "{}";
+  if (content.includes("```json")) content = content.replace(/```json\n?/g, "").replace(/```\n?/g, "");
+
+  return JSON.parse(content.trim());
+}
+
+async function generateImage(prompt: string, filename: string): Promise<string> {
+  const response = await fetch(OPENAI_IMAGE_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${OPENAI_API_KEY}` },
+    body: JSON.stringify({
+      model: "dall-e-3", // Updated to dall-e-3
+      prompt: `Email hero image: ${prompt}. Professional marketing visual, clean design, no text, suitable for email header at 600px wide.`,
+      n: 1,
+      size: "1024x1024", // DALL-E 3 standard size
+      quality: "standard",
+      response_format: "b64_json",
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Image generation failed: ${response.status} - ${error}`);
+  }
+
+  const result = await response.json();
+  const b64Data = result.data[0]?.b64_json;
+
+  if (b64Data) {
+    const imageBuffer = Buffer.from(b64Data, "base64");
+    const imagePath = join(EXPORTS_DIR, filename);
+    writeFileSync(imagePath, imageBuffer);
+    return imagePath;
+  }
+  throw new Error("No image data returned");
+}
+
+function formatOutput(campaign: Campaign, options: Options): string {
+  if (options.format === "json") return JSON.stringify(campaign, null, 2);
+
+  let output = `# Email Campaign: ${options.topic}\n\n`;
+  output += `**Type:** ${campaign.type}\n`;
+  output += `**Emails:** ${campaign.emailCount}\n`;
+  output += `**Generated:** ${new Date().toISOString()}\n\n---\n\n`;
+
+  for (const email of campaign.emails) {
+    output += `## Email ${email.sequence}${email.sendTiming ? ` (${email.sendTiming})` : ""}\n\n`;
+
+    output += `### Subject Lines (A/B Test)\n`;
+    email.subject.forEach((subj, i) => {
+      output += `- ${String.fromCharCode(65 + i)}: "${subj}"\n`;
+    });
+    output += `\n`;
+
+    output += `### Preview Text\n"${email.previewText}"\n\n`;
+
+    if (email.imagePath) {
+      output += `### Hero Image\n${email.imagePath}\n\n`;
+    }
+
+    output += `### Email Body\n\n${email.body}\n\n`;
+
+    output += `### CTA\n`;
+    output += `- **Primary:** [${email.cta.primary}]\n`;
+    if (email.cta.secondary) output += `- **Secondary:** [${email.cta.secondary}]\n`;
+    output += `\n---\n\n`;
+  }
+
+  return output;
+}
+
+async function main(): Promise<void> {
+  const startTime = Date.now();
+  
+  // Parse args first to check for help
+  const options = parseArguments();
+
+  log(`Starting ${SKILL_NAME} session: ${SESSION_ID}`);
+
+  if (!OPENAI_API_KEY) {
+    log("Error: OPENAI_API_KEY environment variable is required.", "error");
+    process.exit(1);
+  }
+
+  if (!options.topic) {
+    log("Error: Please provide a campaign topic.", "error");
+    process.exit(1);
+  }
+
+  ensureDir(EXPORTS_DIR);
+
+  try {
+    log("Generating email campaign...");
+    const campaign = await generateEmailCampaign(options);
+    log(`Generated ${campaign.emails.length} emails`, "success");
+
+    if (!options.noImages) {
+      log("Generating hero images...");
+      for (const email of campaign.emails) {
+        try {
+          const filename = `email-${email.sequence}-hero-${SESSION_ID}.png`;
+          email.imagePath = await generateImage(email.imagePrompt, filename);
+          log(`Image saved: ${filename}`, "success");
+        } catch (err) {
+          log(`Failed to generate image: ${err}`, "error");
+        }
+      }
+    }
+
+    const output = formatOutput(campaign, options);
+    const ext = options.format === "json" ? "json" : "md";
+    writeFileSync(join(EXPORTS_DIR, `email-campaign.${ext}`), output, "utf-8");
+
+    console.log("\n" + "=".repeat(60) + "\n");
+    console.log(output);
+
+    log(`Completed in ${Date.now() - startTime}ms`, "success");
+  } catch (error) {
+    log(`Error: ${error instanceof Error ? error.message : String(error)}`, "error");
+    process.exit(1);
+  }
+}
+
+main();

package/skills/skill-email-campaign/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "declaration": true,
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*", "bin/**/*"]
+}

package/skills/skill-emoji/.env.example

@@ -0,0 +1,7 @@
+# OpenAI API Key
+# Get your key from: https://platform.openai.com/api-keys
+OPENAI_API_KEY=sk-...
+
+# Google Gemini API Key
+# Get your key from: https://aistudio.google.com/apikey
+GEMINI_API_KEY=...

package/skills/skill-emoji/QUICKSTART.md

@@ -0,0 +1,52 @@
+# Quick Start Guide
+
+Generate your first emoji pack in 2 minutes.
+
+## Step 1: Set up API Key
+
+```bash
+export OPENAI_API_KEY="sk-..."
+```
+
+## Step 2: Generate Emojis
+
+```bash
+cd skill-emoji
+bun install
+bun run src/index.ts generate --theme "Christmas" --count 5
+```
+
+## Step 3: Check Output
+
+```bash
+ls -la emoji-christmas/
+open emoji-christmas/
+```
+
+## Examples
+
+```bash
+# Food emojis
+bun run src/index.ts generate -t "Food" -c 10
+
+# Weather as zip
+bun run src/index.ts generate -t "Weather" -c 6 -f zip
+
+# Large 3D animals
+bun run src/index.ts generate -t "Animals" -c 8 --style 3d -s 256
+
+# Office icons
+bun run src/index.ts generate -t "Office and Work" -c 12
+```
+
+## Output
+
+Each run creates:
+- Individual PNG files (128x128 by default)
+- `manifest.json` with metadata
+
+## Next Steps
+
+- Read full [README.md](README.md)
+- Check [SKILL.md](SKILL.md) for skill metadata
+- Try different themes and styles

package/skills/skill-emoji/README.md

@@ -0,0 +1,175 @@
+# Emoji Pack Generator Skill
+
+Generate complete emoji packs using AI. Provide a theme, and the AI will create prompts for each emoji and generate them using OpenAI DALL-E 3 or Google Gemini.
+
+## Features
+
+- AI-powered prompt generation for cohesive emoji sets
+- Multiple providers: OpenAI DALL-E 3, Google Gemini
+- Concurrent image generation for speed
+- Automatic resizing to any target size
+- Multiple output formats: directory or zip
+- Customizable styles: flat, 3d, outline, gradient
+- Manifest file with metadata and prompts
+
+## Installation
+
+```bash
+cd skill-emoji
+bun install
+```
+
+## Configuration
+
+Set up your API keys as environment variables:
+
+```bash
+# OpenAI (for both prompt generation and image generation)
+export OPENAI_API_KEY="your-openai-api-key"
+
+# Google Gemini (for both prompt generation and image generation)
+export GEMINI_API_KEY="your-gemini-api-key"
+export GOOGLE_PROJECT_ID="your-google-project-id"  # Required for Gemini images
+```
+
+## Usage
+
+### Basic Commands
+
+```bash
+# Generate 5 Christmas emojis (default)
+bun run src/index.ts generate --theme "Christmas"
+
+# Generate 10 food emojis
+bun run src/index.ts generate --theme "Food and Drinks" --count 10
+
+# Generate animal emojis with Gemini
+bun run src/index.ts generate --theme "Cute Animals" --count 8 --provider gemini
+```
+
+### Advanced Options
+
+```bash
+# Generate as zip file
+bun run src/index.ts generate \
+  --theme "Weather" \
+  --count 6 \
+  --format zip \
+  --output ./weather-emojis.zip
+
+# Generate 3D style, larger size
+bun run src/index.ts generate \
+  --theme "Sports" \
+  --count 12 \
+  --style 3d \
+  --size 256
+
+# Custom output directory with high concurrency
+bun run src/index.ts generate \
+  --theme "Office" \
+  --count 15 \
+  --output ./my-emojis \
+  --concurrency 5
+```
+
+### Short Flags
+
+```bash
+bun run src/index.ts generate \
+  -t "Halloween" \
+  -c 10 \
+  -p openai \
+  -s 128 \
+  -f directory \
+  -o ./halloween-emojis
+```
+
+## Options Reference
+
+| Option | Short | Default | Description |
+|--------|-------|---------|-------------|
+| `--theme` | `-t` | required | Theme for the emoji pack |
+| `--count` | `-c` | 5 | Number of emojis (1-50) |
+| `--provider` | `-p` | openai | Image provider (openai, gemini) |
+| `--size` | `-s` | 128 | Output size in pixels |
+| `--style` | | flat | Style (flat, 3d, outline, gradient) |
+| `--output` | `-o` | auto | Output path |
+| `--format` | `-f` | directory | Output format (directory, zip) |
+| `--concurrency` | | 3 | Concurrent image generations |
+
+## Workflow
+
+1. **Prompt Generation**: AI analyzes the theme and generates creative prompts for each emoji
+2. **Image Generation**: Prompts are dispatched concurrently to the image provider
+3. **Resizing**: Generated images are resized to the target size
+4. **Output**: Files are saved to directory or packaged as zip
+
+## Output Structure
+
+### Directory Format
+
+```
+emoji-christmas/
+├── manifest.json
+├── santa-hat.png
+├── gift-box.png
+├── snowflake.png
+├── christmas-tree.png
+└── candy-cane.png
+```
+
+### Manifest File
+
+```json
+{
+  "theme": "Christmas",
+  "count": 5,
+  "size": 128,
+  "generated": "2024-12-11T12:00:00.000Z",
+  "emojis": [
+    {
+      "name": "santa-hat",
+      "filename": "santa-hat.png",
+      "prompt": "A red Santa Claus hat with white fluffy trim..."
+    }
+  ]
+}
+```
+
+## Styles
+
+- **flat**: Solid colors, no shadows, minimal detail
+- **3d**: Soft 3D style, subtle shadows, rounded shapes
+- **outline**: Line art style, clean outlines
+- **gradient**: Gradient colors, smooth transitions
+
+## Provider Details
+
+### OpenAI DALL-E 3
+
+- High-quality, detailed images
+- Great for creative and stylized emojis
+- Faster prompt revision and enhancement
+
+### Google Gemini (Imagen 3)
+
+- Photorealistic capabilities
+- Good for realistic emoji styles
+- Requires Google Cloud Project ID
+
+## Tips
+
+1. **Theme specificity**: More specific themes produce more cohesive packs
+2. **Count**: Start with 5-10 to test, then scale up
+3. **Concurrency**: Higher values = faster, but may hit rate limits
+4. **Size**: 128px is standard for emojis, 256px for icons
+
+## Error Handling
+
+- Failed generations are logged but don't stop the process
+- Partial results are still saved
+- Manifest includes only successfully generated emojis
+
+## License
+
+MIT

package/skills/skill-emoji/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: emoji
+description: Generate emoji packs using AI-powered prompt generation and image creation
+---
+
+# Emoji Pack Generator Skill
+
+Generate complete emoji packs from a single theme using AI.
+
+## Supported Providers
+
+### OpenAI
+- **Prompt Model**: gpt-4o-mini
+- **Image Model**: dall-e-3
+- **API Key**: `OPENAI_API_KEY`
+
+### Google Gemini
+- **Prompt Model**: gemini-1.5-flash
+- **Image Model**: imagen-3.0-generate-001
+- **API Keys**: `GEMINI_API_KEY`, `GOOGLE_PROJECT_ID`
+
+## Usage
+
+```bash
+# Basic usage
+bun run src/index.ts generate --theme "Christmas" --count 10
+
+# With options
+bun run src/index.ts generate \
+  --theme "Food" \
+  --count 15 \
+  --provider openai \
+  --style 3d \
+  --size 256 \
+  --format zip \
+  --output ./food-emojis.zip
+```
+
+## Options
+
+- `--theme, -t`: Theme for emoji pack (required)
+- `--count, -c`: Number of emojis (1-50, default: 5)
+- `--provider, -p`: openai or gemini (default: openai)
+- `--style`: flat, 3d, outline, gradient (default: flat)
+- `--size, -s`: Output size in pixels (default: 128)
+- `--format, -f`: directory or zip (default: directory)
+- `--output, -o`: Output path
+- `--concurrency`: Parallel generations (default: 3)
+
+## Environment Variables
+
+```bash
+export OPENAI_API_KEY="your-openai-key"
+export GEMINI_API_KEY="your-gemini-key"
+export GOOGLE_PROJECT_ID="your-project-id"
+```
+
+## Workflow
+
+1. AI generates creative prompts based on theme
+2. Images generated concurrently via selected provider
+3. Images resized to target size
+4. Output saved with manifest.json

package/skills/skill-emoji/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "skill-emoji",
+  "version": "1.0.0",
+  "description": "Generate emoji packs using AI (OpenAI or Gemini) with automatic prompt generation",
+  "main": "src/index.ts",
+  "type": "module",
+  "bin": {
+    "skill-emoji": "src/index.ts"
+  },
+  "scripts": {
+    "start": "bun run src/index.ts",
+    "generate": "bun run src/index.ts generate"
+  },
+  "keywords": [
+    "emoji-generation",
+    "ai",
+    "dall-e",
+    "gemini",
+    "openai",
+    "google",
+    "icon",
+    "emoji-pack"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  }
+}