@hasna/skills 0.0.2

package/skills/skill-watermark/package.json

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

package/skills/skill-watermark/src/index.ts

@@ -0,0 +1,587 @@
+#!/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/skill-watermark/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-webcrawling/.env.example

@@ -0,0 +1,2 @@
+# Firecrawl API key (required)
+FIRECRAWL_API_KEY=fc-your-api-key-here

package/skills/skill-webcrawling/CLAUDE.md

@@ -0,0 +1,22 @@
+# service-webcrawling
+
+Web crawling service using Firecrawl API.
+
+## Tech Stack
+
+- Runtime: Bun
+- Language: TypeScript
+- CLI: Commander.js
+- API: Firecrawl
+
+## CLI
+
+```bash
+service-webcrawling scrape https://example.com
+service-webcrawling crawl https://example.com -d 2 -l 20
+service-webcrawling sessions
+```
+
+## Environment
+
+- `FIRECRAWL_API_KEY` - Required

package/skills/skill-webcrawling/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Hasna
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.