@hasna/skills 0.1.23 → 0.1.25

package/skills/product-demo-script/src/index.ts

@@ -0,0 +1,326 @@
+#!/usr/bin/env bun
+/**
+ * product-demo-script
+ * Generates structured product demo scripts using OpenAI.
+ */
+
+import { parseArgs } from "util";
+import { existsSync, mkdirSync, appendFileSync, readFileSync } from "fs";
+import { join, dirname, resolve } from "path";
+
+type OutputFormat = "markdown" | "json";
+
+type StoryArc = "problem-solution" | "before-after" | "jobs-to-be-done";
+
+type PresenterTone = "confident" | "friendly" | "energetic";
+
+type DemoTemplate = {
+  key_features?: Array<Record<string, unknown>>;
+  audience_pains?: Array<Record<string, unknown>>;
+  stories?: Array<Record<string, unknown>>;
+  objections?: Array<Record<string, unknown>>;
+  proof_points?: Array<Record<string, unknown>>;
+  notes?: string;
+};
+
+interface SkillOptions {
+  brief: string;
+  audience?: string;
+  duration?: string;
+  storyArc: StoryArc;
+  tone: PresenterTone;
+  format: OutputFormat;
+  model: string;
+  output?: string;
+  template?: DemoTemplate;
+}
+
+interface OpenAIChatResponse {
+  choices?: Array<{
+    message?: {
+      content?: string | null;
+    };
+  }>;
+  error?: {
+    message?: string;
+  };
+}
+
+const SKILL_SLUG = "product-demo-script";
+
+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) || "demo-script";
+}
+
+function parseJsonTemplate(content: string): DemoTemplate | undefined {
+  try {
+    const data = JSON.parse(content);
+    if (typeof data === "object" && data !== null) {
+      return data as DemoTemplate;
+    }
+  } catch (_error) {
+    // treat as plain text if parsing fails
+  }
+  return undefined;
+}
+
+function showHelp(): void {
+  console.log(`
+product-demo-script - Generate structured product demo scripts using AI
+
+Usage:
+  skills run product-demo-script -- <brief-file> [options]
+  skills run product-demo-script -- --text "<product-brief>" [options]
+
+Options:
+  -h, --help               Show this help message
+  --text <brief>           Inline product/demo brief
+  --audience <type>        Target audience (default: executive audience)
+  --duration <time>        Demo duration (default: 30 minutes)
+  --story-arc <arc>        Narrative arc: problem-solution | before-after | jobs-to-be-done
+  --tone <style>           Presenter tone: confident | friendly | energetic (default: confident)
+  --format <type>          Output format: markdown | json (default: markdown)
+  --model <model>          OpenAI model (default: gpt-4o-mini)
+  --output <path>          Custom output file path
+
+Output includes:
+  - Executive summary
+  - Agenda with time boxes
+  - Detailed segments (talk track, features, proof points)
+  - Objection handling
+  - Visual recommendations
+  - CTA close
+
+Examples:
+  skills run product-demo-script -- ./product-info.txt --duration "15 minutes" --tone "energetic"
+  skills run product-demo-script -- --text "SaaS analytics platform" --story-arc "before-after"
+
+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" },
+      text: { type: "string" },
+      audience: { type: "string" },
+      duration: { type: "string" },
+      "story-arc": { type: "string", default: "problem-solution" },
+      tone: { type: "string", default: "confident" },
+      format: { type: "string", default: "markdown" },
+      model: { type: "string", default: "gpt-4o-mini" },
+      output: { type: "string" },
+    },
+    allowPositionals: true,
+  });
+
+  if (values.help) {
+    showHelp();
+    process.exit(0);
+  }
+
+  let brief = values.text || "";
+  let template: DemoTemplate | undefined;
+
+  if (!brief && positionals[0]) {
+    const filePath = resolve(positionals[0]);
+    const content = readFileSync(filePath, "utf-8");
+    template = parseJsonTemplate(content);
+    brief = template ? "" : content;
+  }
+
+  if (!brief.trim() && !template) {
+    throw new Error("Provide demo inputs via file path, JSON template, or --text.");
+  }
+
+  const format: OutputFormat =
+    values.format === "json" ? "json" : values.format === "markdown" ? "markdown" : "markdown";
+
+  let storyArc: StoryArc = "problem-solution";
+  if (values["story-arc"] === "problem-solution" || values["story-arc"] === "before-after" || values["story-arc"] === "jobs-to-be-done") {
+    storyArc = values["story-arc"];
+  }
+
+  let tone: PresenterTone = "confident";
+  if (values.tone === "confident" || values.tone === "friendly" || values.tone === "energetic") {
+    tone = values.tone;
+  }
+
+  return {
+    brief,
+    audience: values.audience,
+    duration: values.duration,
+    storyArc,
+    tone,
+    format,
+    model: values.model,
+    output: values.output,
+    template,
+  };
+}
+
+function buildPrompt(options: SkillOptions) {
+  const system = `You are a senior solutions consultant building a captivating product demo.
+Design a narrative arc, align proof points with pains, script objection handling, and specify visuals.
+Include transitions that reinforce value and end with a strong CTA.`;
+
+  const instructions =
+    options.format === "json"
+      ? "Respond in JSON with keys: summary, agenda, segments, objections, visuals, cta. Each segment should include title, objective, talk_track, feature_callout, proof_point, time_allocation." 
+      : "Respond in polished Markdown. Start with an executive summary, outline agenda with time boxes, detail segments (talk track, feature, proof, customer story), objection handling table, recommended visuals, and CTA close.";
+
+  const payload = {
+    audience: options.audience || "executive audience",
+    duration: options.duration || "30 minutes",
+    story_arc: options.storyArc,
+    tone: options.tone,
+    brief_text: options.brief.substring(0, 6000),
+    structured_template: options.template,
+  };
+
+  const user = `${instructions}\n\n${JSON.stringify(payload, 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.39,
+    max_tokens: options.format === "json" ? 2300 : 2100,
+  };
+
+  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);
+}
+
+function buildExportPath(skillExportsDir: string, sessionStamp: string, options: SkillOptions) {
+  if (options.output) {
+    return resolve(options.output);
+  }
+
+  const descriptorParts = [options.audience || "demo", options.storyArc];
+  const base = slugify(descriptorParts.filter(Boolean).join("-"));
+  const extension = options.format === "json" ? "json" : "md";
+  return join(skillExportsDir, `${base}_${sessionStamp}.${extension}`);
+}
+
+function preview(content: string) {
+  const lines = content.split(/\r?\n/).slice(0, 8);
+  lines.forEach(line => console.log(`   ${line}`));
+  if (content.split(/\r?\n/).length > 8) {
+    console.log("   ...");
+  }
+}
+
+async function main() {
+  const { sessionStamp, skillExportsDir, skillLogsDir } = getPaths();
+  const logger = createLogger(skillLogsDir, sessionStamp);
+
+  try {
+    const options = parseOptions();
+    logger.info("Parsed demo brief and options.");
+
+    const { system, user } = buildPrompt(options);
+    logger.info("Constructed demo script prompt.");
+
+    const content = await callOpenAI(options, system, user);
+    logger.success("Received demo script from OpenAI.");
+
+    const exportPath = buildExportPath(skillExportsDir, sessionStamp, options);
+    await writeExport(exportPath, content);
+    logger.success(`Saved demo script to ${exportPath}`);
+
+    console.log("\nPreview:");
+    preview(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(message);
+    process.exitCode = 1;
+  }
+}
+
+main();

package/skills/product-mockup/CLAUDE.md

@@ -0,0 +1,19 @@
+# product-mockup
+
+Product Mockup skill.
+
+## Tech Stack
+
+- Runtime: Bun
+- Language: TypeScript
+- CLI: Commander.js
+
+## CLI
+
+```bash
+product-mockup run
+```
+
+## Data Directory
+
+~/.skill/product-mockup/

package/skills/product-mockup/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "product-mockup",
+  "version": "0.1.0",
+  "description": "Product Mockup skill",
+  "type": "module",
+  "bin": {
+    "product-mockup": "./src/index.ts"
+  },
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "build": "bun build src/index.ts --outdir dist --target node",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.7.0"
+  },
+  "publishConfig": {
+    "access": "restricted",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "src",
+    "tsconfig.json"
+  ]
+}

package/skills/product-mockup/src/index.ts

@@ -0,0 +1,290 @@
+#!/usr/bin/env bun
+
+import { existsSync, mkdirSync, appendFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { randomUUID } from "crypto";
+
+// Constants
+const SKILL_NAME = "product-mockup";
+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_IMAGE_URL = "https://api.openai.com/v1/images/generations";
+
+// Types
+interface MockupResult {
+  style: string;
+  scene: string;
+  angle: string;
+  lighting: string;
+  filename: string;
+  prompt: string;
+}
+
+interface Options {
+  product: string;
+  style: string;
+  scene: string;
+  background: string;
+  variations: number;
+  angle: string;
+  lighting: string;
+  season: string;
+  size: string;
+  format: string;
+  verbose: boolean;
+}
+
+// Style configurations
+const STYLES: Record<string, string> = {
+  lifestyle: "product in real-world lifestyle setting, natural environment, authentic usage context",
+  minimal: "product on clean white background, studio lighting, e-commerce ready, pure and simple",
+  flatlay: "top-down flat lay photography, organized arrangement, styled composition",
+  inuse: "product being used by person, demonstration shot, action context",
+  seasonal: "seasonal themed setting, holiday or season-specific decoration and props",
+  premium: "luxury aesthetic, high-end styling, premium materials and backdrop",
+};
+
+const SCENES: Record<string, string> = {
+  office: "modern office desk with laptop, coffee cup, plants, natural light from window",
+  kitchen: "clean marble kitchen counter, cooking ingredients, warm home atmosphere",
+  outdoor: "natural outdoor setting, grass, trees, golden hour sunlight",
+  gym: "fitness studio environment, workout equipment, energetic atmosphere",
+  travel: "travel adventure context, suitcase, passport, world map background",
+  cozy: "cozy home environment, soft blankets, warm lighting, comfortable setting",
+  urban: "urban city street style, concrete, graffiti, modern architecture",
+  nature: "natural elements, wood texture, green plants, stone, organic materials",
+};
+
+const ANGLES: Record<string, string> = {
+  front: "front-facing straight-on view",
+  side: "side profile view, 90-degree angle",
+  top: "top-down bird's eye view",
+  "3/4": "three-quarter angle view, dynamic perspective",
+  hero: "hero shot, dramatic angle, showcasing product at its best",
+};
+
+// Utilities
+function ensureDir(dir: string): void {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+
+function log(message: string, level: "info" | "error" | "success" = "info"): void {
+  const timestamp = new Date().toISOString();
+  ensureDir(LOGS_DIR);
+  appendFileSync(join(LOGS_DIR, `log_${SESSION_TIMESTAMP}_${SESSION_ID}.log`), `[${timestamp}] [${level.toUpperCase()}] ${message}\n`);
+  console.log(`[${level.toUpperCase()}] ${message}`);
+}
+
+function parseArguments(): Options {
+  const args = process.argv.slice(2);
+  const options: Options = {
+    product: "",
+    style: "lifestyle",
+    scene: "auto",
+    background: "contextual",
+    variations: 1,
+    angle: "hero",
+    lighting: "natural",
+    season: "none",
+    size: "square",
+    format: "images",
+    verbose: false,
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--style": options.style = args[++i]; break;
+      case "--scene": options.scene = args[++i]; break;
+      case "--background": options.background = args[++i]; break;
+      case "--variations": options.variations = parseInt(args[++i], 10); break;
+      case "--angle": options.angle = args[++i]; break;
+      case "--lighting": options.lighting = args[++i]; break;
+      case "--season": options.season = args[++i]; break;
+      case "--size": options.size = args[++i]; break;
+      case "--format": options.format = args[++i]; break;
+      case "--verbose": options.verbose = true; break;
+      case "--help": case "-h": printHelp(); process.exit(0);
+      default: if (!arg.startsWith("-") && !options.product) options.product = arg;
+    }
+  }
+  return options;
+}
+
+function printHelp(): void {
+  console.log(`
+Product Mockup Generator - AI-powered product photography
+
+Usage:
+  skills run product-mockup -- "<product description>" [options]
+
+Options:
+  --style <style>       Style: lifestyle, minimal, flatlay, inuse, seasonal, premium
+  --scene <scene>       Scene: office, kitchen, outdoor, gym, travel, cozy, urban, nature
+  --background <bg>     Background color or description
+  --variations <n>      Number of image variations (default: 1)
+  --angle <angle>       Angle: front, side, top, 3/4, hero
+  --lighting <type>     Lighting: natural, studio, dramatic, soft
+  --season <season>     Season theme: spring, summer, fall, winter, holiday
+  --size <size>         Size: square, portrait, landscape, story
+  --verbose             Show detailed progress
+
+Examples:
+  skills run product-mockup -- "Stainless steel water bottle, matte black, 32oz"
+  skills run product-mockup -- "Leather laptop bag" --style lifestyle --scene office
+  skills run product-mockup -- "Organic face cream" --style premium --variations 3
+`);
+}
+
+function buildPrompt(options: Options, variation: number): string {
+  const styleDesc = STYLES[options.style] || options.style;
+  const sceneDesc = options.scene !== "auto" ? (SCENES[options.scene] || options.scene) : "";
+  const angleDesc = ANGLES[options.angle] || options.angle;
+
+  let prompt = `Professional product photography of ${options.product}. `;
+  prompt += `${styleDesc}. `;
+  if (sceneDesc) prompt += `Setting: ${sceneDesc}. `;
+  prompt += `Camera angle: ${angleDesc}. `;
+  prompt += `Lighting: ${options.lighting} lighting. `;
+
+  if (options.season !== "none") {
+    prompt += `Seasonal theme: ${options.season}. `;
+  }
+
+  if (options.background !== "contextual") {
+    prompt += `Background: ${options.background}. `;
+  }
+
+  prompt += "High-resolution, commercial quality, sharp focus on product, professional color grading.";
+
+  // Add variation hint
+  if (variation > 0) {
+    const variationHints = ["slightly different angle", "alternative composition", "different prop arrangement", "varied lighting mood"];
+    prompt += ` Variation: ${variationHints[variation % variationHints.length]}.`;
+  }
+
+  return prompt;
+}
+
+async function generateMockup(prompt: string, filename: string, size: string): Promise<string> {
+  const sizeMap: Record<string, string> = {
+    square: "1024x1024",
+    portrait: "1024x1536",
+    landscape: "1536x1024",
+    story: "1024x1536",
+  };
+
+  const response = await fetch(OPENAI_IMAGE_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${OPENAI_API_KEY}` },
+    body: JSON.stringify({
+      model: "gpt-image-1.5",
+      prompt,
+      n: 1,
+      size: sizeMap[size] || "1024x1024",
+      quality: "high",
+      output_format: "png",
+    }),
+  });
+
+  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(results: MockupResult[], options: Options): string {
+  let output = `# Product Mockup: ${options.product}\n\n`;
+  output += `**Generated:** ${new Date().toISOString()}\n`;
+  output += `**Style:** ${options.style}\n`;
+  output += `**Variations:** ${options.variations}\n\n---\n\n`;
+  output += `## Generated Images\n\n`;
+
+  for (const result of results) {
+    output += `### ${result.style.charAt(0).toUpperCase() + result.style.slice(1)} Shot\n`;
+    output += `**File:** ${result.filename}\n`;
+    output += `**Scene:** ${result.scene}\n`;
+    output += `**Angle:** ${result.angle}\n`;
+    output += `**Lighting:** ${result.lighting}\n\n`;
+  }
+
+  output += `---\n\n**Export Directory:** ${EXPORTS_DIR}\n`;
+  output += `**Total Images:** ${results.length}\n`;
+
+  return output;
+}
+
+async function main(): Promise<void> {
+  const startTime = Date.now();
+  log(`Starting ${SKILL_NAME} session: ${SESSION_ID}`);
+
+  if (!OPENAI_API_KEY) {
+    console.error("Error: OPENAI_API_KEY environment variable is required.");
+    process.exit(1);
+  }
+
+  const options = parseArguments();
+  if (!options.product) {
+    console.error("Error: Please provide a product description.");
+    process.exit(1);
+  }
+
+  ensureDir(EXPORTS_DIR);
+
+  try {
+    const results: MockupResult[] = [];
+
+    for (let i = 0; i < options.variations; i++) {
+      const prompt = buildPrompt(options, i);
+      const filename = `mockup-${options.style}-${i + 1}-${SESSION_ID}.png`;
+
+      log(`Generating mockup ${i + 1}/${options.variations}...`);
+      if (options.verbose) log(`Prompt: ${prompt}`);
+
+      await generateMockup(prompt, filename, options.size);
+
+      results.push({
+        style: options.style,
+        scene: options.scene,
+        angle: options.angle,
+        lighting: options.lighting,
+        filename,
+        prompt,
+      });
+
+      log(`Saved: ${filename}`, "success");
+    }
+
+    const output = formatOutput(results, options);
+    const outputFile = join(EXPORTS_DIR, "mockup-summary.md");
+    writeFileSync(outputFile, 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/project-retro-companion/CLAUDE.md

@@ -0,0 +1,19 @@
+# project-retro-companion
+
+Project Retro Companion skill.
+
+## Tech Stack
+
+- Runtime: Bun
+- Language: TypeScript
+- CLI: Commander.js
+
+## CLI
+
+```bash
+project-retro-companion run
+```
+
+## Data Directory
+
+~/.skill/project-retro-companion/