@hasna/skills 0.1.62 → 0.1.64

package/skills/watermark/src/index.ts

@@ -1,587 +0,0 @@
-#!/usr/bin/env bun
-
-import sharp from "sharp";
-import { PDFDocument, rgb, StandardFonts, degrees } from "pdf-lib";
-import * as fs from "fs";
-import * as path from "path";
-import minimist from "minimist";
-import { globSync } from "glob";
-
-// Types
-interface WatermarkOptions {
-  output: string | null;
-  text: string | null;
-  image: string | null;
-  position: string;
-  opacity: number;
-  rotation: number;
-  tile: boolean;
-  margin: number;
-  // Text options
-  font: string;
-  fontSize: number;
-  color: string;
-  bgColor: string | null;
-  shadow: boolean;
-  outline: boolean;
-  outlineColor: string;
-  // Image options
-  scale: number;
-  width: number | null;
-  height: number | null;
-  // PDF options
-  pages: string;
-  layer: "over" | "under";
-}
-
-// Position presets
-const POSITION_PRESETS: Record<string, { x: string; y: string }> = {
-  "top-left": { x: "left", y: "top" },
-  "top-center": { x: "center", y: "top" },
-  "top-right": { x: "right", y: "top" },
-  "center-left": { x: "left", y: "center" },
-  center: { x: "center", y: "center" },
-  "center-right": { x: "right", y: "center" },
-  "bottom-left": { x: "left", y: "bottom" },
-  "bottom-center": { x: "center", y: "bottom" },
-  "bottom-right": { x: "right", y: "bottom" },
-};
-
-// Parse command line arguments
-const args = minimist(process.argv.slice(2), {
-  string: [
-    "output",
-    "text",
-    "image",
-    "position",
-    "font",
-    "color",
-    "bg-color",
-    "outline-color",
-    "pages",
-    "layer",
-  ],
-  boolean: ["tile", "shadow", "outline", "help"],
-  default: {
-    position: "bottom-right",
-    opacity: 0.5,
-    rotation: 0,
-    tile: false,
-    margin: 20,
-    font: "Arial",
-    "font-size": 24,
-    color: "#ffffff",
-    shadow: true,
-    outline: false,
-    "outline-color": "#000000",
-    scale: 0.2,
-    pages: "all",
-    layer: "over",
-  },
-  alias: {
-    o: "output",
-    t: "text",
-    i: "image",
-    p: "position",
-    h: "help",
-  },
-});
-
-// Show help
-if (args.help || args._.length === 0) {
-  console.log(`
-Watermark - Add watermarks to images and PDFs
-
-Usage:
-  skills run watermark -- <file> [options]
-
-Options:
-  -o, --output <path>       Output file or directory
-  -t, --text <text>         Text watermark content
-  -i, --image <path>        Image watermark (logo) path
-  -p, --position <pos>      Position: top-left, center, bottom-right, etc. or "x,y"
-  --opacity <number>        Opacity 0.0-1.0 (default: 0.5)
-  --rotation <degrees>      Rotation angle (default: 0)
-  --tile                    Tile watermark across image
-  --margin <pixels>         Margin from edges (default: 20)
-
-Text Options:
-  --font <name>             Font family (default: Arial)
-  --font-size <pixels>      Font size (default: 24)
-  --color <hex>             Text color (default: #ffffff)
-  --bg-color <hex>          Background color
-  --shadow                  Add drop shadow (default: true)
-  --outline                 Add text outline
-  --outline-color <hex>     Outline color (default: #000000)
-
-Image Options:
-  --scale <factor>          Scale relative to image (default: 0.2)
-  --width <pixels>          Fixed width
-  --height <pixels>         Fixed height
-
-PDF Options:
-  --pages <range>           Pages: "all", "1-5", "1,3,5" (default: all)
-  --layer <position>        Layer: over, under (default: over)
-
-Examples:
-  skills run watermark -- photo.jpg --text "Copyright" -o marked.jpg
-  skills run watermark -- photo.jpg --image logo.png -o branded.jpg
-  skills run watermark -- doc.pdf --text "DRAFT" --rotation -45 -o draft.pdf
-`);
-  process.exit(0);
-}
-
-// Parse options
-const options: WatermarkOptions = {
-  output: args.output || null,
-  text: args.text || null,
-  image: args.image || null,
-  position: args.position,
-  opacity: parseFloat(args.opacity) || 0.5,
-  rotation: parseFloat(args.rotation) || 0,
-  tile: args.tile,
-  margin: parseInt(args.margin) || 20,
-  font: args.font,
-  fontSize: parseInt(args["font-size"]) || 24,
-  color: args.color,
-  bgColor: args["bg-color"] || null,
-  shadow: args.shadow,
-  outline: args.outline,
-  outlineColor: args["outline-color"],
-  scale: parseFloat(args.scale) || 0.2,
-  width: args.width ? parseInt(args.width) : null,
-  height: args.height ? parseInt(args.height) : null,
-  pages: args.pages,
-  layer: args.layer as "over" | "under",
-};
-
-// Validate
-if (!options.text && !options.image) {
-  console.error("Error: Must specify --text or --image watermark");
-  process.exit(1);
-}
-
-// Get input files
-function getInputFiles(patterns: string[]): string[] {
-  const files: string[] = [];
-
-  for (const pattern of patterns) {
-    const matches = globSync(pattern);
-    if (matches.length > 0) {
-      files.push(...matches);
-    } else if (fs.existsSync(pattern)) {
-      files.push(pattern);
-    }
-  }
-
-  return files;
-}
-
-// Parse hex color to RGB
-function hexToRgb(hex: string): { r: number; g: number; b: number } {
-  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
-  if (result) {
-    return {
-      r: parseInt(result[1], 16),
-      g: parseInt(result[2], 16),
-      b: parseInt(result[3], 16),
-    };
-  }
-  return { r: 255, g: 255, b: 255 };
-}
-
-// Calculate position
-function calculatePosition(
-  position: string,
-  containerWidth: number,
-  containerHeight: number,
-  watermarkWidth: number,
-  watermarkHeight: number,
-  margin: number
-): { x: number; y: number } {
-  // Check for custom position
-  if (position.includes(",")) {
-    const [x, y] = position.split(",").map((v) => parseInt(v.trim()));
-    return { x, y };
-  }
-
-  const preset = POSITION_PRESETS[position] || POSITION_PRESETS["bottom-right"];
-
-  let x: number;
-  let y: number;
-
-  // Calculate X
-  switch (preset.x) {
-    case "left":
-      x = margin;
-      break;
-    case "right":
-      x = containerWidth - watermarkWidth - margin;
-      break;
-    default: // center
-      x = (containerWidth - watermarkWidth) / 2;
-  }
-
-  // Calculate Y
-  switch (preset.y) {
-    case "top":
-      y = margin;
-      break;
-    case "bottom":
-      y = containerHeight - watermarkHeight - margin;
-      break;
-    default: // center
-      y = (containerHeight - watermarkHeight) / 2;
-  }
-
-  return { x: Math.max(0, x), y: Math.max(0, y) };
-}
-
-// Create text watermark SVG
-function createTextSvg(
-  text: string,
-  options: WatermarkOptions,
-  width: number,
-  height: number
-): string {
-  const { color, fontSize, shadow, outline, outlineColor, bgColor } = options;
-
-  let shadowFilter = "";
-  if (shadow) {
-    shadowFilter = `
-      <filter id="shadow" x="-20%" y="-20%" width="140%" height="140%">
-        <feDropShadow dx="2" dy="2" stdDeviation="2" flood-opacity="0.5"/>
-      </filter>
-    `;
-  }
-
-  const textStyle = `
-    font-family: ${options.font}, Arial, sans-serif;
-    font-size: ${fontSize}px;
-    fill: ${color};
-    ${shadow ? 'filter: url(#shadow);' : ''}
-    ${outline ? `stroke: ${outlineColor}; stroke-width: 1px;` : ''}
-  `;
-
-  let bgRect = "";
-  if (bgColor) {
-    bgRect = `<rect x="0" y="0" width="100%" height="100%" fill="${bgColor}" rx="4"/>`;
-  }
-
-  // Estimate text dimensions
-  const textWidth = text.length * fontSize * 0.6;
-  const textHeight = fontSize * 1.2;
-  const padding = 10;
-
-  return `
-    <svg width="${textWidth + padding * 2}" height="${textHeight + padding * 2}" xmlns="http://www.w3.org/2000/svg">
-      <defs>${shadowFilter}</defs>
-      ${bgRect}
-      <text x="50%" y="50%" dominant-baseline="middle" text-anchor="middle" style="${textStyle}">
-        ${text}
-      </text>
-    </svg>
-  `;
-}
-
-// Watermark image using Sharp
-async function watermarkImage(inputPath: string, outputPath: string): Promise<void> {
-  console.log(`Processing: ${inputPath}`);
-
-  const image = sharp(inputPath);
-  const metadata = await image.metadata();
-  const { width: imgWidth = 800, height: imgHeight = 600 } = metadata;
-
-  let watermarkBuffer: Buffer;
-  let watermarkWidth: number;
-  let watermarkHeight: number;
-
-  if (options.text) {
-    // Create text watermark
-    const svg = createTextSvg(options.text, options, imgWidth, imgHeight);
-    const svgBuffer = Buffer.from(svg);
-    const svgImage = sharp(svgBuffer);
-    const svgMeta = await svgImage.metadata();
-    watermarkWidth = svgMeta.width || 200;
-    watermarkHeight = svgMeta.height || 50;
-
-    // Apply rotation if needed
-    if (options.rotation !== 0) {
-      watermarkBuffer = await svgImage
-        .rotate(options.rotation, { background: { r: 0, g: 0, b: 0, alpha: 0 } })
-        .toBuffer();
-      const rotatedMeta = await sharp(watermarkBuffer).metadata();
-      watermarkWidth = rotatedMeta.width || watermarkWidth;
-      watermarkHeight = rotatedMeta.height || watermarkHeight;
-    } else {
-      watermarkBuffer = await svgImage.toBuffer();
-    }
-  } else if (options.image) {
-    // Load image watermark
-    let wmImage = sharp(options.image);
-    const wmMeta = await wmImage.metadata();
-
-    // Calculate dimensions
-    if (options.width || options.height) {
-      watermarkWidth = options.width || Math.round((options.height! / wmMeta.height!) * wmMeta.width!);
-      watermarkHeight = options.height || Math.round((options.width! / wmMeta.width!) * wmMeta.height!);
-    } else {
-      watermarkWidth = Math.round(imgWidth * options.scale);
-      watermarkHeight = Math.round((watermarkWidth / wmMeta.width!) * wmMeta.height!);
-    }
-
-    wmImage = wmImage.resize(watermarkWidth, watermarkHeight, { fit: "inside" });
-
-    // Apply rotation
-    if (options.rotation !== 0) {
-      wmImage = wmImage.rotate(options.rotation, { background: { r: 0, g: 0, b: 0, alpha: 0 } });
-    }
-
-    watermarkBuffer = await wmImage.toBuffer();
-    const finalMeta = await sharp(watermarkBuffer).metadata();
-    watermarkWidth = finalMeta.width || watermarkWidth;
-    watermarkHeight = finalMeta.height || watermarkHeight;
-  } else {
-    throw new Error("No watermark specified");
-  }
-
-  // Apply opacity
-  if (options.opacity < 1) {
-    watermarkBuffer = await sharp(watermarkBuffer)
-      .ensureAlpha()
-      .raw()
-      .toBuffer({ resolveWithObject: true })
-      .then(({ data, info }) => {
-        // Modify alpha channel
-        for (let i = 3; i < data.length; i += 4) {
-          data[i] = Math.round(data[i] * options.opacity);
-        }
-        return sharp(data, { raw: { width: info.width, height: info.height, channels: 4 } })
-          .png()
-          .toBuffer();
-      });
-  }
-
-  if (options.tile) {
-    // Create tiled watermark
-    const composites: sharp.OverlayOptions[] = [];
-    const spacingX = watermarkWidth + options.margin * 2;
-    const spacingY = watermarkHeight + options.margin * 2;
-
-    for (let y = 0; y < imgHeight; y += spacingY) {
-      for (let x = 0; x < imgWidth; x += spacingX) {
-        composites.push({
-          input: watermarkBuffer,
-          left: Math.round(x),
-          top: Math.round(y),
-        });
-      }
-    }
-
-    await image.composite(composites).toFile(outputPath);
-  } else {
-    // Single watermark
-    const { x, y } = calculatePosition(
-      options.position,
-      imgWidth,
-      imgHeight,
-      watermarkWidth,
-      watermarkHeight,
-      options.margin
-    );
-
-    await image
-      .composite([
-        {
-          input: watermarkBuffer,
-          left: Math.round(x),
-          top: Math.round(y),
-        },
-      ])
-      .toFile(outputPath);
-  }
-
-  console.log(`  -> ${outputPath}`);
-}
-
-// Parse page range
-function parsePageRange(pageStr: string, totalPages: number): number[] {
-  if (pageStr === "all") {
-    return Array.from({ length: totalPages }, (_, i) => i);
-  }
-
-  const pages: Set<number> = new Set();
-  const parts = pageStr.split(",").map((p) => p.trim());
-
-  for (const part of parts) {
-    if (part.includes("-")) {
-      const [start, end] = part.split("-").map((n) => parseInt(n.trim()));
-      for (let i = start - 1; i < Math.min(end, totalPages); i++) {
-        if (i >= 0) pages.add(i);
-      }
-    } else {
-      const pageNum = parseInt(part) - 1;
-      if (pageNum >= 0 && pageNum < totalPages) {
-        pages.add(pageNum);
-      }
-    }
-  }
-
-  return Array.from(pages).sort((a, b) => a - b);
-}
-
-// Watermark PDF
-async function watermarkPdf(inputPath: string, outputPath: string): Promise<void> {
-  console.log(`Processing PDF: ${inputPath}`);
-
-  const pdfBytes = fs.readFileSync(inputPath);
-  const pdfDoc = await PDFDocument.load(pdfBytes);
-  const pages = pdfDoc.getPages();
-  const totalPages = pages.length;
-
-  const pageIndices = parsePageRange(options.pages, totalPages);
-  console.log(`  Watermarking ${pageIndices.length} of ${totalPages} pages`);
-
-  // Embed font for text watermark
-  const font = await pdfDoc.embedFont(StandardFonts.Helvetica);
-
-  for (const pageIndex of pageIndices) {
-    const page = pages[pageIndex];
-    const { width, height } = page.getSize();
-
-    if (options.text) {
-      // Process text variables
-      let text = options.text
-        .replace("{n}", String(pageIndex + 1))
-        .replace("{total}", String(totalPages))
-        .replace("{date}", new Date().toISOString().split("T")[0])
-        .replace("{filename}", path.basename(inputPath, ".pdf"));
-
-      const textWidth = font.widthOfTextAtSize(text, options.fontSize);
-      const textHeight = options.fontSize;
-
-      const { x, y } = calculatePosition(
-        options.position,
-        width,
-        height,
-        textWidth,
-        textHeight,
-        options.margin
-      );
-
-      const color = hexToRgb(options.color);
-
-      // Draw text
-      page.drawText(text, {
-        x,
-        y,
-        size: options.fontSize,
-        font,
-        color: rgb(color.r / 255, color.g / 255, color.b / 255),
-        opacity: options.opacity,
-        rotate: degrees(options.rotation),
-      });
-    }
-
-    if (options.image) {
-      // Embed and draw image watermark
-      const imageBytes = fs.readFileSync(options.image);
-      const ext = path.extname(options.image).toLowerCase();
-
-      let embeddedImage;
-      if (ext === ".png") {
-        embeddedImage = await pdfDoc.embedPng(imageBytes);
-      } else {
-        embeddedImage = await pdfDoc.embedJpg(imageBytes);
-      }
-
-      // Calculate dimensions
-      let wmWidth = embeddedImage.width;
-      let wmHeight = embeddedImage.height;
-
-      if (options.width || options.height) {
-        wmWidth = options.width || Math.round((options.height! / wmHeight) * wmWidth);
-        wmHeight = options.height || Math.round((options.width! / wmWidth) * wmHeight);
-      } else {
-        wmWidth = Math.round(width * options.scale);
-        wmHeight = Math.round((wmWidth / embeddedImage.width) * embeddedImage.height);
-      }
-
-      const { x, y } = calculatePosition(
-        options.position,
-        width,
-        height,
-        wmWidth,
-        wmHeight,
-        options.margin
-      );
-
-      page.drawImage(embeddedImage, {
-        x,
-        y,
-        width: wmWidth,
-        height: wmHeight,
-        opacity: options.opacity,
-        rotate: degrees(options.rotation),
-      });
-    }
-  }
-
-  const outputBytes = await pdfDoc.save();
-  fs.writeFileSync(outputPath, outputBytes);
-  console.log(`  -> ${outputPath}`);
-}
-
-// Main execution
-async function main(): Promise<void> {
-  try {
-    const inputFiles = getInputFiles(args._ as string[]);
-
-    if (inputFiles.length === 0) {
-      console.error("Error: No input files found");
-      process.exit(1);
-    }
-
-    const isBatch = inputFiles.length > 1;
-    const outputIsDir = options.output && (isBatch || fs.existsSync(options.output) && fs.statSync(options.output).isDirectory());
-
-    // Create output directory if needed
-    if (outputIsDir && options.output && !fs.existsSync(options.output)) {
-      fs.mkdirSync(options.output, { recursive: true });
-    }
-
-    console.log(`\nProcessing ${inputFiles.length} file(s)...\n`);
-
-    for (const inputFile of inputFiles) {
-      const ext = path.extname(inputFile).toLowerCase();
-      const basename = path.basename(inputFile);
-
-      // Determine output path
-      let outputPath: string;
-      if (outputIsDir && options.output) {
-        outputPath = path.join(options.output, basename);
-      } else if (options.output) {
-        outputPath = options.output;
-      } else {
-        const name = path.basename(inputFile, ext);
-        outputPath = path.join(path.dirname(inputFile), `${name}-watermarked${ext}`);
-      }
-
-      // Process based on type
-      if (ext === ".pdf") {
-        await watermarkPdf(inputFile, outputPath);
-      } else if ([".jpg", ".jpeg", ".png", ".webp", ".tiff", ".bmp"].includes(ext)) {
-        await watermarkImage(inputFile, outputPath);
-      } else {
-        console.warn(`Skipping unsupported format: ${inputFile}`);
-      }
-    }
-
-    console.log("\nDone!");
-  } catch (error: any) {
-    console.error(`Error: ${error.message}`);
-    process.exit(1);
-  }
-}
-
-main();

package/skills/watermark/tsconfig.json

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