qasai 0.0.1

package/dist/index.js

@@ -0,0 +1,879 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command, Option } from "commander";
+import { createRequire } from "module";
+
+// src/commands/compress.ts
+import { glob } from "glob";
+import { stat as stat3, mkdir as mkdir3 } from "fs/promises";
+import { join as join3, dirname as dirname3, basename as basename2, relative, resolve } from "path";
+import ora from "ora";
+import pc from "picocolors";
+
+// src/utils/compressor.ts
+import sharp from "sharp";
+import { optimize } from "svgo";
+import { readFile as readFile2, writeFile as writeFile2, stat as stat2, mkdir as mkdir2, copyFile as copyFile2 } from "fs/promises";
+import { dirname as dirname2, extname, basename, join as join2 } from "path";
+
+// src/utils/engines.ts
+import { execa } from "execa";
+import { stat, copyFile, mkdir } from "fs/promises";
+import { dirname, join } from "path";
+async function compressWithMozjpeg(inputPath, outputPath, options) {
+  const originalStats = await stat(inputPath);
+  const originalSize = originalStats.size;
+  const mozjpeg = await import("mozjpeg");
+  const quality = parseInt(options.quality || "80");
+  await mkdir(dirname(outputPath), { recursive: true });
+  const args = [
+    "-quality",
+    options.lossless ? "100" : String(quality),
+    "-outfile",
+    outputPath,
+    inputPath
+  ];
+  if (options.progressive !== false) {
+    args.unshift("-progressive");
+  }
+  await execa(mozjpeg.default, args);
+  const compressedStats = await stat(outputPath);
+  const compressedSize = compressedStats.size;
+  const saved = originalSize - compressedSize;
+  return {
+    file: inputPath,
+    originalSize,
+    compressedSize,
+    saved,
+    savedPercent: saved / originalSize * 100
+  };
+}
+async function compressWithJpegtran(inputPath, outputPath, options) {
+  const originalStats = await stat(inputPath);
+  const originalSize = originalStats.size;
+  const jpegtran = await import("jpegtran-bin");
+  await mkdir(dirname(outputPath), { recursive: true });
+  const args = [
+    "-optimize",
+    "-outfile",
+    outputPath
+  ];
+  if (options.progressive !== false) {
+    args.push("-progressive");
+  }
+  if (!options.keepMetadata) {
+    args.push("-copy", "none");
+  } else {
+    args.push("-copy", "all");
+  }
+  args.push(inputPath);
+  await execa(jpegtran.default, args);
+  const compressedStats = await stat(outputPath);
+  const compressedSize = compressedStats.size;
+  const saved = originalSize - compressedSize;
+  return {
+    file: inputPath,
+    originalSize,
+    compressedSize,
+    saved,
+    savedPercent: saved / originalSize * 100
+  };
+}
+async function compressWithPngquant(inputPath, outputPath, options) {
+  const originalStats = await stat(inputPath);
+  const originalSize = originalStats.size;
+  const pngquant = await import("pngquant-bin");
+  const quality = options.pngQuality || options.quality || "65-80";
+  const colors = parseInt(options.colors || "256");
+  await mkdir(dirname(outputPath), { recursive: true });
+  const args = [
+    "--quality",
+    quality.includes("-") ? quality : `0-${quality}`,
+    "--speed",
+    "1",
+    "--force",
+    colors.toString(),
+    "--output",
+    outputPath,
+    inputPath
+  ];
+  try {
+    await execa(pngquant.default, args);
+  } catch (error) {
+    const execaError = error;
+    if (execaError.exitCode === 99) {
+      await copyFile(inputPath, outputPath);
+    } else {
+      throw error;
+    }
+  }
+  const compressedStats = await stat(outputPath);
+  const compressedSize = compressedStats.size;
+  const saved = originalSize - compressedSize;
+  return {
+    file: inputPath,
+    originalSize,
+    compressedSize,
+    saved,
+    savedPercent: saved / originalSize * 100
+  };
+}
+async function compressWithOptipng(inputPath, outputPath, options) {
+  const originalStats = await stat(inputPath);
+  const originalSize = originalStats.size;
+  const optipng = await import("optipng-bin");
+  const effort = parseInt(options.effort || "2");
+  await mkdir(dirname(outputPath), { recursive: true });
+  await copyFile(inputPath, outputPath);
+  const args = [
+    `-o${Math.min(7, effort)}`,
+    "-silent",
+    outputPath
+  ];
+  if (!options.keepMetadata) {
+    args.push("-strip", "all");
+  }
+  await execa(optipng.default, args);
+  const compressedStats = await stat(outputPath);
+  const compressedSize = compressedStats.size;
+  const saved = originalSize - compressedSize;
+  return {
+    file: inputPath,
+    originalSize,
+    compressedSize,
+    saved,
+    savedPercent: saved / originalSize * 100
+  };
+}
+async function compressWithGifsicle(inputPath, outputPath, options) {
+  const originalStats = await stat(inputPath);
+  const originalSize = originalStats.size;
+  const gifsicle = await import("gifsicle");
+  const colors = parseInt(options.colors || "256");
+  const effort = parseInt(options.effort || "3");
+  await mkdir(dirname(outputPath), { recursive: true });
+  const args = [
+    `-O${Math.min(3, effort)}`,
+    "--colors",
+    String(colors),
+    "-o",
+    outputPath,
+    inputPath
+  ];
+  if (options.lossless) {
+    args.splice(args.indexOf("--colors"), 2);
+  }
+  await execa(gifsicle.default, args);
+  const compressedStats = await stat(outputPath);
+  const compressedSize = compressedStats.size;
+  const saved = originalSize - compressedSize;
+  return {
+    file: inputPath,
+    originalSize,
+    compressedSize,
+    saved,
+    savedPercent: saved / originalSize * 100
+  };
+}
+
+// src/utils/compressor.ts
+var SUPPORTED_FORMATS = [".jpg", ".jpeg", ".png", ".webp", ".avif", ".gif", ".tiff", ".svg"];
+function isSupportedFormat(file) {
+  const ext = extname(file).toLowerCase();
+  return SUPPORTED_FORMATS.includes(ext);
+}
+function getFormat(file) {
+  const ext = extname(file).toLowerCase().slice(1);
+  return ext;
+}
+function parseResize(resize) {
+  if (resize.endsWith("%")) {
+    return { percent: parseInt(resize) / 100 };
+  }
+  const [w, h] = resize.split("x").map(Number);
+  return { width: w || void 0, height: h || void 0 };
+}
+async function compressSvg(inputPath, outputPath, options) {
+  const originalContent = await readFile2(inputPath, "utf-8");
+  const originalSize = Buffer.byteLength(originalContent, "utf-8");
+  const result = optimize(originalContent, {
+    multipass: true,
+    plugins: [
+      "preset-default",
+      "removeDimensions",
+      {
+        name: "removeAttrs",
+        params: {
+          attrs: options.keepMetadata ? [] : ["data-.*"]
+        }
+      }
+    ]
+  });
+  await mkdir2(dirname2(outputPath), { recursive: true });
+  await writeFile2(outputPath, result.data);
+  const compressedSize = Buffer.byteLength(result.data, "utf-8");
+  const saved = originalSize - compressedSize;
+  return {
+    file: inputPath,
+    originalSize,
+    compressedSize,
+    saved,
+    savedPercent: saved / originalSize * 100
+  };
+}
+async function needsResize(options) {
+  return !!(options.resize || options.maxWidth || options.maxHeight);
+}
+async function resizeWithSharp(inputPath, options) {
+  let image = sharp(inputPath);
+  const metadata = await image.metadata();
+  if (options.resize) {
+    const { width, height, percent } = parseResize(options.resize);
+    if (percent && metadata.width && metadata.height) {
+      image = image.resize(
+        Math.round(metadata.width * percent),
+        Math.round(metadata.height * percent)
+      );
+    } else if (width || height) {
+      image = image.resize(width, height, { fit: "inside", withoutEnlargement: true });
+    }
+  }
+  if (options.maxWidth || options.maxHeight) {
+    const maxW = options.maxWidth ? parseInt(options.maxWidth) : void 0;
+    const maxH = options.maxHeight ? parseInt(options.maxHeight) : void 0;
+    image = image.resize(maxW, maxH, { fit: "inside", withoutEnlargement: true });
+  }
+  return image.toBuffer();
+}
+async function compressJpeg(inputPath, outputPath, options) {
+  const engine = options.jpegEngine || "mozjpeg";
+  let actualInput = inputPath;
+  if (await needsResize(options)) {
+    const buffer = await resizeWithSharp(inputPath, options);
+    const tempPath = outputPath + ".tmp.jpg";
+    await mkdir2(dirname2(tempPath), { recursive: true });
+    await sharp(buffer).jpeg({ quality: 100 }).toFile(tempPath);
+    actualInput = tempPath;
+  }
+  let result;
+  switch (engine) {
+    case "mozjpeg":
+      result = await compressWithMozjpeg(actualInput, outputPath, options);
+      break;
+    case "jpegtran":
+      result = await compressWithJpegtran(actualInput, outputPath, options);
+      break;
+    case "sharp":
+    default:
+      result = await compressWithSharpJpeg(actualInput, outputPath, options);
+      break;
+  }
+  if (actualInput !== inputPath) {
+    await import("fs/promises").then((fs) => fs.unlink(actualInput).catch(() => {
+    }));
+  }
+  result.file = inputPath;
+  return result;
+}
+async function compressWithSharpJpeg(inputPath, outputPath, options) {
+  const originalStats = await stat2(inputPath);
+  const originalSize = originalStats.size;
+  const quality = parseInt(options.quality || "80");
+  await mkdir2(dirname2(outputPath), { recursive: true });
+  let image = sharp(inputPath);
+  if (!options.keepMetadata) {
+    image = image.rotate();
+  }
+  await image.jpeg({
+    quality: options.lossless ? 100 : quality,
+    progressive: options.progressive !== false,
+    mozjpeg: true
+  }).toFile(outputPath);
+  const compressedStats = await stat2(outputPath);
+  const compressedSize = compressedStats.size;
+  const saved = originalSize - compressedSize;
+  return {
+    file: inputPath,
+    originalSize,
+    compressedSize,
+    saved,
+    savedPercent: saved / originalSize * 100
+  };
+}
+async function compressPng(inputPath, outputPath, options) {
+  const engine = options.pngEngine || "pngquant";
+  let actualInput = inputPath;
+  if (await needsResize(options)) {
+    const buffer = await resizeWithSharp(inputPath, options);
+    const tempPath = outputPath + ".tmp.png";
+    await mkdir2(dirname2(tempPath), { recursive: true });
+    await sharp(buffer).png().toFile(tempPath);
+    actualInput = tempPath;
+  }
+  let result;
+  switch (engine) {
+    case "pngquant":
+      result = await compressWithPngquant(actualInput, outputPath, options);
+      break;
+    case "optipng":
+      result = await compressWithOptipng(actualInput, outputPath, options);
+      break;
+    case "sharp":
+    default:
+      result = await compressWithSharpPng(actualInput, outputPath, options);
+      break;
+  }
+  if (actualInput !== inputPath) {
+    await import("fs/promises").then((fs) => fs.unlink(actualInput).catch(() => {
+    }));
+  }
+  result.file = inputPath;
+  return result;
+}
+async function compressWithSharpPng(inputPath, outputPath, options) {
+  const originalStats = await stat2(inputPath);
+  const originalSize = originalStats.size;
+  const quality = parseInt(options.quality || "80");
+  const effort = parseInt(options.effort || "6");
+  await mkdir2(dirname2(outputPath), { recursive: true });
+  let image = sharp(inputPath);
+  if (!options.keepMetadata) {
+    image = image.rotate();
+  }
+  await image.png({
+    compressionLevel: Math.min(9, Math.round(effort * 0.9)),
+    palette: !options.lossless,
+    quality: options.lossless ? 100 : quality,
+    effort
+  }).toFile(outputPath);
+  const compressedStats = await stat2(outputPath);
+  const compressedSize = compressedStats.size;
+  const saved = originalSize - compressedSize;
+  return {
+    file: inputPath,
+    originalSize,
+    compressedSize,
+    saved,
+    savedPercent: saved / originalSize * 100
+  };
+}
+async function compressGif(inputPath, outputPath, options) {
+  const engine = options.gifEngine || "gifsicle";
+  if (engine === "gifsicle") {
+    return compressWithGifsicle(inputPath, outputPath, options);
+  }
+  return compressWithSharpGif(inputPath, outputPath, options);
+}
+async function compressWithSharpGif(inputPath, outputPath, options) {
+  const originalStats = await stat2(inputPath);
+  const originalSize = originalStats.size;
+  const effort = parseInt(options.effort || "6");
+  await mkdir2(dirname2(outputPath), { recursive: true });
+  await sharp(inputPath, { animated: true }).gif({ effort }).toFile(outputPath);
+  const compressedStats = await stat2(outputPath);
+  const compressedSize = compressedStats.size;
+  const saved = originalSize - compressedSize;
+  return {
+    file: inputPath,
+    originalSize,
+    compressedSize,
+    saved,
+    savedPercent: saved / originalSize * 100
+  };
+}
+async function compressRaster(inputPath, outputPath, options) {
+  const originalStats = await stat2(inputPath);
+  const originalSize = originalStats.size;
+  let image = sharp(inputPath);
+  const metadata = await image.metadata();
+  const quality = parseInt(options.quality || "80");
+  const effort = parseInt(options.effort || "6");
+  if (options.resize) {
+    const { width, height, percent } = parseResize(options.resize);
+    if (percent && metadata.width && metadata.height) {
+      image = image.resize(
+        Math.round(metadata.width * percent),
+        Math.round(metadata.height * percent)
+      );
+    } else if (width || height) {
+      image = image.resize(width, height, { fit: "inside", withoutEnlargement: true });
+    }
+  }
+  if (options.maxWidth || options.maxHeight) {
+    const maxW = options.maxWidth ? parseInt(options.maxWidth) : void 0;
+    const maxH = options.maxHeight ? parseInt(options.maxHeight) : void 0;
+    image = image.resize(maxW, maxH, { fit: "inside", withoutEnlargement: true });
+  }
+  if (!options.keepMetadata) {
+    image = image.rotate();
+  }
+  const inputFormat = getFormat(inputPath);
+  const outputFormat = options.format || (inputFormat === "jpeg" ? "jpg" : inputFormat);
+  await mkdir2(dirname2(outputPath), { recursive: true });
+  switch (outputFormat) {
+    case "webp":
+      await image.webp({
+        quality: options.lossless ? 100 : quality,
+        lossless: options.lossless || false,
+        effort
+      }).toFile(outputPath);
+      break;
+    case "avif":
+      await image.avif({
+        quality: options.lossless ? 100 : quality,
+        lossless: options.lossless || false,
+        effort
+      }).toFile(outputPath);
+      break;
+    case "tiff":
+      await image.tiff({
+        quality: options.lossless ? 100 : quality,
+        compression: options.lossless ? "lzw" : "jpeg"
+      }).toFile(outputPath);
+      break;
+    default:
+      await copyFile2(inputPath, outputPath);
+  }
+  const compressedStats = await stat2(outputPath);
+  const compressedSize = compressedStats.size;
+  const saved = originalSize - compressedSize;
+  return {
+    file: inputPath,
+    originalSize,
+    compressedSize,
+    saved,
+    savedPercent: saved / originalSize * 100
+  };
+}
+async function compressImage(inputPath, outputPath, options) {
+  const format = getFormat(inputPath);
+  let finalOutputPath = outputPath;
+  if (options.format && options.format !== format) {
+    const dir = dirname2(outputPath);
+    const name = basename(outputPath, extname(outputPath));
+    finalOutputPath = join2(dir, `${name}.${options.format}`);
+  }
+  switch (format) {
+    case "svg":
+      return compressSvg(inputPath, finalOutputPath, options);
+    case "jpg":
+    case "jpeg":
+      if (!options.format || options.format === "jpg") {
+        return compressJpeg(inputPath, finalOutputPath, options);
+      }
+      return compressRaster(inputPath, finalOutputPath, options);
+    case "png":
+      if (!options.format || options.format === "png") {
+        return compressPng(inputPath, finalOutputPath, options);
+      }
+      return compressRaster(inputPath, finalOutputPath, options);
+    case "gif":
+      if (!options.format) {
+        return compressGif(inputPath, finalOutputPath, options);
+      }
+      return compressRaster(inputPath, finalOutputPath, options);
+    default:
+      return compressRaster(inputPath, finalOutputPath, options);
+  }
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+
+// src/commands/compress.ts
+async function findImages(input, recursive) {
+  const inputStat = await stat3(input);
+  if (inputStat.isFile()) {
+    return isSupportedFormat(input) ? [input] : [];
+  }
+  const pattern = recursive ? "**/*.{jpg,jpeg,png,webp,avif,gif,tiff,svg,JPG,JPEG,PNG,WEBP,AVIF,GIF,TIFF,SVG}" : "*.{jpg,jpeg,png,webp,avif,gif,tiff,svg,JPG,JPEG,PNG,WEBP,AVIF,GIF,TIFF,SVG}";
+  return glob(pattern, { cwd: input, absolute: true, nodir: true });
+}
+function getOutputPath(inputFile, inputDir, outputDir, inPlace) {
+  if (inPlace) {
+    return inputFile;
+  }
+  const relativePath = relative(inputDir, inputFile);
+  return join3(outputDir, relativePath);
+}
+async function compress(input, options) {
+  const inputPath = resolve(input);
+  const inputStat = await stat3(inputPath).catch(() => null);
+  if (!inputStat) {
+    console.error(pc.red(`Error: Path not found: ${inputPath}`));
+    process.exit(1);
+  }
+  const inputDir = inputStat.isDirectory() ? inputPath : dirname3(inputPath);
+  const outputDir = options.inPlace ? inputDir : options.output ? resolve(options.output) : join3(inputDir, "Kasai");
+  const spinner = ora("Finding images...").start();
+  const images = await findImages(inputPath, options.recursive || false);
+  if (images.length === 0) {
+    spinner.fail("No supported images found");
+    return;
+  }
+  spinner.succeed(`Found ${images.length} image${images.length > 1 ? "s" : ""}`);
+  if (!options.inPlace) {
+    await mkdir3(outputDir, { recursive: true });
+  }
+  const results = [];
+  let totalOriginal = 0;
+  let totalCompressed = 0;
+  for (let i = 0; i < images.length; i++) {
+    const image = images[i];
+    const outputPath = getOutputPath(image, inputDir, outputDir, options.inPlace || false);
+    const fileName = basename2(image);
+    const progress = pc.dim(`[${i + 1}/${images.length}]`);
+    const compressSpinner = ora(`${progress} Compressing ${fileName}...`).start();
+    try {
+      const result = await compressImage(image, outputPath, options);
+      results.push(result);
+      totalOriginal += result.originalSize;
+      totalCompressed += result.compressedSize;
+      const savedStr = result.saved > 0 ? pc.green(`-${result.savedPercent.toFixed(1)}%`) : pc.yellow(`+${Math.abs(result.savedPercent).toFixed(1)}%`);
+      compressSpinner.succeed(
+        `${progress} ${fileName} ${pc.dim(formatBytes(result.originalSize))} \u2192 ${pc.dim(formatBytes(result.compressedSize))} ${savedStr}`
+      );
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      compressSpinner.fail(`${progress} ${fileName} - ${pc.red(errorMessage)}`);
+    }
+  }
+  console.log("");
+  const totalSaved = totalOriginal - totalCompressed;
+  const totalPercent = totalOriginal > 0 ? totalSaved / totalOriginal * 100 : 0;
+  console.log(pc.bold("Summary:"));
+  console.log(`  Files processed: ${pc.cyan(results.length.toString())}`);
+  console.log(`  Original size:   ${pc.dim(formatBytes(totalOriginal))}`);
+  console.log(`  Compressed size: ${pc.dim(formatBytes(totalCompressed))}`);
+  console.log(
+    `  Total saved:     ${totalSaved > 0 ? pc.green(`${formatBytes(totalSaved)} (${totalPercent.toFixed(1)}%)`) : pc.yellow("0 B")}`
+  );
+  if (!options.inPlace) {
+    console.log(`  Output:          ${pc.cyan(outputDir)}`);
+  }
+}
+
+// src/commands/interactive.ts
+import * as p from "@clack/prompts";
+import pc2 from "picocolors";
+import { resolve as resolve2 } from "path";
+import { statSync } from "fs";
+async function interactive() {
+  p.intro(pc2.bgCyan(pc2.black(" QASAI Image Compression ")));
+  const input = await p.text({
+    message: "Enter the path to compress",
+    placeholder: "./images or ./photo.jpg",
+    defaultValue: ".",
+    validate: (value) => {
+      try {
+        const path = resolve2(value);
+        statSync(path);
+        return void 0;
+      } catch {
+        return "Path does not exist";
+      }
+    }
+  });
+  if (p.isCancel(input)) {
+    p.cancel("Operation cancelled");
+    process.exit(0);
+  }
+  const outputMode = await p.select({
+    message: "Where should compressed images be saved?",
+    options: [
+      { value: "kasai", label: "Kasai folder", hint: "Creates a Kasai folder in the input directory" },
+      { value: "custom", label: "Custom folder", hint: "Specify a custom output directory" },
+      { value: "inplace", label: "In place", hint: "Overwrites original files (destructive)" }
+    ]
+  });
+  if (p.isCancel(outputMode)) {
+    p.cancel("Operation cancelled");
+    process.exit(0);
+  }
+  let output;
+  let inPlace = false;
+  if (outputMode === "custom") {
+    const customOutput = await p.text({
+      message: "Enter output directory path",
+      placeholder: "./compressed"
+    });
+    if (p.isCancel(customOutput)) {
+      p.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    output = customOutput;
+  } else if (outputMode === "inplace") {
+    const confirm2 = await p.confirm({
+      message: "This will overwrite original files. Are you sure?",
+      initialValue: false
+    });
+    if (p.isCancel(confirm2) || !confirm2) {
+      p.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    inPlace = true;
+  }
+  const compressionType = await p.select({
+    message: "Compression type",
+    options: [
+      { value: "lossy", label: "Lossy", hint: "Smaller files, slight quality loss (recommended)" },
+      { value: "lossless", label: "Lossless", hint: "No quality loss, larger files" }
+    ]
+  });
+  if (p.isCancel(compressionType)) {
+    p.cancel("Operation cancelled");
+    process.exit(0);
+  }
+  let quality = "80";
+  if (compressionType === "lossy") {
+    const qualityInput = await p.text({
+      message: "Quality level (1-100)",
+      placeholder: "80",
+      defaultValue: "80",
+      validate: (value) => {
+        const num = parseInt(value);
+        if (isNaN(num) || num < 1 || num > 100) {
+          return "Please enter a number between 1 and 100";
+        }
+        return void 0;
+      }
+    });
+    if (p.isCancel(qualityInput)) {
+      p.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    quality = qualityInput;
+  }
+  const engineConfig = await p.confirm({
+    message: "Configure compression engines? (defaults are optimal)",
+    initialValue: false
+  });
+  if (p.isCancel(engineConfig)) {
+    p.cancel("Operation cancelled");
+    process.exit(0);
+  }
+  let jpegEngine = "mozjpeg";
+  let pngEngine = "pngquant";
+  let gifEngine = "gifsicle";
+  if (engineConfig) {
+    const jpegEngineChoice = await p.select({
+      message: "JPEG compression engine",
+      options: [
+        { value: "mozjpeg", label: "MozJPEG", hint: "Best compression, recommended" },
+        { value: "jpegtran", label: "jpegtran", hint: "Lossless optimization only" },
+        { value: "sharp", label: "Sharp", hint: "Fast, good compression" }
+      ]
+    });
+    if (p.isCancel(jpegEngineChoice)) {
+      p.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    jpegEngine = jpegEngineChoice;
+    const pngEngineChoice = await p.select({
+      message: "PNG compression engine",
+      options: [
+        { value: "pngquant", label: "pngquant", hint: "Best lossy compression, recommended" },
+        { value: "optipng", label: "OptiPNG", hint: "Lossless optimization" },
+        { value: "sharp", label: "Sharp", hint: "Fast, good compression" }
+      ]
+    });
+    if (p.isCancel(pngEngineChoice)) {
+      p.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    pngEngine = pngEngineChoice;
+    const gifEngineChoice = await p.select({
+      message: "GIF compression engine",
+      options: [
+        { value: "gifsicle", label: "Gifsicle", hint: "Best for animated GIFs, recommended" },
+        { value: "sharp", label: "Sharp", hint: "Fast, basic compression" }
+      ]
+    });
+    if (p.isCancel(gifEngineChoice)) {
+      p.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    gifEngine = gifEngineChoice;
+  }
+  const advancedOptions = await p.multiselect({
+    message: "Additional options",
+    options: [
+      { value: "recursive", label: "Process subdirectories", hint: "Include images in subfolders" },
+      { value: "keepMetadata", label: "Keep metadata", hint: "Preserve EXIF and other metadata" },
+      { value: "resize", label: "Resize images", hint: "Set maximum dimensions" }
+    ],
+    required: false
+  });
+  if (p.isCancel(advancedOptions)) {
+    p.cancel("Operation cancelled");
+    process.exit(0);
+  }
+  const options = {
+    output,
+    inPlace,
+    quality,
+    lossless: compressionType === "lossless",
+    recursive: advancedOptions.includes("recursive"),
+    keepMetadata: advancedOptions.includes("keepMetadata"),
+    progressive: true,
+    jpegEngine,
+    pngEngine,
+    gifEngine
+  };
+  if (advancedOptions.includes("resize")) {
+    const resizeType = await p.select({
+      message: "Resize method",
+      options: [
+        { value: "maxWidth", label: "Maximum width", hint: "Maintains aspect ratio" },
+        { value: "maxHeight", label: "Maximum height", hint: "Maintains aspect ratio" },
+        { value: "dimensions", label: "Specific dimensions", hint: "e.g., 800x600" },
+        { value: "percent", label: "Percentage", hint: "e.g., 50%" }
+      ]
+    });
+    if (p.isCancel(resizeType)) {
+      p.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    if (resizeType === "maxWidth") {
+      const maxWidth = await p.text({
+        message: "Maximum width in pixels",
+        placeholder: "1920",
+        validate: (value) => {
+          const num = parseInt(value);
+          if (isNaN(num) || num < 1) {
+            return "Please enter a valid number";
+          }
+          return void 0;
+        }
+      });
+      if (p.isCancel(maxWidth)) {
+        p.cancel("Operation cancelled");
+        process.exit(0);
+      }
+      options.maxWidth = maxWidth;
+    } else if (resizeType === "maxHeight") {
+      const maxHeight = await p.text({
+        message: "Maximum height in pixels",
+        placeholder: "1080",
+        validate: (value) => {
+          const num = parseInt(value);
+          if (isNaN(num) || num < 1) {
+            return "Please enter a valid number";
+          }
+          return void 0;
+        }
+      });
+      if (p.isCancel(maxHeight)) {
+        p.cancel("Operation cancelled");
+        process.exit(0);
+      }
+      options.maxHeight = maxHeight;
+    } else if (resizeType === "dimensions") {
+      const dimensions = await p.text({
+        message: "Dimensions (WIDTHxHEIGHT)",
+        placeholder: "800x600",
+        validate: (value) => {
+          if (!/^\d+x\d+$/.test(value)) {
+            return "Please use format: WIDTHxHEIGHT (e.g., 800x600)";
+          }
+          return void 0;
+        }
+      });
+      if (p.isCancel(dimensions)) {
+        p.cancel("Operation cancelled");
+        process.exit(0);
+      }
+      options.resize = dimensions;
+    } else if (resizeType === "percent") {
+      const percent = await p.text({
+        message: "Resize percentage",
+        placeholder: "50",
+        validate: (value) => {
+          const num = parseInt(value);
+          if (isNaN(num) || num < 1 || num > 100) {
+            return "Please enter a number between 1 and 100";
+          }
+          return void 0;
+        }
+      });
+      if (p.isCancel(percent)) {
+        p.cancel("Operation cancelled");
+        process.exit(0);
+      }
+      options.resize = `${percent}%`;
+    }
+  }
+  const convertFormat = await p.confirm({
+    message: "Convert images to a different format?",
+    initialValue: false
+  });
+  if (p.isCancel(convertFormat)) {
+    p.cancel("Operation cancelled");
+    process.exit(0);
+  }
+  if (convertFormat) {
+    const format = await p.select({
+      message: "Convert to format",
+      options: [
+        { value: "webp", label: "WebP", hint: "Modern format, great compression" },
+        { value: "avif", label: "AVIF", hint: "Best compression, newer format" },
+        { value: "jpg", label: "JPEG", hint: "Universal compatibility" },
+        { value: "png", label: "PNG", hint: "Lossless, supports transparency" }
+      ]
+    });
+    if (p.isCancel(format)) {
+      p.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    options.format = format;
+  }
+  console.log("");
+  p.outro(pc2.dim("Starting compression..."));
+  console.log("");
+  await compress(input, options);
+}
+
+// src/utils/banner.ts
+import pc3 from "picocolors";
+function banner() {
+  const terminalWidth = process.stdout.columns || 80;
+  const isSmall = terminalWidth < 60;
+  const bigArt = `
+${pc3.white("  \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557")}
+${pc3.white(" \u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551")}
+${pc3.gray(" \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551")}
+${pc3.gray(" \u2588\u2588\u2551\u2584\u2584 \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551")}
+${pc3.dim(" \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551")}
+${pc3.dim("  \u255A\u2550\u2550\u2580\u2580\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D")}
+`;
+  const smallArt = `
+${pc3.white("\u2588\u2580\u2588\u2584\u2580\u2588\u2588\u2580\u2584\u2580\u2588\u2588")}
+${pc3.gray("\u2580\u2580\u2588\u2588\u2580\u2588\u2584\u2588\u2588\u2580\u2588\u2588")}
+`;
+  console.log(isSmall ? smallArt : bigArt);
+  console.log(pc3.dim("  Image Compression CLI\n"));
+}
+
+// src/index.ts
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var program = new Command();
+program.name("qasai").description("Image compression CLI with lossless and lossy options").version(pkg.version, "-v, --version").helpOption("-h, --help", "Display help information");
+program.command("compress").description("Compress images in a directory").argument("[input]", "Input directory or file", ".").option("-o, --output <dir>", "Output directory (default: Kasai folder in input dir)").option("-i, --in-place", "Compress images in place (overwrites originals)").option("-q, --quality <number>", "Quality level 1-100 (default: 80)", "80").option("-l, --lossless", "Use lossless compression").option("--resize <dimensions>", "Resize images (e.g., 800x600, 50%)").option("--max-width <pixels>", "Maximum width (maintains aspect ratio)").option("--max-height <pixels>", "Maximum height (maintains aspect ratio)").option("-f, --format <format>", "Convert to format (jpg, png, webp, avif)").option("-r, --recursive", "Process subdirectories recursively").option("--keep-metadata", "Preserve image metadata (EXIF, etc.)").option("--no-progressive", "Disable progressive encoding for JPEGs").addOption(new Option("--effort <level>", "Compression effort 1-10 (higher = slower but smaller)").default("6")).addOption(
+  new Option("--jpeg-engine <engine>", "JPEG compression engine").choices(["mozjpeg", "jpegtran", "sharp"]).default("mozjpeg")
+).addOption(
+  new Option("--png-engine <engine>", "PNG compression engine").choices(["pngquant", "optipng", "sharp"]).default("pngquant")
+).addOption(
+  new Option("--gif-engine <engine>", "GIF compression engine").choices(["gifsicle", "sharp"]).default("gifsicle")
+).option("--png-quality <range>", "PNG quality range for pngquant (e.g., 65-80)", "65-80").option("--colors <number>", "Max colors for PNG/GIF (2-256)", "256").action(compress);
+program.command("interactive", { isDefault: true }).description("Run in interactive mode").action(async () => {
+  banner();
+  await interactive();
+});
+program.parse();
+//# sourceMappingURL=index.js.map