@hasna/skills 0.0.2

package/skills/skill-create-blog-article/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-create-ebook/CLAUDE.md

@@ -0,0 +1,19 @@
+# skill-create-ebook
+
+Create Ebook skill.
+
+## Tech Stack
+
+- Runtime: Bun
+- Language: TypeScript
+- CLI: Commander.js
+
+## CLI
+
+```bash
+skill-create-ebook run
+```
+
+## Data Directory
+
+~/.skill/skill-create-ebook/

package/skills/skill-create-ebook/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@hasnaxyz/skill-create-ebook",
+  "version": "0.1.0",
+  "description": "Create Ebook skill",
+  "type": "module",
+  "bin": {
+    "skill-create-ebook": "./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-create-ebook.git"
+  },
+  "author": "Hasna",
+  "license": "MIT"
+}

package/skills/skill-create-ebook/src/index.ts

@@ -0,0 +1,637 @@
+#!/usr/bin/env bun
+
+/**
+ * Create eBook Skill
+ *
+ * Generates complete ebooks with AI-powered content, chapter images, and export options.
+ * Supports OpenAI GPT-4/DALL-E and Anthropic Claude.
+ */
+
+import { parseArgs } from "util";
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+import { existsSync } from "fs";
+import { randomUUID } from "crypto";
+
+// ============================================================================
+// Types & Interfaces
+// ============================================================================
+
+interface SkillOptions {
+  topic: string;
+  chapters: number;
+  style: "educational" | "narrative" | "technical" | "casual";
+  audience: "beginner" | "intermediate" | "expert";
+  language: string;
+  aiProvider: "openai" | "anthropic";
+  format: "markdown" | "pdf";
+  includeImages: boolean;
+  output: string;
+  saveIntermediate: boolean;
+}
+
+interface TableOfContents {
+  title: string;
+  chapters: {
+    number: number;
+    title: string;
+    description: string;
+  }[];
+}
+
+interface ChapterContent {
+  number: number;
+  title: string;
+  content: string;
+}
+
+// ============================================================================
+// Environment & Configuration
+// ============================================================================
+
+const OPENAI_API_KEY = process.env.OPENAI_API_KEY || "";
+const ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY || "";
+const SKILLS_OUTPUT_DIR = process.env.SKILLS_OUTPUT_DIR || ".skills";
+const SKILLS_PROJECT_ROOT = process.env.SKILLS_PROJECT_ROOT || process.cwd();
+const SKILL_NAME = "create-ebook";
+const SESSION_ID = randomUUID().slice(0, 8);
+
+// ============================================================================
+// Logging Utility
+// ============================================================================
+
+class Logger {
+  private logFile: string;
+  private sessionId: string;
+
+  constructor() {
+    this.sessionId = SESSION_ID;
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "_").slice(0, 19);
+    this.logFile = join(
+      SKILLS_PROJECT_ROOT,
+      SKILLS_OUTPUT_DIR,
+      "logs",
+      SKILL_NAME,
+      `log_${timestamp}_${this.sessionId}.log`
+    );
+    this.initLogFile();
+  }
+
+  private async initLogFile() {
+    const logDir = join(
+      SKILLS_PROJECT_ROOT,
+      SKILLS_OUTPUT_DIR,
+      "logs",
+      SKILL_NAME
+    );
+    await mkdir(logDir, { recursive: true });
+  }
+
+  private timestamp(): string {
+    return new Date().toISOString();
+  }
+
+  async log(message: string, level: "info" | "error" | "success" = "info") {
+    const logMessage = `[${this.timestamp()}] [${level.toUpperCase()}] ${message}\n`;
+    
+    const prefix = level === "error" ? "❌" : level === "success" ? "✅" : "ℹ️";
+    if (level === "error") {
+      console.error(`${prefix} ${message}`);
+    } else {
+      console.log(`${prefix} ${message}`);
+    }
+
+    try {
+      await writeFile(this.logFile, logMessage, { flag: "a" });
+    } catch (error) {
+      // Silent fail for logging
+    }
+  }
+
+  async error(message: string) {
+    await this.log(message, "error");
+  }
+
+  async success(message: string) {
+    await this.log(message, "success");
+  }
+}
+
+// ============================================================================
+// AI Provider Clients
+// ============================================================================
+
+class OpenAIClient {
+  private apiKey: string;
+
+  constructor(apiKey: string) {
+    this.apiKey = apiKey;
+  }
+
+  async generateText(prompt: string, systemPrompt?: string): Promise<string> {
+    const response = await fetch("https://api.openai.com/v1/chat/completions", {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "gpt-4-turbo-preview",
+        messages: [
+          ...(systemPrompt ? [{ role: "system", content: systemPrompt }] : []),
+          { role: "user", content: prompt },
+        ],
+        temperature: 0.7,
+        max_tokens: 2500,
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`OpenAI API error: ${error}`);
+    }
+
+    const data = await response.json();
+    return data.choices[0].message.content;
+  }
+
+  async generateImage(prompt: string): Promise<string> {
+    const response = await fetch("https://api.openai.com/v1/images/generations", {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "dall-e-3",
+        prompt: prompt,
+        n: 1,
+        size: "1024x1024",
+        quality: "standard",
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`DALL-E API error: ${error}`);
+    }
+
+    const data = await response.json();
+    return data.data[0].url;
+  }
+}
+
+class AnthropicClient {
+  private apiKey: string;
+
+  constructor(apiKey: string) {
+    this.apiKey = apiKey;
+  }
+
+  async generateText(prompt: string, systemPrompt?: string): Promise<string> {
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "x-api-key": this.apiKey,
+        "anthropic-version": "2023-06-01",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "claude-3-5-sonnet-20241022",
+        max_tokens: 2500,
+        system: systemPrompt || undefined,
+        messages: [
+          { role: "user", content: prompt },
+        ],
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Anthropic API error: ${error}`);
+    }
+
+    const data = await response.json();
+    return data.content[0].text;
+  }
+}
+
+// ============================================================================
+// eBook Generator
+// ============================================================================
+
+class EbookGenerator {
+  private logger: Logger;
+  private options: SkillOptions;
+  private outputDir: string;
+  private openaiClient?: OpenAIClient;
+  private anthropicClient?: AnthropicClient;
+
+  constructor(options: SkillOptions, logger: Logger) {
+    this.logger = logger;
+    this.options = options;
+    this.outputDir = join(SKILLS_PROJECT_ROOT, options.output);
+
+    // Initialize AI clients
+    if (options.aiProvider === "openai" && OPENAI_API_KEY) {
+      this.openaiClient = new OpenAIClient(OPENAI_API_KEY);
+    } else if (options.aiProvider === "anthropic" && ANTHROPIC_API_KEY) {
+      this.anthropicClient = new AnthropicClient(ANTHROPIC_API_KEY);
+    }
+  }
+
+  async generate(): Promise<void> {
+    await this.logger.log(`Starting ebook generation: "${this.options.topic}"`);
+
+    // Step 1: Generate TOC
+    const toc = await this.generateTableOfContents();
+    await this.logger.success(`Generated table of contents (${toc.chapters.length} chapters)`);
+
+    if (this.options.saveIntermediate) {
+      await this.saveTOC(toc);
+    }
+
+    // Step 2: Generate chapters
+    const chapters: ChapterContent[] = [];
+    for (const chapter of toc.chapters) {
+      const content = await this.generateChapter(chapter);
+      chapters.push(content);
+      await this.logger.success(`Generated chapter ${chapter.number}/${toc.chapters.length}: ${chapter.title}`);
+
+      if (this.options.saveIntermediate) {
+        await this.saveChapter(content);
+      }
+    }
+
+    // Step 3: Generate images (if enabled)
+    const imageUrls: Map<number, string> = new Map();
+    if (this.options.includeImages) {
+      await this.logger.log("Generating chapter images...");
+      for (const chapter of toc.chapters) {
+        try {
+          const imageUrl = await this.generateChapterImage(chapter);
+          imageUrls.set(chapter.number, imageUrl);
+          await this.logger.success(`Generated image for chapter ${chapter.number}`);
+        } catch (error) {
+          await this.logger.error(`Failed to generate image for chapter ${chapter.number}: ${error}`);
+        }
+      }
+    }
+
+    // Step 4: Compile ebook
+    await this.logger.log("Compiling final ebook...");
+    const ebookContent = await this.compileEbook(toc, chapters, imageUrls);
+    const markdownPath = await this.saveMarkdown(ebookContent);
+    await this.logger.success(`Compiled ebook: ${markdownPath}`);
+
+    // Step 5: Convert to PDF (if requested)
+    if (this.options.format === "pdf") {
+      await this.logger.log("Converting to PDF...");
+      try {
+        await this.convertToPDF(markdownPath);
+        await this.logger.success("Converted to PDF format");
+      } catch (error) {
+        await this.logger.error(`PDF conversion failed: ${error}`);
+      }
+    }
+
+    await this.logger.success("eBook generation complete!");
+  }
+
+  private async generateTableOfContents(): Promise<TableOfContents> {
+    const systemPrompt = this.buildSystemPrompt();
+    const prompt = `Generate a table of contents for an ebook about: "${this.options.topic}"
+
+Requirements:
+- Create exactly ${this.options.chapters} chapters
+- Each chapter should have a clear title and brief description
+- Chapters should flow logically and cover the topic comprehensively
+- Target audience: ${this.options.audience}
+- Writing style: ${this.options.style}
+- Language: ${this.options.language}
+
+Return ONLY a valid JSON object in this exact format (no markdown, no code blocks):
+{
+  "title": "Book Title",
+  "chapters": [
+    {
+      "number": 1,
+      "title": "Chapter Title",
+      "description": "Brief chapter description"
+    }
+  ]
+}`;
+
+    const response = await this.generateText(prompt, systemPrompt);
+
+    // Clean response - remove markdown code blocks if present
+    let cleanedResponse = response.trim();
+    if (cleanedResponse.startsWith("```")) {
+      cleanedResponse = cleanedResponse.replace(/```json\n?/, "").replace(/```\n?$/, "").trim();
+    }
+
+    return JSON.parse(cleanedResponse);
+  }
+
+  private async generateChapter(chapter: { number: number; title: string; description: string }): Promise<ChapterContent> {
+    const systemPrompt = this.buildSystemPrompt();
+    const prompt = `Write Chapter ${chapter.number}: "${chapter.title}"
+
+Description: ${chapter.description}
+Topic: ${this.options.topic}
+
+Requirements:
+- Maximum 2000 characters
+- Target audience: ${this.options.audience}
+- Writing style: ${this.options.style}
+- Language: ${this.options.language}
+- Include practical examples where relevant
+- Make it engaging and informative
+
+Write the full chapter content now:`;
+
+    const content = await this.generateText(prompt, systemPrompt);
+
+    return {
+      number: chapter.number,
+      title: chapter.title,
+      content: content.trim(),
+    };
+  }
+
+  private async generateChapterImage(chapter: { number: number; title: string; description: string }): Promise<string> {
+    if (!this.openaiClient) {
+      throw new Error("Image generation requires OpenAI API key");
+    }
+
+    const imagePrompt = `Create a professional, high-quality illustration for a book chapter titled "${chapter.title}".
+Description: ${chapter.description}
+Style: Clean, modern, and suitable for an educational/professional ebook.
+Topic context: ${this.options.topic}`;
+
+    const imageUrl = await this.openaiClient.generateImage(imagePrompt);
+
+    // Download and save image
+    const imageResponse = await fetch(imageUrl);
+    const imageBuffer = await imageResponse.arrayBuffer();
+
+    const imagesDir = join(this.outputDir, "images");
+    await mkdir(imagesDir, { recursive: true });
+
+    const imagePath = join(imagesDir, `chapter-${String(chapter.number).padStart(2, "0")}.png`);
+    await writeFile(imagePath, Buffer.from(imageBuffer));
+
+    return imagePath;
+  }
+
+  private async compileEbook(
+    toc: TableOfContents,
+    chapters: ChapterContent[],
+    imageUrls: Map<number, string>
+  ): Promise<string> {
+    let markdown = `# ${toc.title}\n\n`;
+    markdown += `*Generated with skills.md create-ebook*\n\n`;
+    markdown += `---\n\n`;
+
+    // Table of contents
+    markdown += `## Table of Contents\n\n`;
+    for (const chapter of toc.chapters) {
+      markdown += `${chapter.number}. [${chapter.title}](#chapter-${chapter.number})\n`;
+    }
+    markdown += `\n---\n\n`;
+
+    // Chapters
+    for (const chapter of chapters) {
+      markdown += `## Chapter ${chapter.number}: ${chapter.title} {#chapter-${chapter.number}}\n\n`;
+
+      // Add image if available
+      if (imageUrls.has(chapter.number)) {
+        const imagePath = imageUrls.get(chapter.number)!;
+        const relativeImagePath = `./images/chapter-${String(chapter.number).padStart(2, "0")}.png`;
+        markdown += `![Chapter ${chapter.number} Illustration](${relativeImagePath})\n\n`;
+      }
+
+      markdown += `${chapter.content}\n\n`;
+      markdown += `---\n\n`;
+    }
+
+    return markdown;
+  }
+
+  private async saveTOC(toc: TableOfContents): Promise<void> {
+    await mkdir(this.outputDir, { recursive: true });
+    const tocPath = join(this.outputDir, "toc.json");
+    await writeFile(tocPath, JSON.stringify(toc, null, 2));
+  }
+
+  private async saveChapter(chapter: ChapterContent): Promise<void> {
+    const chaptersDir = join(this.outputDir, "chapters");
+    await mkdir(chaptersDir, { recursive: true });
+
+    const chapterPath = join(chaptersDir, `chapter-${String(chapter.number).padStart(2, "0")}.md`);
+    const content = `# Chapter ${chapter.number}: ${chapter.title}\n\n${chapter.content}`;
+    await writeFile(chapterPath, content);
+  }
+
+  private async saveMarkdown(content: string): Promise<string> {
+    await mkdir(this.outputDir, { recursive: true });
+    const markdownPath = join(this.outputDir, "ebook.md");
+    await writeFile(markdownPath, content);
+    return markdownPath;
+  }
+
+  private async convertToPDF(markdownPath: string): Promise<void> {
+    const pdfPath = join(this.outputDir, "ebook.pdf");
+
+    // Check if pandoc is available
+    const pandocCheck = Bun.spawn(["which", "pandoc"]);
+    await pandocCheck.exited;
+
+    if (pandocCheck.exitCode !== 0) {
+      throw new Error("pandoc not found. Install with: brew install pandoc (macOS) or apt-get install pandoc (Linux)");
+    }
+
+    // Convert using pandoc
+    const pandoc = Bun.spawn([
+      "pandoc",
+      markdownPath,
+      "-o",
+      pdfPath,
+      "--pdf-engine=xelatex",
+      "-V",
+      "geometry:margin=1in",
+    ]);
+
+    await pandoc.exited;
+
+    if (pandoc.exitCode !== 0) {
+      throw new Error(`PDF conversion failed with exit code ${pandoc.exitCode}`);
+    }
+  }
+
+  private async generateText(prompt: string, systemPrompt?: string): Promise<string> {
+    if (this.openaiClient) {
+      return this.openaiClient.generateText(prompt, systemPrompt);
+    } else if (this.anthropicClient) {
+      return this.anthropicClient.generateText(prompt, systemPrompt);
+    } else {
+      throw new Error("No AI provider configured. Set OPENAI_API_KEY or ANTHROPIC_API_KEY");
+    }
+  }
+
+  private buildSystemPrompt(): string {
+    const audienceContext = {
+      beginner: "Write for beginners with simple language, clear explanations, and assume no prior knowledge.",
+      intermediate: "Write for intermediate readers with moderate technical knowledge and some experience.",
+      expert: "Write for experts with advanced technical knowledge and deep understanding of the subject.",
+    };
+
+    const styleContext = {
+      educational: "Use a clear, instructional tone. Focus on teaching concepts step-by-step.",
+      narrative: "Use storytelling and engaging prose. Make it compelling and enjoyable to read.",
+      technical: "Use precise, technical language. Be concise and focus on accuracy.",
+      casual: "Use a conversational, friendly tone. Make it approachable and easy to understand.",
+    };
+
+    return `You are an expert ebook writer. ${audienceContext[this.options.audience]} ${styleContext[this.options.style]} Write in ${this.options.language} language.`;
+  }
+}
+
+// ============================================================================
+// Argument Parsing
+// ============================================================================
+
+function parseArguments(): SkillOptions {
+  const { values, positionals } = parseArgs({
+    args: process.argv.slice(2),
+    options: {
+      chapters: { type: "string", default: "7" },
+      style: { type: "string", default: "educational" },
+      audience: { type: "string", default: "intermediate" },
+      language: { type: "string", default: "en" },
+      "ai-provider": { type: "string", default: "openai" },
+      format: { type: "string", default: "markdown" },
+      "include-images": { type: "string", default: "true" },
+      output: { type: "string", default: join(SKILLS_OUTPUT_DIR, "exports", "create-ebook") },
+      "save-intermediate": { type: "string", default: "true" },
+      help: { type: "boolean", short: "h" },
+    },
+    allowPositionals: true,
+  });
+
+  if (values.help) {
+    console.log(`
+Create eBook - Generates complete ebooks with AI-powered content
+
+Usage:
+  skills run create-ebook -- [options] <topic>
+
+Options:
+  --chapters <n>       Number of chapters (5-10, default: 7)
+  --style <style>      Writing style: educational, narrative, technical, casual
+  --audience <level>   Target audience: beginner, intermediate, expert
+  --language <code>    Language code (default: en)
+  --ai-provider <name> AI provider: openai, anthropic (default: openai)
+  --format <fmt>       Output format: markdown, pdf (default: markdown)
+  --include-images     Generate chapter images (default: true)
+  --output <path>      Output directory
+  --save-intermediate  Save intermediate files (default: true)
+  --help, -h           Show this help
+`);
+    process.exit(0);
+  }
+
+  const topic = positionals[0];
+  if (!topic) {
+    throw new Error("Topic is required. Usage: skills run create-ebook -- \"Your Topic\"");
+  }
+
+  const chapters = parseInt(values.chapters as string, 10);
+  if (isNaN(chapters) || chapters < 5 || chapters > 10) {
+    throw new Error("Chapters must be between 5 and 10");
+  }
+
+  const style = values.style as string;
+  if (!["educational", "narrative", "technical", "casual"].includes(style)) {
+    throw new Error("Style must be: educational, narrative, technical, or casual");
+  }
+
+  const audience = values.audience as string;
+  if (!["beginner", "intermediate", "expert"].includes(audience)) {
+    throw new Error("Audience must be: beginner, intermediate, or expert");
+  }
+
+  const aiProvider = values["ai-provider"] as string;
+  if (!["openai", "anthropic"].includes(aiProvider)) {
+    throw new Error("AI provider must be: openai or anthropic");
+  }
+
+  const format = values.format as string;
+  if (!["markdown", "pdf"].includes(format)) {
+    throw new Error("Format must be: markdown or pdf");
+  }
+
+  return {
+    topic,
+    chapters,
+    style: style as any,
+    audience: audience as any,
+    language: values.language as string,
+    aiProvider: aiProvider as any,
+    format: format as any,
+    includeImages: values["include-images"] === "true",
+    output: values.output as string,
+    saveIntermediate: values["save-intermediate"] === "true",
+  };
+}
+
+// ============================================================================
+// Validation
+// ============================================================================
+
+function validateEnvironment(options: SkillOptions): void {
+  if (options.aiProvider === "openai" && !OPENAI_API_KEY) {
+    throw new Error("OPENAI_API_KEY environment variable is required for OpenAI provider");
+  }
+
+  if (options.aiProvider === "anthropic" && !ANTHROPIC_API_KEY) {
+    throw new Error("ANTHROPIC_API_KEY environment variable is required for Anthropic provider");
+  }
+
+  if (options.includeImages && !OPENAI_API_KEY) {
+    throw new Error("OPENAI_API_KEY is required for image generation (DALL-E)");
+  }
+
+  if (options.format === "pdf") {
+    // Check will be done at conversion time
+  }
+}
+
+// ============================================================================
+// Main Execution
+// ============================================================================
+
+async function main() {
+  const logger = new Logger();
+
+  try {
+    logger.log(`Starting ${SKILL_NAME} session: ${SESSION_ID}`);
+    
+    // Parse arguments
+    const options = parseArguments();
+
+    // Validate environment
+    validateEnvironment(options);
+
+    // Generate ebook
+    const generator = new EbookGenerator(options, logger);
+    await generator.generate();
+
+    process.exit(0);
+  } catch (error) {
+    await logger.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+main();