@lamnn96/imgo 1.0.0

package/README.md

@@ -0,0 +1,127 @@
+# Imgo
+
+Compress & convert images to web-friendly formats right from your terminal.
+
+Supports: **JPG, PNG, WebP, TIFF, AVIF, HEIC, HEIF, GIF, SVG**
+
+## Installation
+
+```bash
+npm install -g imgo
+```
+
+After installation, add the following to your `~/.zshrc` to ensure the command is available globally:
+
+```bash
+# Open .zshrc
+nano ~/.zshrc
+
+# Add this line at the end of the file
+export PATH="$(npm prefix -g)/bin:$PATH"
+
+# Save and reload
+source ~/.zshrc
+```
+
+Verify installation:
+
+```bash
+imgo --version
+```
+
+## Usage
+
+Navigate to the folder containing your images, then run:
+
+### Compress only (keep original format)
+
+```bash
+imgo
+```
+
+Compresses all images in the current directory while preserving their original format. HEIC/HEIF files are automatically converted to JPEG.
+
+### Compress + Convert to WebP
+
+```bash
+imgo -w
+```
+
+### Compress + Convert to PNG
+
+```bash
+imgo -p
+```
+
+### Compress + Convert to JPEG
+
+```bash
+imgo -j
+```
+
+### Options
+
+| Flag | Description |
+|------|-------------|
+| `-w` | Convert all images to WebP |
+| `-p` | Convert all images to PNG |
+| `-j` | Convert all images to JPEG |
+| `-q, --quality <number>` | Output quality 1-100 (default: 80) |
+| `-d, --dir <path>` | Source directory (default: current directory) |
+| `-V, --version` | Show version |
+| `-h, --help` | Show help |
+
+### Examples
+
+```bash
+# Compress all images in current folder
+imgo
+
+# Convert to WebP with custom quality
+imgo -w -q 90
+
+# Process images from a specific folder
+imgo -w -d ~/Pictures/photos
+
+# Convert to JPEG with lower quality for smaller size
+imgo -j -q 60
+```
+
+## Output
+
+All processed images are saved to a `result/` folder inside the source directory.
+
+After processing, you'll see a summary table:
+
+```
+  IMGO
+  Compress + Convert → WEBP | Quality: 80
+  Source: /Users/you/photos
+  Output: /Users/you/photos/result
+
+  ✔ IMG_9998.HEIC → IMG_9998.webp  1.86 MB → 476.0 KB  -75.0%
+  ✔ IMG_9999.HEIC → IMG_9999.webp  2.61 MB → 926.2 KB  -65.3%
+
+  Summary: 2 image(s) processed
+  Total:   5.0 MB → 568 KB  (-88.9%)
+  Saved:   4.5 MB
+```
+
+## Supported Input Formats
+
+- JPEG / JPG
+- PNG
+- WebP
+- TIFF
+- AVIF
+- HEIC / HEIF (Apple photos)
+- GIF
+- SVG
+
+## Requirements
+
+- Node.js >= 18.0.0
+
+## License
+
+MIT

package/bin/imgo.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { processImages } from '../lib/processor.js';
+import chalk from 'chalk';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+
+const program = new Command();
+
+const banner = chalk.bold.hex('#FF6B35')(`
+  ██╗███╗   ███╗ ██████╗  ██████╗ 
+  ██║████╗ ████║██╔════╝ ██╔═══██╗
+  ██║██╔████╔██║██║  ███╗██║   ██║
+  ██║██║╚██╔╝██║██║   ██║██║   ██║
+  ██║██║ ╚═╝ ██║╚██████╔╝╚██████╔╝
+  ╚═╝╚═╝     ╚═╝ ╚═════╝  ╚═════╝ 
+`);
+
+program
+  .name('imgo')
+  .version(pkg.version)
+  .description(`${banner}\n  ${chalk.dim('Compress & convert images to web-friendly formats')}\n`)
+  .option('-w', 'Compress and convert all images to WebP')
+  .option('-p', 'Compress and convert all images to PNG')
+  .option('-j', 'Compress and convert all images to JPEG')
+  .option('-q, --quality <number>', 'Output quality (1-100)', '80')
+  .option('-d, --dir <path>', 'Source directory (default: current directory)', '.')
+  .action(async (options) => {
+    let outputFormat = null;
+
+    if (options.w) outputFormat = 'webp';
+    else if (options.p) outputFormat = 'png';
+    else if (options.j) outputFormat = 'jpeg';
+
+    const quality = Math.min(100, Math.max(1, parseInt(options.quality, 10) || 80));
+    const sourceDir = options.dir;
+
+    try {
+      await processImages({
+        sourceDir,
+        outputFormat,
+        quality,
+      });
+    } catch (err) {
+      console.error(chalk.red(`\n✖ Error: ${err.message}\n`));
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/lib/processor.js

@@ -0,0 +1,264 @@
+import { readdir, readFile, stat, mkdir } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import sharp from 'sharp';
+import convert from 'heic-convert';
+import chalk from 'chalk';
+import ora from 'ora';
+import {
+  isSupportedImage,
+  formatBytes,
+  formatReduction,
+  getOutputExtension,
+  stripExtension,
+  getExtension,
+} from './utils.js';
+
+const QUALITY_PRESETS = {
+  webp: { quality: 80, effort: 6, smartSubsample: true },
+  png: { compressionLevel: 9, adaptiveFiltering: true, palette: false },
+  jpeg: { quality: 80, mozjpeg: true },
+};
+
+function buildSharpPipeline(pipeline, format, quality) {
+  switch (format) {
+    case 'webp':
+      return pipeline.webp({ ...QUALITY_PRESETS.webp, quality });
+    case 'png':
+      return pipeline.png({ ...QUALITY_PRESETS.png });
+    case 'jpeg':
+    case 'jpg':
+      return pipeline.jpeg({ ...QUALITY_PRESETS.jpeg, quality });
+    default:
+      return pipeline;
+  }
+}
+
+function detectFormatFromExt(ext) {
+  const map = {
+    '.jpg': 'jpeg', '.jpeg': 'jpeg',
+    '.png': 'png',
+    '.webp': 'webp',
+    '.tiff': 'tiff', '.tif': 'tiff',
+    '.avif': 'avif',
+    '.gif': 'gif',
+  };
+  return map[ext] || null;
+}
+
+function isHeic(ext) {
+  return ext === '.heic' || ext === '.heif';
+}
+
+async function decodeHeic(inputPath) {
+  const inputBuffer = await readFile(inputPath);
+  const jpegBuffer = await convert({
+    buffer: inputBuffer,
+    format: 'JPEG',
+    quality: 1,
+  });
+  return sharp(jpegBuffer);
+}
+
+function compressInOriginalFormat(pipeline, ext, quality) {
+  const format = detectFormatFromExt(ext);
+  if (!format) return pipeline;
+
+  switch (format) {
+    case 'jpeg':
+      return pipeline.jpeg({ quality, mozjpeg: true });
+    case 'png':
+      return pipeline.png({ compressionLevel: 9, adaptiveFiltering: true });
+    case 'webp':
+      return pipeline.webp({ quality, effort: 6, smartSubsample: true });
+    case 'tiff':
+      return pipeline.tiff({ quality, compression: 'deflate' });
+    case 'avif':
+      return pipeline.avif({ quality, effort: 4 });
+    case 'gif':
+      return pipeline.gif();
+    default:
+      return pipeline;
+  }
+}
+
+export async function processImages({ sourceDir, outputFormat, quality }) {
+  const absDir = resolve(sourceDir);
+  const resultDir = join(absDir, 'result');
+
+  let files;
+  try {
+    files = await readdir(absDir);
+  } catch {
+    throw new Error(`Cannot read directory: ${absDir}`);
+  }
+
+  const imageFiles = files.filter(
+    (f) => isSupportedImage(f) && f !== 'result'
+  );
+
+  if (imageFiles.length === 0) {
+    console.log(chalk.yellow('\n⚠  No supported images found in this directory.\n'));
+    console.log(chalk.dim('  Supported formats: JPG, PNG, WebP, TIFF, AVIF, HEIC, HEIF, GIF, SVG\n'));
+    return;
+  }
+
+  await mkdir(resultDir, { recursive: true });
+
+  const modeLabel = outputFormat
+    ? `Compress + Convert → ${outputFormat.toUpperCase()}`
+    : 'Compress (keep original format)';
+
+  console.log('');
+  console.log(chalk.bold.hex('#FF6B35')('  IMGO'));
+  console.log(chalk.dim(`  ${modeLabel} | Quality: ${quality}`));
+  console.log(chalk.dim(`  Source: ${absDir}`));
+  console.log(chalk.dim(`  Output: ${resultDir}`));
+  console.log('');
+
+  const spinner = ora({
+    text: `Processing ${imageFiles.length} image(s)...`,
+    color: 'cyan',
+  }).start();
+
+  const results = [];
+  let totalOriginal = 0;
+  let totalResult = 0;
+  let successCount = 0;
+  let failCount = 0;
+
+  for (let i = 0; i < imageFiles.length; i++) {
+    const file = imageFiles[i];
+    const inputPath = join(absDir, file);
+    const ext = getExtension(file);
+    const baseName = stripExtension(file);
+
+    let outExt;
+    if (outputFormat) {
+      outExt = getOutputExtension(outputFormat);
+    } else {
+      outExt = ext === '.heic' || ext === '.heif' ? '.jpg' : ext;
+    }
+
+    const outputFileName = `${baseName}${outExt}`;
+    const outputPath = join(resultDir, outputFileName);
+
+    spinner.text = chalk.dim(`  [${i + 1}/${imageFiles.length}] ${file}`);
+
+    try {
+      const inputStat = await stat(inputPath);
+      const originalSize = inputStat.size;
+
+      let pipeline;
+      if (isHeic(ext)) {
+        pipeline = await decodeHeic(inputPath);
+      } else {
+        pipeline = sharp(inputPath, { failOn: 'none' });
+      }
+
+      if (outputFormat) {
+        pipeline = buildSharpPipeline(pipeline, outputFormat, quality);
+      } else {
+        if (isHeic(ext)) {
+          pipeline = pipeline.jpeg({ quality, mozjpeg: true });
+        } else if (ext === '.svg') {
+          pipeline = pipeline.png({ compressionLevel: 9 });
+        } else {
+          pipeline = compressInOriginalFormat(pipeline, ext, quality);
+        }
+      }
+
+      await pipeline.toFile(outputPath);
+
+      const outputStat = await stat(outputPath);
+      const newSize = outputStat.size;
+
+      totalOriginal += originalSize;
+      totalResult += newSize;
+      successCount++;
+
+      results.push({
+        file,
+        outputFile: outputFileName,
+        originalSize,
+        newSize,
+        success: true,
+      });
+    } catch (err) {
+      failCount++;
+      results.push({
+        file,
+        outputFile: outputFileName,
+        originalSize: 0,
+        newSize: 0,
+        success: false,
+        error: err.message,
+      });
+    }
+  }
+
+  spinner.stop();
+
+  results.forEach((r) => {
+    if (r.success) {
+      console.log(
+        chalk.green('  ✔ ') +
+        chalk.white(r.file) +
+        chalk.dim(' → ') +
+        chalk.cyan(r.outputFile) +
+        chalk.dim('  ') +
+        chalk.dim(formatBytes(r.originalSize)) +
+        chalk.dim(' → ') +
+        chalk.white(formatBytes(r.newSize)) +
+        '  ' +
+        formatReduction(r.originalSize, r.newSize)
+      );
+    } else {
+      console.log(
+        chalk.red('  ✖ ') +
+        chalk.red(r.file) +
+        chalk.dim(' — ') +
+        chalk.red(r.error)
+      );
+    }
+  });
+
+  console.log('');
+
+  if (successCount > 0) {
+    const totalSavedPercent = ((totalOriginal - totalResult) / totalOriginal) * 100;
+    const savedSign = totalSavedPercent >= 0 ? '-' : '+';
+    const savedColor = totalSavedPercent >= 0 ? chalk.green : chalk.red;
+
+    console.log(
+      chalk.bold('  Summary: ') +
+      chalk.white(`${successCount} image(s) processed`) +
+      (failCount > 0 ? chalk.red(` | ${failCount} failed`) : '')
+    );
+    console.log(
+      chalk.bold('  Total:   ') +
+      chalk.dim(formatBytes(totalOriginal)) +
+      chalk.dim(' → ') +
+      chalk.white(formatBytes(totalResult)) +
+      '  ' +
+      savedColor(`(${savedSign}${Math.abs(totalSavedPercent).toFixed(1)}%)`)
+    );
+    console.log(
+      chalk.bold('  Saved:   ') +
+      savedColor(formatBytes(totalOriginal - totalResult))
+    );
+  }
+
+  if (failCount > 0) {
+    console.log('');
+    console.log(chalk.red.bold('  Errors:'));
+    results
+      .filter((r) => !r.success)
+      .forEach((r) => {
+        console.log(chalk.red(`    ✖ ${r.file}: ${r.error}`));
+      });
+  }
+
+  console.log('');
+  console.log(chalk.dim(`  Results saved to: ${resultDir}`));
+  console.log('');
+}

package/lib/utils.js

@@ -0,0 +1,47 @@
+import chalk from 'chalk';
+
+const SUPPORTED_EXTENSIONS = new Set([
+  '.jpg', '.jpeg', '.png', '.webp', '.tiff', '.tif',
+  '.avif', '.heic', '.heif', '.gif', '.svg',
+]);
+
+export function isSupportedImage(filename) {
+  const ext = filename.toLowerCase().slice(filename.lastIndexOf('.'));
+  return SUPPORTED_EXTENSIONS.has(ext);
+}
+
+export function formatBytes(bytes) {
+  if (bytes === 0) return '0 B';
+  const units = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  const value = bytes / Math.pow(1024, i);
+  return `${value.toFixed(value < 10 ? 2 : 1)} ${units[i]}`;
+}
+
+export function formatReduction(originalSize, newSize) {
+  if (originalSize === 0) return '0%';
+  const reduction = ((originalSize - newSize) / originalSize) * 100;
+  const sign = reduction >= 0 ? '-' : '+';
+  const color = reduction >= 0 ? chalk.green : chalk.red;
+  return color(`${sign}${Math.abs(reduction).toFixed(1)}%`);
+}
+
+export function getOutputExtension(format) {
+  const map = {
+    webp: '.webp',
+    png: '.png',
+    jpeg: '.jpg',
+    jpg: '.jpg',
+  };
+  return map[format] || null;
+}
+
+export function stripExtension(filename) {
+  const lastDot = filename.lastIndexOf('.');
+  return lastDot > 0 ? filename.slice(0, lastDot) : filename;
+}
+
+export function getExtension(filename) {
+  const lastDot = filename.lastIndexOf('.');
+  return lastDot > 0 ? filename.slice(lastDot).toLowerCase() : '';
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@lamnn96/imgo",
+  "version": "1.0.0",
+  "description": "Compress and convert images to web-friendly formats (WebP, PNG, JPEG) right from your terminal",
+  "type": "module",
+  "main": "lib/processor.js",
+  "bin": {
+    "imgo": "bin/imgo.js"
+  },
+  "keywords": [
+    "image",
+    "compress",
+    "convert",
+    "webp",
+    "png",
+    "jpeg",
+    "heic",
+    "optimization",
+    "cli"
+  ],
+  "author": "Lam Nguyen",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "cli-table3": "^0.6.5",
+    "commander": "^12.1.0",
+    "glob": "^11.0.0",
+    "heic-convert": "^2.1.0",
+    "ora": "^8.1.0",
+    "sharp": "^0.33.5"
+  }
+}