@hasna/skills 0.1.23 → 0.1.25

package/skills/livestream-runofshow/src/index.ts

@@ -0,0 +1,299 @@
+#!/usr/bin/env bun
+/**
+ * livestream-runofshow
+ * Generates livestream run-of-show plans using OpenAI.
+ */
+
+import { parseArgs } from "util";
+import { existsSync, mkdirSync, appendFileSync } from "fs";
+import { join, dirname } from "path";
+
+type OutputFormat = "markdown" | "json";
+
+interface SkillOptions {
+  brief: string;
+  duration: number;
+  platforms: string[];
+  hosts?: string;
+  goals?: string;
+  format: OutputFormat;
+  model: string;
+  output?: string;
+}
+
+interface OpenAIChatResponse {
+  choices?: Array<{
+    message?: {
+      content?: string | null;
+    };
+  }>;
+  error?: {
+    message?: string;
+  };
+}
+
+const SKILL_SLUG = "livestream-runofshow";
+
+function ensureDir(path: string) {
+  if (!existsSync(path)) {
+    mkdirSync(path, { recursive: true });
+  }
+}
+
+function getPaths() {
+  const sessionStamp = new Date().toISOString().replace(/[:.]/g, "_").replace(/-/g, "_");
+  const exportsRoot = process.env.SKILLS_EXPORTS_DIR || join(process.cwd(), ".skills", "exports");
+  const logsRoot = process.env.SKILLS_LOGS_DIR || join(process.cwd(), ".skills", "logs");
+
+  const skillExportsDir = join(exportsRoot, SKILL_SLUG);
+  const skillLogsDir = join(logsRoot, SKILL_SLUG);
+
+  ensureDir(skillExportsDir);
+  ensureDir(skillLogsDir);
+
+  return {
+    sessionStamp,
+    skillExportsDir,
+    skillLogsDir,
+  };
+}
+
+function createLogger(logDir: string, sessionStamp: string) {
+  const logFile = join(logDir, `log_${sessionStamp}.txt`);
+
+  function write(level: "info" | "success" | "error", message: string) {
+    const timestamp = new Date().toISOString();
+    const entry = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
+    appendFileSync(logFile, entry);
+    const prefix = level === "success" ? "✅" : level === "error" ? "❌" : "ℹ️";
+    console.log(`${prefix} ${message}`);
+  }
+
+  return {
+    info: (message: string) => write("info", message),
+    success: (message: string) => write("success", message),
+    error: (message: string) => write("error", message),
+    logFile,
+  };
+}
+
+function slugify(value: string): string {
+  return value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 40) || "livestream";
+}
+
+function showHelp(): void {
+  console.log(`
+livestream-runofshow - Generate livestream run-of-show plans using AI
+
+Usage:
+  skills run livestream-runofshow -- "<brief>" [options]
+  skills run livestream-runofshow -- --brief "<brief>" [options]
+
+Options:
+  -h, --help               Show this help message
+  --brief <text>           Livestream brief/description
+  --duration <minutes>     Duration in minutes (default: 90, min: 15)
+  --platforms <list>       Comma-separated platforms (default: YouTube Live, Twitch)
+  --hosts <names>          Host/talent names
+  --goals <objectives>     Goals for the stream
+  --format <type>          Output format: markdown | json (default: markdown)
+  --model <model>          OpenAI model (default: gpt-4o-mini)
+  --output <path>          Custom output file path
+
+Output includes:
+  - Timeline with pre-show, main content, breaks, and post-show
+  - Scene list for OBS/vMix/StreamYard with hotkey cues
+  - Host script prompts and interaction beats
+  - Audience engagement tactics (polls, chat prompts, giveaways)
+  - Technical checklist
+  - Contingency plans
+  - Sponsor/CTA placement notes
+
+Examples:
+  skills run livestream-runofshow -- "Gaming tournament finale" --duration 120
+  skills run livestream-runofshow -- --brief "Product launch stream" --platforms "YouTube,Twitch,LinkedIn"
+
+Requirements:
+  OPENAI_API_KEY environment variable must be set.
+`);
+}
+
+function parseOptions(): SkillOptions {
+  const { values, positionals } = parseArgs({
+    args: Bun.argv.slice(2),
+    options: {
+      help: { type: "boolean", short: "h" },
+      brief: { type: "string" },
+      duration: { type: "string" },
+      platforms: { type: "string" },
+      hosts: { type: "string" },
+      goals: { type: "string" },
+      format: { type: "string", default: "markdown" },
+      model: { type: "string", default: "gpt-4o-mini" },
+      output: { type: "string" },
+    },
+    allowPositionals: true,
+  });
+
+  if (values.help) {
+    showHelp();
+    process.exit(0);
+  }
+
+  const brief = values.brief || positionals.join(" ").trim();
+  if (!brief) {
+    throw new Error("Provide a livestream brief via positional text or --brief.");
+  }
+
+  const duration = values.duration ? parseInt(values.duration, 10) : 90;
+  if (Number.isNaN(duration) || duration < 15) {
+    throw new Error("--duration must be an integer >= 15.");
+  }
+
+  const platforms = values.platforms
+    ? values.platforms.split(",").map(p => p.trim()).filter(Boolean)
+    : ["YouTube Live", "Twitch"];
+
+  const format: OutputFormat =
+    values.format === "json" ? "json" : values.format === "markdown" ? "markdown" : "markdown";
+
+  return {
+    brief,
+    duration,
+    platforms,
+    hosts: values.hosts,
+    goals: values.goals,
+    format,
+    model: values.model,
+    output: values.output,
+  };
+}
+
+function buildPrompt(options: SkillOptions) {
+  const system = `You are a livestream producer and technical director.
+Create a run-of-show plan that includes:
+- Timeline covering ${options.duration} minutes with pre-show, main content, breaks, and post-show wrap.
+- Scene list for OBS/vMix/StreamYard (camera, screen share, media, lower thirds) with hotkey cues.
+- Host/${options.hosts || "talent"} script prompts and interaction beats for ${options.platforms.join(", ")}.
+- Audience engagement tactics (polls, chat prompts, giveaways) tied to goals (${options.goals || "engage audience, drive CTA"}).
+- Technical checklist (audio routing, redundancy, stream keys, safety checks).
+- Contingency plans for network failure, guest drop, or content overruns.
+- Sponsor/CTA placement notes and post-show follow-up actions.
+- Accessibility reminders (captions, audio description options, chat moderation).`;
+
+  const instructions =
+    options.format === "json"
+      ? "Respond in JSON with keys: overview, timeline, scenes, scripts, engagement, technical, contingencies, followup. Timeline should be ordered with minute_start, minute_end, segment, notes."
+      : "Respond in polished Markdown. Start with an executive summary blockquote, include tables for timeline and scenes, and bullet lists for scripts, technical notes, contingencies, follow-up.";
+
+  const userPayload = {
+    livestream_brief: options.brief,
+    duration_minutes: options.duration,
+    platforms: options.platforms,
+    hosts: options.hosts,
+    goals: options.goals,
+    format: options.format,
+  };
+
+  const user = `${instructions}\n\n${JSON.stringify(userPayload, null, 2)}`;
+
+  return { system, user };
+}
+
+async function callOpenAI(options: SkillOptions, system: string, user: string): Promise<string> {
+  const apiKey = process.env.OPENAI_API_KEY;
+
+  if (!apiKey) {
+    throw new Error("OPENAI_API_KEY environment variable is required.");
+  }
+
+  const body = {
+    model: options.model,
+    messages: [
+      { role: "system", content: system },
+      { role: "user", content: user },
+    ],
+    temperature: 0.58,
+    max_tokens: options.format === "json" ? 2300 : 2000,
+  };
+
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify(body),
+  });
+
+  const data: OpenAIChatResponse = await response.json();
+
+  if (!response.ok) {
+    throw new Error(data.error?.message || `OpenAI API error (${response.status})`);
+  }
+
+  const content = data.choices?.[0]?.message?.content;
+
+  if (!content) {
+    throw new Error("OpenAI response did not include content.");
+  }
+
+  return content.trim();
+}
+
+async function writeExport(path: string, content: string) {
+  ensureDir(dirname(path));
+  await Bun.write(path, content);
+}
+
+async function run() {
+  const options = parseOptions();
+  const { sessionStamp, skillExportsDir, skillLogsDir } = getPaths();
+  const logger = createLogger(skillLogsDir, sessionStamp);
+
+  try {
+    logger.info("Planning livestream run-of-show.");
+    logger.info(`Format: ${options.format.toUpperCase()}, Model: ${options.model}`);
+
+    const { system, user } = buildPrompt(options);
+    const content = await callOpenAI(options, system, user);
+
+    const slugBase = options.brief.split(/\s+/).slice(0, 4).join("-");
+    const planSlug = slugify(slugBase);
+    const extension = options.format === "json" ? "json" : "md";
+    const defaultPath = join(skillExportsDir, `livestream-plan-${planSlug}-${sessionStamp}.${extension}`);
+    const targetPath = options.output ? options.output : defaultPath;
+
+    let finalContent = content;
+
+    if (options.format === "json") {
+      try {
+        finalContent = JSON.stringify(JSON.parse(content), null, 2);
+      } catch {
+        logger.error("Model response was not valid JSON. Wrapping raw response.");
+        finalContent = JSON.stringify({ raw: content }, null, 2);
+      }
+    }
+
+    await writeExport(targetPath, finalContent);
+
+    logger.success("Livestream run-of-show generated successfully.");
+    console.log("\n=== Livestream Plan Preview ===\n");
+    console.log(finalContent.slice(0, 1500));
+    if (finalContent.length > 1500) {
+      console.log("\n… (truncated)");
+    }
+    console.log(`\nExport saved to: ${targetPath}`);
+    console.log(`Logs written to: ${skillLogsDir}`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(message);
+    process.exit(1);
+  }
+}
+
+run();

package/skills/logo-design/CLAUDE.md

@@ -0,0 +1,30 @@
+# 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.

package/skills/logo-design/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: logo-design
+description: Generate professional logos using AI (OpenAI GPT Image, Google Gemini Nano Banana)
+---
+
+# Logo Design Skill
+
+Generate professional logo designs from text descriptions using multiple AI image providers via the connectors REST API.
+
+## Providers
+
+### OpenAI GPT Image
+- **Model**: gpt-image-1
+- **Sizes**: 1024x1024, 1536x1024, 1024x1536
+- **Best for**: Clean vector-style logos, text rendering, minimal designs
+- **Connector**: `openai` (requires API key configured)
+
+### Google Gemini (Nano Banana)
+- **Model**: gemini-2.5-flash-preview-image-generation
+- **Sizes**: Configurable aspect ratios (1:1, 16:9, 9:16)
+- **Best for**: Creative exploration, stylized concepts, detailed compositions
+- **Connector**: `googlegemini` (requires API key configured)
+
+## Usage
+
+```bash
+# Generate with OpenAI GPT Image (default)
+logo-design generate "minimalist geometric owl logo, flat vector, navy and gold, white background"
+
+# Generate with Gemini
+logo-design generate --provider gemini "modern tech startup logo, abstract hexagon, clean lines"
+
+# Save to specific file
+logo-design generate --output ./my-logo.png "coffee shop logo, vintage style, warm tones"
+
+# Generate multiple variations
+logo-design generate --variations 4 "mountain peak logo, minimalist, black and white"
+
+# List available providers and their status
+logo-design providers
+```
+
+## Options
+
+| Flag | Description | Default |
+|------|-------------|---------|
+| `--provider` | Provider: `openai` or `gemini` | `openai` |
+| `--output` / `-o` | Output file path | `./logo_{timestamp}.png` |
+| `--variations` / `-n` | Number of variations | `1` |
+| `--size` / `-s` | Image size (OpenAI: 1024x1024, etc.) | `1024x1024` |
+| `--aspect-ratio` / `-a` | Aspect ratio for Gemini (1:1, 16:9) | `1:1` |
+| `--quality` / `-q` | Quality level (openai: standard/hd) | `hd` |
+| `--server` | Connectors server URL | `http://localhost:19426` |
+
+## Logo Design Tips
+
+1. **Be specific**: "minimalist geometric owl logo, flat vector, navy and gold, white background" beats "owl logo"
+2. **Specify style**: flat vector, 3D, vintage, modern, hand-drawn, geometric, abstract
+3. **Request white/solid background**: Prevents complex backgrounds bleeding into the mark
+4. **Keep it simple**: Logos must work at favicon size (16x16). Ask for clean, minimal designs
+5. **Skip text in the logo**: AI models struggle with typography. Generate the icon, add text in Illustrator/Figma
+6. **Generate many variations**: Run 4-10 variations with slight prompt tweaks, pick the best
+
+## Prerequisites
+
+The connectors server must be running with OpenAI and/or Google Gemini connectors configured:
+
+```bash
+connectors serve    # Start connectors server on port 19426
+```

package/skills/logo-design/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "logo-design",
+  "version": "1.0.0",
+  "description": "Generate professional logos using AI image providers",
+  "type": "module",
+  "main": "src/index.ts",
+  "bin": {
+    "logo-design": "src/index.ts"
+  },
+  "scripts": {
+    "start": "bun run src/index.ts",
+    "generate": "bun run src/index.ts generate"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  }
+}