@hasna/skills 0.0.2

package/skills/skill-generate-slides/CLAUDE.md

@@ -0,0 +1,19 @@
+# skill-generate-slides
+
+Generate Slides skill.
+
+## Tech Stack
+
+- Runtime: Bun
+- Language: TypeScript
+- CLI: Commander.js
+
+## CLI
+
+```bash
+skill-generate-slides run
+```
+
+## Data Directory
+
+~/.skill/skill-generate-slides/

package/skills/skill-generate-slides/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@hasnaxyz/skill-generate-slides",
+  "version": "0.1.0",
+  "description": "Generate Slides skill",
+  "type": "module",
+  "bin": {
+    "skill-generate-slides": "./bin/cli.ts"
+  },
+  "scripts": {
+    "dev": "bun run bin/cli.ts",
+    "build": "bun build bin/cli.ts --outdir dist --target node",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "commander": "^13.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.7.0"
+  },
+  "publishConfig": {
+    "access": "restricted",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": ["bin", "src", "tsconfig.json"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hasnaxyz/skill-generate-slides.git"
+  },
+  "author": "Hasna",
+  "license": "MIT"
+}

package/skills/skill-generate-slides/src/ai.ts

@@ -0,0 +1,140 @@
+/**
+ * AI-powered slide generation
+ */
+
+import OpenAI from "openai";
+import { Presentation, SlideOptions } from "./parse.js";
+
+export async function generateSlidesWithAI(options: SlideOptions): Promise<Presentation> {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    throw new Error("OPENAI_API_KEY environment variable is required for AI generation");
+  }
+
+  const openai = new OpenAI({ apiKey });
+
+  console.log("🤖 Generating slides with AI...");
+  console.log(`   Topic: ${options.topic}`);
+  console.log(`   Slides: ${options.slideCount}`);
+  console.log(`   Audience: ${options.audience}`);
+  console.log(`   Style: ${options.style}`);
+
+  const systemPrompt = `You are an expert presentation designer. Create engaging, well-structured slide content.
+Return ONLY valid JSON with no additional text or markdown formatting.`;
+
+  const userPrompt = `Create EXACTLY ${options.slideCount} slides for a presentation about: "${options.topic}"
+
+IMPORTANT: You MUST create exactly ${options.slideCount} slides - no more, no less.
+
+Target audience: ${options.audience}
+Style: ${options.style}
+Language: ${options.language}
+Include speaker notes: ${options.notes}
+
+Return a JSON object with this exact structure:
+{
+  "title": "Main presentation title",
+  "subtitle": "Optional subtitle",
+  "slides": [
+    {
+      "type": "title",
+      "title": "Slide title",
+      "subtitle": "Optional subtitle for title slide",
+      "content": [],
+      "notes": "Speaker notes for this slide"
+    },
+    {
+      "type": "bullets",
+      "title": "Slide Title",
+      "content": ["Bullet point 1", "Bullet point 2", "Bullet point 3"],
+      "notes": "Speaker notes"
+    },
+    {
+      "type": "two-column",
+      "title": "Comparison Title",
+      "columns": {
+        "left": ["Left point 1", "Left point 2"],
+        "right": ["Right point 1", "Right point 2"]
+      },
+      "notes": "Speaker notes"
+    },
+    {
+      "type": "quote",
+      "title": "Key Insight",
+      "content": ["The quote or key message here"],
+      "notes": "Speaker notes"
+    }
+  ]
+}
+
+Slide types available: title, bullets, content, two-column, quote, image
+- First slide should be type "title"
+- Last slide should be a conclusion/thank you
+- Use variety of slide types
+- Keep bullet points concise (5-8 words each)
+- Include 3-5 bullet points per slide
+- Make content engaging and valuable`;
+
+  try {
+    const response = await openai.chat.completions.create({
+      model: "gpt-4o",
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: userPrompt },
+      ],
+      max_tokens: 4000,
+      temperature: 0.7,
+    });
+
+    const content = response.choices[0]?.message?.content || "";
+
+    // Extract JSON from response
+    let jsonStr = content;
+    const jsonMatch = content.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (jsonMatch) {
+      jsonStr = jsonMatch[1];
+    }
+
+    // Clean up common issues
+    jsonStr = jsonStr.trim();
+    if (!jsonStr.startsWith("{")) {
+      const startIdx = jsonStr.indexOf("{");
+      if (startIdx !== -1) {
+        jsonStr = jsonStr.substring(startIdx);
+      }
+    }
+
+    const data = JSON.parse(jsonStr);
+
+    let slides = data.slides || [];
+    const targetCount = options.slideCount || 5;
+
+    // Enforce slide count - trim if too many
+    if (slides.length > targetCount) {
+      console.log(`   ⚠️  AI generated ${slides.length} slides, trimming to ${targetCount}`);
+      // Keep title slide (first) and conclusion (last), trim from middle
+      if (slides.length > 2) {
+        const titleSlide = slides[0];
+        const conclusionSlide = slides[slides.length - 1];
+        const middleSlides = slides.slice(1, -1).slice(0, targetCount - 2);
+        slides = [titleSlide, ...middleSlides, conclusionSlide];
+      } else {
+        slides = slides.slice(0, targetCount);
+      }
+    }
+
+    console.log(`   ✓ Generated ${slides.length} slides`);
+
+    return {
+      title: data.title || options.topic || "Presentation",
+      subtitle: data.subtitle,
+      author: options.author,
+      date: options.date,
+      slides,
+      metadata: { generatedBy: "AI", topic: options.topic },
+    };
+  } catch (error: any) {
+    console.error("AI generation error:", error.message);
+    throw new Error(`Failed to generate slides: ${error.message}`);
+  }
+}

package/skills/skill-generate-slides/src/cli.ts

@@ -0,0 +1,161 @@
+/**
+ * CLI argument parsing and help text
+ */
+
+import { parseArgs } from "node:util";
+import { join } from "node:path";
+import { SlideOptions } from "./parse.js";
+
+export function parseArguments(): SlideOptions {
+  const { values, positionals } = parseArgs({
+    args: process.argv.slice(2),
+    options: {
+      // Input
+      text: { type: "string" },
+      topic: { type: "string" },
+      outline: { type: "boolean", default: false },
+
+      // AI Generation
+      "ai-generate": { type: "boolean", default: false },
+      "slide-count": { type: "string", default: "8" },
+      audience: { type: "string", default: "general" },
+      style: { type: "string", default: "professional" },
+      language: { type: "string", default: "en" },
+      "include-images": { type: "boolean", default: false },
+
+      // Output
+      format: { type: "string", default: "pptx" },
+      output: { type: "string" },
+      dir: { type: "string", default: "" },
+
+      // Theme
+      theme: { type: "string", default: "minimal" },
+
+      // Content
+      title: { type: "string" },
+      author: { type: "string" },
+      date: { type: "string", default: new Date().toISOString().split("T")[0] },
+      notes: { type: "boolean", default: true },
+      footer: { type: "string" },
+      "slide-numbers": { type: "boolean", default: true },
+
+      // Layout
+      "aspect-ratio": { type: "string", default: "16:9" },
+
+      // Branding
+      logo: { type: "string" },
+      "logo-position": { type: "string", default: "bottom-right" },
+      "primary-color": { type: "string" },
+      "secondary-color": { type: "string" },
+      font: { type: "string" },
+
+      // Animation
+      transition: { type: "string", default: "fade" },
+      "transition-speed": { type: "string", default: "default" },
+
+      // Code
+      "code-theme": { type: "string", default: "github" },
+      "line-numbers": { type: "boolean", default: false },
+
+      help: { type: "boolean", short: "h", default: false },
+    },
+    allowPositionals: true,
+  });
+
+  if (values.help) {
+    printHelp();
+    process.exit(0);
+  }
+
+  const outputDir =
+    values.dir ||
+    (process.env.SKILLS_OUTPUT_DIR
+      ? join(process.env.SKILLS_OUTPUT_DIR, "exports", "generate-slides")
+      : join(process.cwd(), ".skills", "exports", "generate-slides"));
+
+  return {
+    inputFile: positionals[0],
+    text: values.text as string | undefined,
+    topic: values.topic as string | undefined,
+    outline: values.outline as boolean,
+    aiGenerate: values["ai-generate"] as boolean,
+    slideCount: parseInt(values["slide-count"] as string) || 8,
+    audience: values.audience as string,
+    style: values.style as string,
+    language: values.language as string,
+    includeImages: values["include-images"] as boolean,
+    format: values.format as any,
+    output: values.output as string | undefined,
+    dir: outputDir,
+    theme: values.theme as any,
+    title: values.title as string | undefined,
+    author: values.author as string | undefined,
+    date: values.date as string,
+    notes: values.notes as boolean,
+    footer: values.footer as string | undefined,
+    slideNumbers: values["slide-numbers"] as boolean,
+    aspectRatio: values["aspect-ratio"] as any,
+    logo: values.logo as string | undefined,
+    logoPosition: values["logo-position"] as any,
+    primaryColor: values["primary-color"] as string | undefined,
+    secondaryColor: values["secondary-color"] as string | undefined,
+    font: values.font as string | undefined,
+    transition: values.transition as any,
+    transitionSpeed: values["transition-speed"] as any,
+    codeTheme: values["code-theme"] as string,
+    lineNumbers: values["line-numbers"] as boolean,
+  };
+}
+
+export function printHelp(): void {
+  console.log(`
+Generate Slides - Create presentations from markdown or AI
+
+Usage:
+  skills run generate-slides -- [input.md] [options]
+  skills run generate-slides -- --topic "Your Topic" --ai-generate [options]
+
+AI Generation:
+  --topic <text>          Topic for AI to generate slides about
+  --ai-generate           Enable AI slide generation
+  --slide-count <n>       Number of slides to generate (default: 8)
+  --audience <type>       Target audience: general, technical, executive, students
+  --style <type>          Presentation style: professional, casual, academic, sales
+  --language <code>       Language code: en, es, fr, de, etc.
+  --include-images        Generate image suggestions for each slide
+
+Input:
+  [file]                  Markdown file with slide content
+  --text <markdown>       Direct markdown text input
+
+Output:
+  --format <type>         Output format: pptx, pdf, html, revealjs (default: pptx)
+  -o, --output <path>     Output file path
+  --dir <path>            Output directory
+
+Theme & Branding:
+  --theme <name>          Theme: corporate, creative, minimal, dark, light, tech
+  --primary-color <hex>   Primary color (without #)
+  --secondary-color <hex> Secondary color
+  --font <name>           Font family
+  --logo <path>           Logo image file
+  --logo-position <pos>   Logo position: top-left, top-right, bottom-left, bottom-right
+
+Content:
+  --title <text>          Presentation title
+  --author <text>         Author name
+  --notes                 Include speaker notes (default: true)
+  --slide-numbers         Show slide numbers (default: true)
+  --footer <text>         Footer text
+
+Examples:
+  # AI-generated presentation
+  skills run generate-slides -- --topic "Introduction to Machine Learning" --ai-generate --format pptx
+
+  # From markdown file
+  skills run generate-slides -- presentation.md --format pptx --theme corporate
+
+  # Quick HTML presentation
+  skills run generate-slides -- --topic "Q4 Results" --ai-generate --format html --theme dark
+`);
+}

package/skills/skill-generate-slides/src/export.ts

@@ -0,0 +1,65 @@
+/**
+ * Export format handling (PDF generation)
+ */
+
+import { join } from "node:path";
+import { writeFile, unlink } from "node:fs/promises";
+import { Presentation, SlideOptions } from "./parse.js";
+import { renderHTML } from "./render.js";
+
+export async function generatePDF(presentation: Presentation, options: SlideOptions): Promise<Buffer> {
+  console.log("📄 Generating PDF...");
+
+  // Generate HTML first
+  const html = renderHTML(presentation, options);
+
+  // Write temp HTML file
+  const tempDir = options.dir;
+  const tempHtml = join(tempDir, `temp-${Date.now()}.html`);
+  await writeFile(tempHtml, html);
+
+  try {
+    // Use puppeteer to convert to PDF
+    const puppeteer = await import("puppeteer");
+    const browser = await puppeteer.default.launch({
+      headless: true,
+      args: ["--no-sandbox", "--disable-setuid-sandbox"],
+    });
+
+    const page = await browser.newPage();
+    await page.goto(`file://${tempHtml}`, { waitUntil: "networkidle0" });
+
+    // Set viewport based on aspect ratio
+    const viewport =
+      options.aspectRatio === "16:9"
+        ? { width: 1920, height: 1080 }
+        : options.aspectRatio === "4:3"
+          ? { width: 1024, height: 768 }
+          : { width: 1920, height: 1200 };
+
+    await page.setViewport(viewport);
+
+    const pdfBuffer = await page.pdf({
+      format: "A4",
+      landscape: true,
+      printBackground: true,
+      margin: { top: 0, bottom: 0, left: 0, right: 0 },
+    });
+
+    await browser.close();
+
+    // Clean up temp file
+    await unlink(tempHtml);
+
+    return Buffer.from(pdfBuffer);
+  } catch (error: any) {
+    // Clean up temp file on error
+    try {
+      await unlink(tempHtml);
+    } catch {}
+
+    console.warn("   ⚠️  PDF generation failed, falling back to HTML");
+    console.warn(`   Error: ${error.message}`);
+    throw error;
+  }
+}