@hasna/skills 0.1.26 → 0.1.29

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

@@ -1,290 +0,0 @@
-#!/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/read-pdf/src/index.ts

@@ -1,388 +0,0 @@
-#!/usr/bin/env bun
-
-import { mkdir, readFile, writeFile } from "fs/promises";
-import { dirname, resolve } from "path";
-
-const VERSION = "0.1.0";
-const DEFAULT_MODEL = process.env.ANTHROPIC_MODEL || "claude-sonnet-4-20250514";
-const DEFAULT_PROMPT =
-  "Extract the text, tables, and structured content from this PDF. Preserve headings, bullets, and table structure.";
-const API_URL = process.env.ANTHROPIC_API_URL || "https://api.anthropic.com/v1/messages";
-const MAX_CHUNK_SIZE = 20;
-const MAX_REQUEST_BYTES = 32 * 1024 * 1024;
-type PdfLib = typeof import("pdf-lib");
-type LoadedPdfDocument = Awaited<ReturnType<PdfLib["PDFDocument"]["load"]>>;
-
-type OutputFormat = "json" | "markdown" | "text";
-
-interface CliOptions {
-  input?: string;
-  pages?: string;
-  prompt: string;
-  format: OutputFormat;
-  model: string;
-  chunkSize: number;
-  maxTokens: number;
-  output?: string;
-  text: boolean;
-}
-
-interface PdfChunkResult {
-  chunk: number;
-  pages: number[];
-  response: unknown;
-}
-
-interface PdfResult {
-  input: string;
-  model: string;
-  prompt: string;
-  format: OutputFormat;
-  totalPages: number;
-  requestedPages: number[];
-  chunkSize: number;
-  chunks: PdfChunkResult[];
-  mergedText: string;
-}
-
-function printHelp(): void {
-  console.log(`read-pdf v${VERSION}
-
-USAGE:
-  read-pdf --input <path-or-url> [options]
-
-OPTIONS:
-  -i, --input <path-or-url>  PDF file path or remote URL
-      --pages <ranges>       Page ranges like 1-3,5,8-10
-  -p, --prompt <text>        Extraction prompt
-  -f, --format <value>       json | markdown | text
-  -m, --model <name>         Anthropic model to call
-      --chunk-size <n>       Pages per request (max 20)
-      --max-tokens <n>       Maximum response tokens per chunk
-  -o, --output <path>        Save result to a file
-      --text                 Print only merged chunk text
-      --help                 Show this help message
-      --version              Show the current version
-`);
-}
-
-function parseArgs(argv: string[]): CliOptions {
-  const options: CliOptions = {
-    prompt: DEFAULT_PROMPT,
-    format: "markdown",
-    model: DEFAULT_MODEL,
-    chunkSize: MAX_CHUNK_SIZE,
-    maxTokens: 1600,
-    text: false,
-  };
-
-  for (let i = 0; i < argv.length; i += 1) {
-    const arg = argv[i];
-    switch (arg) {
-      case "--help":
-      case "-h":
-        printHelp();
-        process.exit(0);
-      case "--version":
-      case "-v":
-        console.log(VERSION);
-        process.exit(0);
-      case "--input":
-      case "-i":
-        options.input = argv[++i];
-        break;
-      case "--pages":
-        options.pages = argv[++i];
-        break;
-      case "--prompt":
-      case "-p":
-        options.prompt = argv[++i] ?? DEFAULT_PROMPT;
-        break;
-      case "--format":
-      case "-f": {
-        const value = (argv[++i] ?? "markdown").toLowerCase();
-        if (value !== "json" && value !== "markdown" && value !== "text") {
-          throw new Error(`Invalid --format value: ${value}`);
-        }
-        options.format = value;
-        break;
-      }
-      case "--model":
-      case "-m":
-        options.model = argv[++i] ?? DEFAULT_MODEL;
-        break;
-      case "--chunk-size": {
-        const value = Number.parseInt(argv[++i] ?? "", 10);
-        if (!Number.isFinite(value) || value <= 0 || value > MAX_CHUNK_SIZE) {
-          throw new Error(`--chunk-size must be between 1 and ${MAX_CHUNK_SIZE}`);
-        }
-        options.chunkSize = value;
-        break;
-      }
-      case "--max-tokens": {
-        const value = Number.parseInt(argv[++i] ?? "", 10);
-        if (!Number.isFinite(value) || value <= 0) {
-          throw new Error(`Invalid --max-tokens value: ${argv[i]}`);
-        }
-        options.maxTokens = value;
-        break;
-      }
-      case "--output":
-      case "-o":
-        options.output = argv[++i];
-        break;
-      case "--text":
-        options.text = true;
-        break;
-      default:
-        if (arg.startsWith("-")) {
-          throw new Error(`Unknown option: ${arg}`);
-        }
-        if (!options.input) {
-          options.input = arg;
-          break;
-        }
-        throw new Error(`Unexpected argument: ${arg}`);
-    }
-  }
-
-  if (!options.input) {
-    throw new Error("Missing required --input <path-or-url> argument");
-  }
-
-  return options;
-}
-
-function isUrl(value: string): boolean {
-  try {
-    const url = new URL(value);
-    return url.protocol === "http:" || url.protocol === "https:";
-  } catch {
-    return false;
-  }
-}
-
-async function loadPdfBytes(input: string): Promise<{ input: string; bytes: Uint8Array }> {
-  if (isUrl(input)) {
-    const response = await fetch(input);
-    if (!response.ok) {
-      throw new Error(`Failed to download PDF: ${response.status} ${response.statusText}`);
-    }
-    return {
-      input,
-      bytes: new Uint8Array(await response.arrayBuffer()),
-    };
-  }
-
-  const resolvedInput = resolve(input);
-  return {
-    input: resolvedInput,
-    bytes: await readFile(resolvedInput),
-  };
-}
-
-async function loadPdfLib(): Promise<PdfLib> {
-  try {
-    return await import("pdf-lib");
-  } catch {
-    throw new Error("Missing dependency 'pdf-lib'. Run bun install in this skill directory.");
-  }
-}
-
-function parsePageRanges(spec: string | undefined, totalPages: number): number[] {
-  if (!spec) {
-    return Array.from({ length: totalPages }, (_, index) => index + 1);
-  }
-
-  const pages = new Set<number>();
-  for (const part of spec.split(",")) {
-    const trimmed = part.trim();
-    if (!trimmed) continue;
-    if (trimmed.includes("-")) {
-      const [startText, endText] = trimmed.split("-");
-      const start = Number.parseInt(startText ?? "", 10);
-      const end = Number.parseInt(endText ?? "", 10);
-      if (!Number.isFinite(start) || !Number.isFinite(end) || start <= 0 || end <= 0 || end < start) {
-        throw new Error(`Invalid page range: ${trimmed}`);
-      }
-      for (let page = start; page <= end; page += 1) {
-        if (page > totalPages) {
-          throw new Error(`Requested page ${page} exceeds total pages (${totalPages})`);
-        }
-        pages.add(page);
-      }
-      continue;
-    }
-
-    const page = Number.parseInt(trimmed, 10);
-    if (!Number.isFinite(page) || page <= 0 || page > totalPages) {
-      throw new Error(`Invalid page number: ${trimmed}`);
-    }
-    pages.add(page);
-  }
-
-  return Array.from(pages).sort((a, b) => a - b);
-}
-
-function chunkPages(pages: number[], size: number): number[][] {
-  const chunks: number[][] = [];
-  for (let index = 0; index < pages.length; index += size) {
-    chunks.push(pages.slice(index, index + size));
-  }
-  return chunks;
-}
-
-async function buildChunkPdf(pdfLib: PdfLib, sourcePdf: LoadedPdfDocument, pages: number[]): Promise<Uint8Array> {
-  const { PDFDocument } = pdfLib;
-  const output = await PDFDocument.create();
-  const copiedPages = await output.copyPages(sourcePdf, pages.map((page) => page - 1));
-  for (const page of copiedPages) {
-    output.addPage(page);
-  }
-  return output.save();
-}
-
-function formatInstruction(format: OutputFormat): string {
-  switch (format) {
-    case "json":
-      return "Return valid JSON with keys summary, text, tables, and structure.";
-    case "text":
-      return "Return plain text only. Keep the important structure readable.";
-    case "markdown":
-    default:
-      return "Return markdown. Preserve headings, lists, and tables when possible.";
-  }
-}
-
-async function callAnthropicPdf(
-  pdfBytes: Uint8Array,
-  model: string,
-  maxTokens: number,
-  prompt: string,
-): Promise<{ raw: unknown; text: string }> {
-  if (pdfBytes.byteLength > MAX_REQUEST_BYTES) {
-    throw new Error(`Chunk exceeds 32MB request limit (${pdfBytes.byteLength} bytes)`);
-  }
-
-  const apiKey = process.env.ANTHROPIC_API_KEY;
-  if (!apiKey) {
-    throw new Error("Missing ANTHROPIC_API_KEY");
-  }
-
-  const response = await fetch(API_URL, {
-    method: "POST",
-    headers: {
-      "content-type": "application/json",
-      "x-api-key": apiKey,
-      "anthropic-version": "2023-06-01",
-    },
-    body: JSON.stringify({
-      model,
-      max_tokens: maxTokens,
-      messages: [
-        {
-          role: "user",
-          content: [
-            {
-              type: "document",
-              source: {
-                type: "base64",
-                media_type: "application/pdf",
-                data: Buffer.from(pdfBytes).toString("base64"),
-              },
-            },
-            {
-              type: "text",
-              text: prompt,
-            },
-          ],
-        },
-      ],
-    }),
-  });
-
-  const payload = await response.json() as {
-    content?: Array<{ type: string; text?: string }>;
-    error?: { message?: string };
-  };
-
-  if (!response.ok) {
-    throw new Error(payload.error?.message || `Anthropic request failed with status ${response.status}`);
-  }
-
-  const text = (payload.content ?? [])
-    .filter((entry) => entry.type === "text" && typeof entry.text === "string")
-    .map((entry) => entry.text)
-    .join("\n\n");
-
-  return { raw: payload, text };
-}
-
-async function writeOutput(path: string, value: string): Promise<void> {
-  await mkdir(dirname(path), { recursive: true });
-  await writeFile(path, value, "utf8");
-}
-
-async function main(): Promise<void> {
-  const options = parseArgs(process.argv.slice(2));
-  const pdfLib = await loadPdfLib();
-  const { PDFDocument } = pdfLib;
-  const { input, bytes } = await loadPdfBytes(options.input!);
-  const sourcePdf = await PDFDocument.load(bytes);
-  const totalPages = sourcePdf.getPageCount();
-  const requestedPages = parsePageRanges(options.pages, totalPages);
-  const pageChunks = chunkPages(requestedPages, options.chunkSize);
-  const chunkResults: PdfChunkResult[] = [];
-  const mergedParts: string[] = [];
-
-  for (let index = 0; index < pageChunks.length; index += 1) {
-    const pages = pageChunks[index];
-    const chunkPdf = await buildChunkPdf(pdfLib, sourcePdf, pages);
-    const prompt = [
-      options.prompt,
-      formatInstruction(options.format),
-      `This chunk covers pages ${pages.join(", ")}.`,
-      `Chunk ${index + 1} of ${pageChunks.length}.`,
-    ].join("\n\n");
-    const response = await callAnthropicPdf(chunkPdf, options.model, options.maxTokens, prompt);
-    chunkResults.push({
-      chunk: index + 1,
-      pages,
-      response: options.format === "json" ? tryParseJson(response.text) : response.text,
-    });
-    mergedParts.push(response.text);
-  }
-
-  const result: PdfResult = {
-    input,
-    model: options.model,
-    prompt: options.prompt,
-    format: options.format,
-    totalPages,
-    requestedPages,
-    chunkSize: options.chunkSize,
-    chunks: chunkResults,
-    mergedText: mergedParts.join("\n\n"),
-  };
-
-  const output = options.text ? `${result.mergedText}\n` : `${JSON.stringify(result, null, 2)}\n`;
-  if (options.output) {
-    await writeOutput(resolve(options.output), output);
-  } else {
-    process.stdout.write(output);
-  }
-}
-
-function tryParseJson(value: string): unknown {
-  try {
-    return JSON.parse(value);
-  } catch {
-    return value;
-  }
-}
-
-main().catch((error) => {
-  const message = error instanceof Error ? error.message : String(error);
-  process.stderr.write(`read-pdf: ${message}\n`);
-  process.exit(1);
-});