@hasna/skills 0.1.62 → 0.1.64

package/skills/gif-maker/package.json

@@ -1,30 +0,0 @@
-{
-  "name": "gif-maker",
-  "version": "0.1.0",
-  "description": "Gif Maker skill",
-  "type": "module",
-  "bin": {
-    "gif-maker": "./src/index.ts"
-  },
-  "scripts": {
-    "dev": "bun run src/index.ts",
-    "build": "bun build src/index.ts --outdir dist --target node",
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {
-    "minimist": "^1.2.8",
-    "glob": "^11.1.0"
-  },
-  "devDependencies": {
-    "@types/bun": "latest",
-    "typescript": "^5.7.0"
-  },
-  "publishConfig": {
-    "access": "restricted",
-    "registry": "https://registry.npmjs.org/"
-  },
-  "files": [
-    "src",
-    "tsconfig.json"
-  ]
-}

package/skills/gif-maker/src/index.ts

@@ -1,600 +0,0 @@
-#!/usr/bin/env bun
-
-import { execFileSync, spawnSync } from "child_process";
-import * as fs from "fs";
-import * as path from "path";
-import minimist from "minimist";
-import { globSync } from "glob";
-
-// Path validation to prevent command injection
-const DANGEROUS_PATH_CHARS = /[;&|`$(){}[\]<>\\!*?'"]/;
-
-function validatePath(inputPath: string): void {
-  if (DANGEROUS_PATH_CHARS.test(inputPath)) {
-    throw new Error(`Invalid characters in path: ${inputPath}. Paths cannot contain shell metacharacters.`);
-  }
-  // Resolve to absolute path and check for path traversal
-  const resolved = path.resolve(inputPath);
-  if (resolved.includes("..")) {
-    throw new Error(`Path traversal detected in: ${inputPath}`);
-  }
-}
-
-// Types
-interface GifOptions {
-  output: string;
-  start: number;
-  duration: number | null;
-  end: number | null;
-  fps: number;
-  width: number | null;
-  height: number | null;
-  scale: number;
-  quality: "low" | "medium" | "high";
-  loop: number;
-  speed: number;
-  reverse: boolean;
-  bounce: boolean;
-  delay: number | null;
-  optimize: "none" | "balanced" | "aggressive";
-  dither: string;
-  colors: number;
-}
-
-// Quality presets
-const QUALITY_PRESETS = {
-  low: { fps: 8, colors: 64, dither: "none" },
-  medium: { fps: 12, colors: 128, dither: "sierra2_4a" },
-  high: { fps: 20, colors: 256, dither: "floyd_steinberg" },
-};
-
-// Parse command line arguments
-const args = minimist(process.argv.slice(2), {
-  string: ["output", "quality", "optimize", "dither"],
-  boolean: ["reverse", "bounce", "help"],
-  default: {
-    output: "output.gif",
-    start: 0,
-    fps: 10,
-    scale: 1.0,
-    quality: "medium",
-    loop: 0,
-    speed: 1.0,
-    reverse: false,
-    bounce: false,
-    optimize: "balanced",
-    dither: "sierra2_4a",
-    colors: 256,
-  },
-  alias: {
-    o: "output",
-    q: "quality",
-    h: "help",
-  },
-});
-
-// Show help
-if (args.help || args._.length === 0) {
-  console.log(`
-GIF Maker - Create animated GIFs from videos or images
-
-Usage:
-  skills run gif-maker -- <input> [options]
-  skills run gif-maker -- video.mp4 -o output.gif
-  skills run gif-maker -- *.png -o animation.gif
-
-Options:
-  -o, --output <file>       Output file path (default: output.gif)
-  --start <seconds>         Start time for video (default: 0)
-  --duration <seconds>      Duration to capture
-  --end <seconds>           End time for video
-  --fps <number>            Frames per second (default: 10)
-  --width <pixels>          Output width (auto-scales height)
-  --height <pixels>         Output height (auto-scales width)
-  --scale <factor>          Scale factor (default: 1.0)
-  -q, --quality <preset>    Quality: low, medium, high (default: medium)
-  --loop <count>            Loop count, 0 = infinite (default: 0)
-  --speed <factor>          Playback speed (default: 1.0)
-  --reverse                 Reverse playback
-  --bounce                  Play forward then reverse
-  --delay <ms>              Frame delay in ms (images only)
-  --optimize <level>        Optimization: none, balanced, aggressive
-  --dither <algorithm>      Dithering: none, bayer, sierra2_4a, floyd_steinberg
-  --colors <number>         Max colors 2-256 (default: 256)
-  -h, --help                Show this help message
-
-Examples:
-  skills run gif-maker -- video.mp4 -o demo.gif
-  skills run gif-maker -- video.mp4 --start 5 --duration 3 -o clip.gif
-  skills run gif-maker -- "frames/*.png" --fps 24 -o animation.gif
-`);
-  process.exit(0);
-}
-
-// Check for FFmpeg
-function checkFFmpeg(): boolean {
-  try {
-    execFileSync("ffmpeg", ["-version"], { stdio: "pipe" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-if (!checkFFmpeg()) {
-  console.error("Error: FFmpeg is not installed or not in PATH");
-  console.error("Install FFmpeg:");
-  console.error("  macOS: brew install ffmpeg");
-  console.error("  Ubuntu: sudo apt install ffmpeg");
-  console.error("  Windows: winget install ffmpeg");
-  process.exit(1);
-}
-
-// Parse options
-const options: GifOptions = {
-  output: args.output,
-  start: parseFloat(args.start) || 0,
-  duration: args.duration ? parseFloat(args.duration) : null,
-  end: args.end ? parseFloat(args.end) : null,
-  fps: parseInt(args.fps) || 10,
-  width: args.width ? parseInt(args.width) : null,
-  height: args.height ? parseInt(args.height) : null,
-  scale: parseFloat(args.scale) || 1.0,
-  quality: args.quality as GifOptions["quality"],
-  loop: parseInt(args.loop) ?? 0,
-  speed: parseFloat(args.speed) || 1.0,
-  reverse: args.reverse,
-  bounce: args.bounce,
-  delay: args.delay ? parseInt(args.delay) : null,
-  optimize: args.optimize as GifOptions["optimize"],
-  dither: args.dither,
-  colors: Math.min(256, Math.max(2, parseInt(args.colors) || 256)),
-};
-
-// Apply quality preset
-if (options.quality && QUALITY_PRESETS[options.quality]) {
-  const preset = QUALITY_PRESETS[options.quality];
-  if (!args.fps) options.fps = preset.fps;
-  if (!args.colors) options.colors = preset.colors;
-  if (!args.dither) options.dither = preset.dither;
-}
-
-// Get input files
-function getInputFiles(patterns: string[]): string[] {
-  const files: string[] = [];
-
-  for (const pattern of patterns) {
-    // Validate input pattern for dangerous characters before processing
-    // Allow glob wildcards in patterns but validate the base path
-    const hasGlob = pattern.includes("*") || pattern.includes("?");
-
-    // If it contains dangerous characters (other than glob wildcards), validate strictly
-    if (!hasGlob) {
-      validatePath(pattern);
-    } else {
-      // For glob patterns, check for command injection chars but allow * and ?
-      const DANGEROUS_CHARS_GLOB = /[;&|`$(){}[\]<>\\!'"]/;
-      if (DANGEROUS_CHARS_GLOB.test(pattern)) {
-        throw new Error(`Invalid characters in path: ${pattern}. Paths cannot contain shell metacharacters.`);
-      }
-    }
-
-    const matches = globSync(pattern);
-    if (matches.length > 0) {
-      // Validate all matched files
-      for (const match of matches) {
-        validatePath(match);
-      }
-      files.push(...matches);
-    } else if (fs.existsSync(pattern)) {
-      files.push(pattern);
-    }
-  }
-
-  return files.sort();
-}
-
-// Check if input is video or images
-function isVideo(file: string): boolean {
-  const videoExtensions = [".mp4", ".mov", ".avi", ".mkv", ".webm", ".m4v", ".flv"];
-  return videoExtensions.includes(path.extname(file).toLowerCase());
-}
-
-// Get video duration (using execFileSync with array args for safety)
-function getVideoDuration(file: string): number {
-  try {
-    const result = execFileSync("ffprobe", [
-      "-v", "error",
-      "-show_entries", "format=duration",
-      "-of", "default=noprint_wrappers=1:nokey=1",
-      file
-    ], { encoding: "utf-8" });
-    return parseFloat(result.trim());
-  } catch {
-    return 0;
-  }
-}
-
-// Get video dimensions (using execFileSync with array args for safety)
-function getVideoDimensions(file: string): { width: number; height: number } {
-  try {
-    const result = execFileSync("ffprobe", [
-      "-v", "error",
-      "-select_streams", "v:0",
-      "-show_entries", "stream=width,height",
-      "-of", "csv=s=x:p=0",
-      file
-    ], { encoding: "utf-8" });
-    const [width, height] = result.trim().split("x").map(Number);
-    return { width, height };
-  } catch {
-    return { width: 0, height: 0 };
-  }
-}
-
-// Build FFmpeg filter for scaling
-function buildScaleFilter(options: GifOptions, inputWidth: number, inputHeight: number): string {
-  let width = inputWidth;
-  let height = inputHeight;
-
-  if (options.width && options.height) {
-    width = options.width;
-    height = options.height;
-  } else if (options.width) {
-    width = options.width;
-    height = -1; // Auto
-  } else if (options.height) {
-    width = -1; // Auto
-    height = options.height;
-  } else if (options.scale !== 1.0) {
-    width = Math.round(inputWidth * options.scale);
-    height = Math.round(inputHeight * options.scale);
-  }
-
-  // Ensure even dimensions
-  if (width > 0) width = width % 2 === 0 ? width : width - 1;
-  if (height > 0) height = height % 2 === 0 ? height : height - 1;
-
-  return `scale=${width}:${height}:flags=lanczos`;
-}
-
-// Create GIF from video
-async function createGifFromVideo(inputFile: string): Promise<void> {
-  console.log(`\nProcessing video: ${inputFile}`);
-
-  const duration = getVideoDuration(inputFile);
-  const { width: inputWidth, height: inputHeight } = getVideoDimensions(inputFile);
-
-  console.log(`  - Duration: ${duration.toFixed(1)}s`);
-  console.log(`  - Dimensions: ${inputWidth}x${inputHeight}`);
-
-  // Calculate actual duration to process
-  let startTime = options.start;
-  let endTime = options.end !== null ? options.end : duration;
-  let clipDuration = options.duration !== null ? options.duration : endTime - startTime;
-
-  if (startTime >= duration) {
-    console.error("Error: Start time exceeds video duration");
-    process.exit(1);
-  }
-
-  clipDuration = Math.min(clipDuration, duration - startTime);
-
-  console.log(`  - Extracting: ${startTime}s to ${(startTime + clipDuration).toFixed(1)}s`);
-
-  // Build filter chain
-  const filters: string[] = [];
-
-  // Time trimming
-  const inputArgs: string[] = [];
-  if (startTime > 0) {
-    inputArgs.push("-ss", startTime.toString());
-  }
-  if (clipDuration) {
-    inputArgs.push("-t", clipDuration.toString());
-  }
-
-  // Speed adjustment
-  if (options.speed !== 1.0) {
-    const speedFactor = 1 / options.speed;
-    filters.push(`setpts=${speedFactor}*PTS`);
-  }
-
-  // Scale filter
-  const scaleFilter = buildScaleFilter(options, inputWidth, inputHeight);
-  filters.push(scaleFilter);
-
-  // FPS filter
-  filters.push(`fps=${options.fps}`);
-
-  // Reverse filter
-  if (options.reverse) {
-    filters.push("reverse");
-  }
-
-  // Create temp directory
-  const tempDir = process.env.SKILLS_OUTPUT_DIR || "/tmp";
-  const paletteFile = path.join(tempDir, `palette_${Date.now()}.png`);
-
-  // Build filter string
-  const filterString = filters.join(",");
-
-  // Two-pass encoding for better quality
-  console.log("\nGenerating optimized palette...");
-
-  // Pass 1: Generate palette (using spawnSync with array args for safety)
-  const paletteArgs = [
-    "-y",
-    ...inputArgs,
-    "-i", inputFile,
-    "-vf", `${filterString},palettegen=max_colors=${options.colors}:stats_mode=diff`,
-    paletteFile,
-  ];
-
-  try {
-    const result = spawnSync("ffmpeg", paletteArgs, { stdio: "pipe" });
-    if (result.error) throw result.error;
-  } catch (error: any) {
-    console.error("Error generating palette:", error.message);
-    process.exit(1);
-  }
-
-  console.log("Creating GIF...");
-
-  // Pass 2: Create GIF with palette (using spawnSync with array args for safety)
-  const ditherOption = options.dither === "none" ? "" : `:dither=${options.dither}`;
-  const gifArgs = [
-    "-y",
-    ...inputArgs,
-    "-i", inputFile,
-    "-i", paletteFile,
-    "-lavfi", `${filterString} [x]; [x][1:v] paletteuse${ditherOption}`,
-    "-loop", options.loop.toString(),
-    options.output,
-  ];
-
-  try {
-    const result = spawnSync("ffmpeg", gifArgs, { stdio: "pipe" });
-    if (result.error) throw result.error;
-  } catch (error: any) {
-    console.error("Error creating GIF:", error.message);
-    // Clean up palette
-    if (fs.existsSync(paletteFile)) fs.unlinkSync(paletteFile);
-    process.exit(1);
-  }
-
-  // Clean up palette
-  if (fs.existsSync(paletteFile)) fs.unlinkSync(paletteFile);
-
-  // Handle bounce effect (append reversed version)
-  if (options.bounce) {
-    console.log("Applying bounce effect...");
-    const tempGif = path.join(tempDir, `temp_bounce_${Date.now()}.gif`);
-    fs.renameSync(options.output, tempGif);
-
-    // Using spawnSync with array args for safety
-    const bounceArgs = [
-      "-y",
-      "-i", tempGif,
-      "-filter_complex", "[0:v]reverse[r];[0:v][r]concat=n=2:v=1:a=0",
-      "-loop", options.loop.toString(),
-      options.output,
-    ];
-
-    try {
-      const result = spawnSync("ffmpeg", bounceArgs, { stdio: "pipe" });
-      if (result.error) throw result.error;
-    } catch {
-      // Restore original if bounce fails
-      fs.renameSync(tempGif, options.output);
-    }
-
-    if (fs.existsSync(tempGif)) fs.unlinkSync(tempGif);
-  }
-
-  // Optimize if requested (using spawnSync with array args for safety)
-  if (options.optimize === "aggressive") {
-    console.log("Optimizing...");
-    try {
-      // Try gifsicle if available
-      const result = spawnSync("gifsicle", [
-        "-O3",
-        "--colors", options.colors.toString(),
-        "-o", options.output,
-        options.output
-      ], { stdio: "pipe" });
-      if (result.error) throw result.error;
-    } catch {
-      // gifsicle not available, skip
-    }
-  }
-
-  printSummary();
-}
-
-// Create GIF from images
-async function createGifFromImages(imageFiles: string[]): Promise<void> {
-  console.log(`\nProcessing ${imageFiles.length} images...`);
-
-  // Get dimensions from first image
-  const firstImage = imageFiles[0];
-  const { width: inputWidth, height: inputHeight } = getVideoDimensions(firstImage);
-
-  // Calculate frame delay
-  const frameDelay = options.delay !== null ? options.delay / 1000 : 1 / options.fps;
-
-  // Create temp directory for ordered images
-  const tempDir = process.env.SKILLS_OUTPUT_DIR || "/tmp";
-  const listFile = path.join(tempDir, `filelist_${Date.now()}.txt`);
-
-  // Handle reverse
-  let orderedFiles = [...imageFiles];
-  if (options.reverse) {
-    orderedFiles.reverse();
-  }
-
-  // Handle bounce
-  if (options.bounce) {
-    const reversed = [...orderedFiles].reverse().slice(1, -1);
-    orderedFiles = [...orderedFiles, ...reversed];
-  }
-
-  // Create file list for FFmpeg
-  const fileListContent = orderedFiles
-    .map((f) => `file '${path.resolve(f)}'\nduration ${frameDelay}`)
-    .join("\n");
-  fs.writeFileSync(listFile, fileListContent);
-
-  // Build filter chain
-  const filters: string[] = [];
-  const scaleFilter = buildScaleFilter(options, inputWidth || 640, inputHeight || 480);
-  filters.push(scaleFilter);
-  filters.push(`fps=${options.fps}`);
-
-  const filterString = filters.join(",");
-
-  // Generate palette (using spawnSync with array args for safety)
-  console.log("Generating palette...");
-  const paletteFile = path.join(tempDir, `palette_${Date.now()}.png`);
-
-  const paletteArgs = [
-    "-y",
-    "-f", "concat",
-    "-safe", "0",
-    "-i", listFile,
-    "-vf", `${filterString},palettegen=max_colors=${options.colors}`,
-    paletteFile,
-  ];
-
-  try {
-    const result = spawnSync("ffmpeg", paletteArgs, { stdio: "pipe" });
-    if (result.error) throw result.error;
-  } catch (error: any) {
-    console.error("Error generating palette");
-    fs.unlinkSync(listFile);
-    process.exit(1);
-  }
-
-  // Create GIF (using spawnSync with array args for safety)
-  console.log("Creating GIF...");
-  const ditherOption = options.dither === "none" ? "" : `:dither=${options.dither}`;
-  const gifArgs = [
-    "-y",
-    "-f", "concat",
-    "-safe", "0",
-    "-i", listFile,
-    "-i", paletteFile,
-    "-lavfi", `${filterString} [x]; [x][1:v] paletteuse${ditherOption}`,
-    "-loop", options.loop.toString(),
-    options.output,
-  ];
-
-  try {
-    const result = spawnSync("ffmpeg", gifArgs, { stdio: "pipe" });
-    if (result.error) throw result.error;
-  } catch (error: any) {
-    console.error("Error creating GIF");
-  }
-
-  // Clean up
-  fs.unlinkSync(listFile);
-  if (fs.existsSync(paletteFile)) fs.unlinkSync(paletteFile);
-
-  printSummary();
-}
-
-// Print summary
-function printSummary(): void {
-  if (!fs.existsSync(options.output)) {
-    console.error("\nError: Failed to create GIF");
-    process.exit(1);
-  }
-
-  const stats = fs.statSync(options.output);
-  const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
-
-  // Get GIF info (using execFileSync with array args for safety)
-  let dimensions = "unknown";
-  let frames = "unknown";
-  try {
-    const info = execFileSync("ffprobe", [
-      "-v", "error",
-      "-select_streams", "v:0",
-      "-show_entries", "stream=width,height,nb_frames",
-      "-of", "csv=p=0",
-      options.output
-    ], { encoding: "utf-8" });
-    const [width, height, frameCount] = info.trim().split(",");
-    dimensions = `${width}x${height}`;
-    frames = frameCount || "unknown";
-  } catch {
-    // Ignore
-  }
-
-  console.log(`\n${"=".repeat(50)}`);
-  console.log(`Created: ${options.output}`);
-  console.log("=".repeat(50));
-  console.log(`  - Size: ${sizeMB} MB`);
-  console.log(`  - Dimensions: ${dimensions}`);
-  console.log(`  - Frames: ${frames}`);
-  console.log(`  - FPS: ${options.fps}`);
-  console.log(`  - Colors: ${options.colors}`);
-  console.log(`  - Loop: ${options.loop === 0 ? "infinite" : options.loop}`);
-  console.log("");
-}
-
-// Main execution
-async function main(): Promise<void> {
-  try {
-    // Validate output path first (before any processing)
-    try {
-      validatePath(options.output);
-    } catch (error: any) {
-      console.error(`Error: ${error.message}`);
-      process.exit(1);
-    }
-
-    // Get input files (includes validation inside)
-    let inputFiles: string[];
-    try {
-      inputFiles = getInputFiles(args._ as string[]);
-    } catch (error: any) {
-      console.error(`Error: ${error.message}`);
-      process.exit(1);
-    }
-
-    if (inputFiles.length === 0) {
-      console.error("Error: No input files found");
-      process.exit(1);
-    }
-
-    // Ensure output directory exists
-    const outputDir = path.dirname(options.output);
-    if (outputDir && !fs.existsSync(outputDir)) {
-      fs.mkdirSync(outputDir, { recursive: true });
-    }
-
-    // Determine if video or images
-    if (inputFiles.length === 1 && isVideo(inputFiles[0])) {
-      await createGifFromVideo(inputFiles[0]);
-    } else {
-      // Filter to only image files
-      const imageFiles = inputFiles.filter((f) => {
-        const ext = path.extname(f).toLowerCase();
-        return [".png", ".jpg", ".jpeg", ".webp", ".bmp", ".tiff"].includes(ext);
-      });
-
-      if (imageFiles.length === 0) {
-        console.error("Error: No valid image files found");
-        process.exit(1);
-      }
-
-      await createGifFromImages(imageFiles);
-    }
-  } catch (error: any) {
-    console.error(`Error: ${error.message}`);
-    process.exit(1);
-  }
-}
-
-main();

package/skills/gif-maker/tsconfig.json

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