@hasna/skills 0.1.21 → 0.1.22

package/skills/skill-logo-design/node_modules/undici-types/websocket.d.ts

@@ -0,0 +1,186 @@
+/// <reference types="node" />
+
+import type { Blob } from 'node:buffer'
+import type { ReadableStream, WritableStream } from 'node:stream/web'
+import type { MessagePort } from 'node:worker_threads'
+import {
+  EventInit,
+  EventListenerOptions,
+  AddEventListenerOptions,
+  EventListenerOrEventListenerObject
+} from './patch'
+import Dispatcher from './dispatcher'
+import { HeadersInit } from './fetch'
+
+export type BinaryType = 'blob' | 'arraybuffer'
+
+interface WebSocketEventMap {
+  close: CloseEvent
+  error: ErrorEvent
+  message: MessageEvent
+  open: Event
+}
+
+interface WebSocket extends EventTarget {
+  binaryType: BinaryType
+
+  readonly bufferedAmount: number
+  readonly extensions: string
+
+  onclose: ((this: WebSocket, ev: WebSocketEventMap['close']) => any) | null
+  onerror: ((this: WebSocket, ev: WebSocketEventMap['error']) => any) | null
+  onmessage: ((this: WebSocket, ev: WebSocketEventMap['message']) => any) | null
+  onopen: ((this: WebSocket, ev: WebSocketEventMap['open']) => any) | null
+
+  readonly protocol: string
+  readonly readyState: number
+  readonly url: string
+
+  close(code?: number, reason?: string): void
+  send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void
+
+  readonly CLOSED: number
+  readonly CLOSING: number
+  readonly CONNECTING: number
+  readonly OPEN: number
+
+  addEventListener<K extends keyof WebSocketEventMap>(
+    type: K,
+    listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any,
+    options?: boolean | AddEventListenerOptions
+  ): void
+  addEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | AddEventListenerOptions
+  ): void
+  removeEventListener<K extends keyof WebSocketEventMap>(
+    type: K,
+    listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any,
+    options?: boolean | EventListenerOptions
+  ): void
+  removeEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject,
+    options?: boolean | EventListenerOptions
+  ): void
+}
+
+export declare const WebSocket: {
+  prototype: WebSocket
+  new (url: string | URL, protocols?: string | string[] | WebSocketInit): WebSocket
+  readonly CLOSED: number
+  readonly CLOSING: number
+  readonly CONNECTING: number
+  readonly OPEN: number
+}
+
+interface CloseEventInit extends EventInit {
+  code?: number
+  reason?: string
+  wasClean?: boolean
+}
+
+interface CloseEvent extends Event {
+  readonly code: number
+  readonly reason: string
+  readonly wasClean: boolean
+}
+
+export declare const CloseEvent: {
+  prototype: CloseEvent
+  new (type: string, eventInitDict?: CloseEventInit): CloseEvent
+}
+
+interface MessageEventInit<T = any> extends EventInit {
+  data?: T
+  lastEventId?: string
+  origin?: string
+  ports?: MessagePort[]
+  source?: MessagePort | null
+}
+
+interface MessageEvent<T = any> extends Event {
+  readonly data: T
+  readonly lastEventId: string
+  readonly origin: string
+  readonly ports: readonly MessagePort[]
+  readonly source: MessagePort | null
+  initMessageEvent(
+    type: string,
+    bubbles?: boolean,
+    cancelable?: boolean,
+    data?: any,
+    origin?: string,
+    lastEventId?: string,
+    source?: MessagePort | null,
+    ports?: MessagePort[]
+  ): void;
+}
+
+export declare const MessageEvent: {
+  prototype: MessageEvent
+  new<T>(type: string, eventInitDict?: MessageEventInit<T>): MessageEvent<T>
+}
+
+interface ErrorEventInit extends EventInit {
+  message?: string
+  filename?: string
+  lineno?: number
+  colno?: number
+  error?: any
+}
+
+interface ErrorEvent extends Event {
+  readonly message: string
+  readonly filename: string
+  readonly lineno: number
+  readonly colno: number
+  readonly error: Error
+}
+
+export declare const ErrorEvent: {
+  prototype: ErrorEvent
+  new (type: string, eventInitDict?: ErrorEventInit): ErrorEvent
+}
+
+interface WebSocketInit {
+  protocols?: string | string[],
+  dispatcher?: Dispatcher,
+  headers?: HeadersInit
+}
+
+interface WebSocketStreamOptions {
+  protocols?: string | string[]
+  signal?: AbortSignal
+}
+
+interface WebSocketCloseInfo {
+  closeCode: number
+  reason: string
+}
+
+interface WebSocketStream {
+  closed: Promise<WebSocketCloseInfo>
+  opened: Promise<{
+    extensions: string
+    protocol: string
+    readable: ReadableStream
+    writable: WritableStream
+  }>
+  url: string
+}
+
+export declare const WebSocketStream: {
+  prototype: WebSocketStream
+  new (url: string | URL, options?: WebSocketStreamOptions): WebSocketStream
+}
+
+interface WebSocketError extends Event, WebSocketCloseInfo {}
+
+export declare const WebSocketError: {
+  prototype: WebSocketError
+  new (type: string, init?: WebSocketCloseInfo): WebSocketError
+}
+
+export declare const ping: (ws: WebSocket, body?: Buffer) => void

package/skills/skill-logo-design/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "skill-logo-design",
+  "version": "1.0.0",
+  "description": "AI logo design using OpenAI GPT Image and Google Gemini via connectors REST API",
+  "type": "module",
+  "bin": {
+    "skill-logo-design": "./src/index.ts"
+  },
+  "scripts": {
+    "start": "bun run src/index.ts",
+    "typecheck": "tsc --noEmit",
+    "build": "bun build src/index.ts --outdir dist --target node"
+  },
+  "dependencies": {
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.0.0"
+  }
+}

package/skills/skill-logo-design/src/index.ts

@@ -0,0 +1,322 @@
+#!/usr/bin/env bun
+
+import { Command } from "commander";
+import chalk from "chalk";
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { dirname, resolve, extname } from "path";
+
+// ── Connectors REST API client (inline, no SDK dependency) ───────────
+
+const DEFAULT_SERVER = "http://localhost:19426";
+
+interface RunOperationResponse {
+  connector: string;
+  displayName: string;
+  success: boolean;
+  output: string;
+}
+
+interface ConnectorInfo {
+  name: string;
+  displayName: string;
+  description: string;
+  category: string;
+  auth: { type: string; connected: boolean } | null;
+}
+
+async function connectorGet(server: string, name: string): Promise<ConnectorInfo> {
+  const res = await fetch(`${server}/api/connectors/${encodeURIComponent(name)}`);
+  if (!res.ok) throw new Error(`Connector "${name}" not available (${res.status})`);
+  return res.json() as Promise<ConnectorInfo>;
+}
+
+async function connectorRun(
+  server: string,
+  name: string,
+  args: string[],
+  timeout = 120_000
+): Promise<RunOperationResponse> {
+  const res = await fetch(`${server}/api/connectors/${encodeURIComponent(name)}/operations/run`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ args, format: "json", timeout }),
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({ error: `HTTP ${res.status}` }));
+    throw new Error((err as { error: string }).error || `Request failed: ${res.status}`);
+  }
+  return res.json() as Promise<RunOperationResponse>;
+}
+
+// ── Logo prompt engineering ──────────────────────────────────────────
+
+type Provider = "openai" | "gemini";
+
+const LOGO_SYSTEM_PROMPT =
+  "You are a world-class logo designer. Create a professional, clean, scalable logo. " +
+  "Use flat vector style with solid colors. White or transparent background. " +
+  "No photorealistic textures, no gradients unless specified. " +
+  "The design must be recognizable at small sizes (16x16 favicon).";
+
+function buildLogoPrompt(userPrompt: string): string {
+  return `${LOGO_SYSTEM_PROMPT}\n\nLogo brief: ${userPrompt}\n\nStyle: flat vector logo, clean lines, professional, white background, high resolution, suitable for branding`;
+}
+
+function getOutputPath(output: string | undefined, index: number, total: number): string {
+  if (output) {
+    if (total === 1) return resolve(output);
+    const ext = extname(output) || ".png";
+    const base = output.replace(ext, "");
+    return resolve(`${base}_${index + 1}${ext}`);
+  }
+  const ts = Date.now();
+  return resolve(`./logo_${ts}_${index + 1}.png`);
+}
+
+// ── Generators ───────────────────────────────────────────────────────
+
+async function generateOpenAI(
+  server: string,
+  prompt: string,
+  opts: { size: string; quality: string; variations: number; output?: string; model?: string }
+): Promise<string[]> {
+  const savedPaths: string[] = [];
+
+  for (let i = 0; i < opts.variations; i++) {
+    const label = opts.variations > 1 ? ` (variation ${i + 1}/${opts.variations})` : "";
+    console.log(chalk.cyan(`  Generating with OpenAI gpt-image-1${label}...`));
+
+    const args = [
+      "images", "generate", buildLogoPrompt(prompt),
+      "--model", opts.model || "dall-e-3",
+      "--size", opts.size,
+      "--quality", opts.quality,
+    ];
+
+    const result = await connectorRun(server, "openai", args);
+
+    if (!result.success) {
+      console.error(chalk.red(`  Failed: ${result.output}`));
+      continue;
+    }
+
+    let imageUrl: string | undefined;
+    try {
+      const parsed = JSON.parse(result.output);
+      imageUrl = parsed.url || parsed.data?.[0]?.url;
+    } catch {
+      const urlMatch = result.output.match(/https?:\/\/[^\s"]+/);
+      imageUrl = urlMatch?.[0];
+    }
+
+    if (imageUrl) {
+      const outputPath = getOutputPath(opts.output, i, opts.variations);
+      const dir = dirname(outputPath);
+      if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+      console.log(chalk.gray(`  Downloading...`));
+      const response = await fetch(imageUrl);
+      const buffer = Buffer.from(await response.arrayBuffer());
+      writeFileSync(outputPath, buffer);
+      savedPaths.push(outputPath);
+      console.log(chalk.green(`  Saved: ${outputPath}`));
+    } else {
+      console.error(chalk.yellow(`  No image URL in response.`));
+      console.log(chalk.gray(result.output.slice(0, 300)));
+    }
+  }
+
+  return savedPaths;
+}
+
+async function generateGemini(
+  server: string,
+  prompt: string,
+  opts: { aspectRatio: string; size: string; variations: number; output?: string; model?: string }
+): Promise<string[]> {
+  const savedPaths: string[] = [];
+
+  for (let i = 0; i < opts.variations; i++) {
+    const label = opts.variations > 1 ? ` (variation ${i + 1}/${opts.variations})` : "";
+    console.log(chalk.cyan(`  Generating with Gemini Nano Banana${label}...`));
+
+    const outputPath = getOutputPath(opts.output, i, opts.variations);
+    const dir = dirname(outputPath);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+    const args = [
+      "image", "generate", buildLogoPrompt(prompt),
+      "--model", opts.model || "gemini-2.5-flash-preview-image-generation",
+      "--aspect-ratio", opts.aspectRatio,
+      "--size", opts.size,
+      "--output", outputPath,
+    ];
+
+    const result = await connectorRun(server, "googlegemini", args);
+
+    if (!result.success) {
+      console.error(chalk.red(`  Failed: ${result.output}`));
+      continue;
+    }
+
+    // Gemini connector saves with timestamp suffix — detect actual file
+    if (existsSync(outputPath)) {
+      savedPaths.push(outputPath);
+      console.log(chalk.green(`  Saved: ${outputPath}`));
+    } else {
+      // Check if connector saved with its own naming (prefix_timestamp_index.ext)
+      const dir = dirname(outputPath);
+      const base = outputPath.replace(extname(outputPath), "").split("/").pop() || "generated";
+      try {
+        const { readdirSync } = await import("fs");
+        const files = readdirSync(dir).filter((f) => f.startsWith(base));
+        if (files.length > 0) {
+          const saved = resolve(dir, files[files.length - 1]);
+          savedPaths.push(saved);
+          console.log(chalk.green(`  Saved: ${saved}`));
+        } else {
+          // Try to extract base64 from response
+          const parsed = JSON.parse(result.output);
+          const data = parsed.data || parsed.images?.[0]?.data;
+          if (data) {
+            writeFileSync(outputPath, Buffer.from(data, "base64"));
+            savedPaths.push(outputPath);
+            console.log(chalk.green(`  Saved: ${outputPath}`));
+          } else {
+            console.log(chalk.yellow(`  Generated but could not save locally.`));
+          }
+        }
+      } catch {
+        console.log(chalk.yellow(`  Generated. Output:`));
+        console.log(chalk.gray(result.output.slice(0, 300)));
+      }
+    }
+  }
+
+  return savedPaths;
+}
+
+// ── CLI ──────────────────────────────────────────────────────────────
+
+const program = new Command();
+
+program
+  .name("skill-logo-design")
+  .description("Generate professional logos using AI (OpenAI GPT Image, Google Gemini)")
+  .version("1.0.0");
+
+program
+  .command("generate")
+  .alias("gen")
+  .argument("<prompt>", "Logo description / design brief")
+  .description("Generate a logo from a text prompt")
+  .option("-p, --provider <provider>", "AI provider: openai or gemini", "openai")
+  .option("-o, --output <path>", "Output file path")
+  .option("-n, --variations <count>", "Number of variations to generate", "1")
+  .option("-s, --size <size>", "Image size (openai: 1024x1024, gemini: 2K)", "1024x1024")
+  .option("-a, --aspect-ratio <ratio>", "Aspect ratio for Gemini (1:1, 16:9, 9:16)", "1:1")
+  .option("-q, --quality <quality>", "Quality: standard or hd (OpenAI only)", "hd")
+  .option("-m, --model <model>", "Model override (openai: dall-e-3/gpt-image-1, gemini: gemini-2.5-flash-preview-image-generation)")
+  .option("--server <url>", "Connectors server URL", DEFAULT_SERVER)
+  .action(async (prompt: string, opts) => {
+    const provider = opts.provider as Provider;
+    const variations = parseInt(opts.variations);
+
+    console.log(chalk.bold("\n  Logo Design Generator\n"));
+    console.log(chalk.gray(`  Provider:   ${provider === "openai" ? "OpenAI GPT Image" : "Google Gemini (Nano Banana)"}`));
+    console.log(chalk.gray(`  Prompt:     "${prompt}"`));
+    console.log(chalk.gray(`  Variations: ${variations}\n`));
+
+    let paths: string[];
+    try {
+      if (provider === "gemini") {
+        paths = await generateGemini(opts.server, prompt, {
+          aspectRatio: opts.aspectRatio,
+          size: opts.size === "1024x1024" ? "2K" : opts.size,
+          variations,
+          output: opts.output,
+          model: opts.model,
+        });
+      } else {
+        paths = await generateOpenAI(opts.server, prompt, {
+          size: opts.size,
+          quality: opts.quality,
+          variations,
+          output: opts.output,
+          model: opts.model,
+        });
+      }
+    } catch (err) {
+      console.error(chalk.red(`\n  Error: ${(err as Error).message}`));
+      console.error(chalk.gray("  Make sure the connectors server is running: connectors serve\n"));
+      process.exit(1);
+    }
+
+    console.log();
+    if (paths.length > 0) {
+      console.log(chalk.bold.green(`  Generated ${paths.length} logo(s):`));
+      paths.forEach((p) => console.log(chalk.white(`    ${p}`)));
+    } else {
+      console.log(chalk.red("  No logos were generated. Check connector status:"));
+      console.log(chalk.gray("    skill-logo-design providers"));
+    }
+    console.log();
+  });
+
+program
+  .command("providers")
+  .description("Check available providers and their connection status")
+  .option("--server <url>", "Connectors server URL", DEFAULT_SERVER)
+  .action(async (opts) => {
+    console.log(chalk.bold("\n  Logo Design Providers\n"));
+
+    const providers = [
+      { name: "openai", display: "OpenAI GPT Image", model: "gpt-image-1" },
+      { name: "googlegemini", display: "Google Gemini (Nano Banana)", model: "gemini-2.5-flash-preview-image-generation" },
+    ];
+
+    for (const p of providers) {
+      try {
+        const connector = await connectorGet(opts.server, p.name);
+        const status = connector.auth?.connected
+          ? chalk.green("connected")
+          : chalk.red("not connected");
+        console.log(`  ${chalk.cyan(p.display)}`);
+        console.log(`    Connector: ${p.name} (${status})`);
+        console.log(`    Model:     ${p.model}`);
+        console.log();
+      } catch {
+        console.log(`  ${chalk.cyan(p.display)}`);
+        console.log(`    ${chalk.red("unavailable")} - connectors server not running?`);
+        console.log(`    Start with: ${chalk.gray("connectors serve")}`);
+        console.log();
+      }
+    }
+  });
+
+program
+  .command("tips")
+  .description("Show logo design tips for better AI-generated logos")
+  .action(() => {
+    console.log(chalk.bold("\n  Logo Design Tips\n"));
+    const tips = [
+      ["Be specific", '"minimalist geometric owl, flat vector, navy and gold, white bg" not "owl logo"'],
+      ["Specify style", "flat vector, 3D, vintage, modern, hand-drawn, geometric, abstract, lettermark"],
+      ["White background", "Always request white or solid background to keep the mark clean"],
+      ["Keep it simple", "Logos must work at favicon size (16x16). Minimalism wins."],
+      ["Skip text", "AI struggles with typography. Generate the icon, add text in Figma/Illustrator"],
+      ["Many variations", "Generate 4-10 variations with slight prompt tweaks, pick the best 2-3"],
+      ["Negative guidance", '"no photorealistic textures, no shadows, no gradients" for cleaner output'],
+      ["Color constraints", 'Specify max 2-3 colors: "navy blue and gold only"'],
+      ["Industry context", '"tech startup logo", "organic food brand", "luxury fashion"'],
+      ["Vector conversion", "All AI logos are raster. Trace to SVG with Vectorizer.ai or Illustrator"],
+    ];
+
+    tips.forEach(([title, desc], i) => {
+      console.log(chalk.cyan(`  ${i + 1}. ${title}`));
+      console.log(chalk.gray(`     ${desc}`));
+    });
+    console.log();
+  });
+
+program.parse();

package/skills/skill-logo-design/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"]
+}

package/skills/skill-longform-structurer/package.json

@@ -23,11 +23,5 @@
   "files": [
     "src",
     "tsconfig.json"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/hasnaxyz/skill-longform-structurer.git"
-  },
-  "author": "Hasna",
-  "license": "Apache-2.0"
+  ]
 }

package/skills/skill-lorem-generator/package.json

@@ -23,11 +23,5 @@
   "files": [
     "src",
     "tsconfig.json"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/hasnaxyz/skill-lorem-generator.git"
-  },
-  "author": "Hasna",
-  "license": "Apache-2.0"
+  ]
 }

package/skills/skill-managehook/package.json

@@ -20,7 +20,5 @@
   "devDependencies": {
     "@types/bun": "^1.1.14",
     "typescript": "^5.7.2"
-  },
-  "author": "Hasna",
-  "license": "Apache-2.0"
+  }
 }

package/skills/skill-managemcp/package.json

@@ -20,7 +20,5 @@
   "devDependencies": {
     "@types/bun": "^1.1.14",
     "typescript": "^5.7.2"
-  },
-  "author": "Hasna",
-  "license": "Apache-2.0"
+  }
 }

package/skills/skill-manageskill/package.json

@@ -20,7 +20,5 @@
   "devDependencies": {
     "@types/bun": "^1.1.14",
     "typescript": "^5.7.2"
-  },
-  "author": "Hasna",
-  "license": "Apache-2.0"
+  }
 }

package/skills/skill-markdown-validator/package.json

@@ -23,11 +23,5 @@
   "files": [
     "src",
     "tsconfig.json"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/hasnaxyz/skill-markdown-validator.git"
-  },
-  "author": "Hasna",
-  "license": "Apache-2.0"
+  ]
 }

package/skills/skill-mcp-builder/package.json

@@ -23,11 +23,5 @@
   "files": [
     "src",
     "tsconfig.json"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/hasnaxyz/skill-mcp-builder.git"
-  },
-  "author": "Hasna",
-  "license": "Apache-2.0"
+  ]
 }

package/skills/skill-meal-plan-designer/package.json

@@ -23,11 +23,5 @@
   "files": [
     "src",
     "tsconfig.json"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/hasnaxyz/skill-meal-plan-designer.git"
-  },
-  "author": "Hasna",
-  "license": "Apache-2.0"
+  ]
 }

package/skills/skill-meeting-insight-summarizer/package.json

@@ -23,11 +23,5 @@
   "files": [
     "src",
     "tsconfig.json"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/hasnaxyz/skill-meeting-insight-summarizer.git"
-  },
-  "author": "Hasna",
-  "license": "Apache-2.0"
+  ]
 }

package/skills/skill-merge-pdfs/package.json

@@ -23,11 +23,5 @@
   "files": [
     "src",
     "tsconfig.json"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/hasnaxyz/skill-merge-pdfs.git"
-  },
-  "author": "Hasna",
-  "license": "Apache-2.0"
+  ]
 }

package/skills/skill-microcopy-generator/package.json

@@ -23,11 +23,5 @@
   "files": [
     "src",
     "tsconfig.json"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/hasnaxyz/skill-microcopy-generator.git"
-  },
-  "author": "Hasna",
-  "license": "Apache-2.0"
+  ]
 }