image-video-optimizer 3.3.33 → 3.5.1

package/.image-video-optimizer-status.json

@@ -0,0 +1,6 @@
+{
+  "processed": [],
+  "failed": [],
+  "startTime": null,
+  "lastRun": "2026-04-14T14:04:49.168Z"
+}

package/.image-video-optimizer.conf

@@ -1,4 +1,9 @@
-img_max_width=1080
-img_format=jpg
-video_max_width=720
-video_encode=h264
+# Image Video Optimizer Configuration
+# Generated automatically
+
+max_image_width=720         # Compress images wider than this (pixels)
+img_format=null              # Target format for image conversion (null=no conversion)
+video_max_width=720         # Maximum width for videos (pixels)
+video_encode=h264           # Video encoding format
+audio_ext=mp3                 # Audio extension for audio files
+pdf_compress=true           # Enable/disable PDF compression

package/README.md

@@ -25,7 +25,12 @@ npm install -g image-video-optimizer
 ### Basic Usage
 
 ```bash
-image-video-optimizer /path/to/directory
+image-video-optimizer . # will proceed the current directory
+image-video-optimizer /path/to/directory # will proceed the specified directory
+image-video-optimizer /path/to/directory/file.jpg # will proceed the specified image file
+image-video-optimizer /path/to/directory/file.pdf # will proceed the specified pdf file
+image-video-optimizer /path/to/directory/file.mp4 # will proceed the specified video file
+image-video-optimizer /path/to/directory/file.mp3 # will proceed the specified audio file
 ```
 
 ### Options
@@ -34,7 +39,7 @@ image-video-optimizer /path/to/directory
 image-video-optimizer /path/to/directory [options]
 ```
 
-- `<directory>`: Target directory to optimize (required)
+- `<target>`: Target directory or file to optimize (required)
 - `-r, --reset`: Reset status file and start fresh
 - `-v, --verbose`: Enable verbose logging
 - `-V, --version`: Show version number
@@ -46,7 +51,7 @@ Create a `.image-video-optimizer.conf` file in your target directory to customiz
 
 ```ini
 # Image settings
-img_max_width=1080          # Maximum width for images (pixels)
+img_max_width=720          # Maximum width for images (pixels)
 img_format=jpg              # Target format for image conversion
 
 # Video settings
@@ -63,7 +68,7 @@ pdf_compress=true           # Enable/disable PDF compression
 ### Default Configuration
 
 If no configuration file is found, these defaults are used:
-- `img_max_width`: 1080
+- `img_max_width`: 720
 - `img_format`: jpg
 - `video_max_width`: 720
 - `video_encode`: h264
@@ -74,7 +79,7 @@ If no configuration file is found, these defaults are used:
 
 ### Images
 - Input: jpg, jpeg, png, gif, bmp, tiff, webp
-- Output: jpg, png, webp (configurable)
+- Output: jpg, png, webp (as it is but compressed with better algorithms like avif webp)
 
 ### Videos
 - Input: avi, mov, wmv, flv, webm, mkv, m4v, mp4
@@ -143,10 +148,10 @@ image-video-optimizer ./photos --verbose
 ### Custom configuration
 Create `.image-video-optimizer.conf`:
 ```ini
-img_max_width=1920
+img_max_width=720
 img_format=webp
-video_max_width=1080
-video_encode=h265
+video_max_width=720
+video_encode=h264
 audio_ext=mp3
 pdf_compress=true
 ```

package/bin/cli.js

@@ -2,6 +2,7 @@
 
 const { Command } = require('commander');
 const path = require('path');
+const fs = require('fs');
 const { optimize, resetStatus } = require('../src/index');
 
 const program = new Command();
@@ -9,25 +10,29 @@ const program = new Command();
 program
   .name('image-video-optimizer')
   .description('CLI tool to optimize and compress images, videos, audio, and PDFs')
-  .version('3.3.33');
+  .version('3.4.0');
 
 program
-  .argument('[directory]', 'Target directory to optimize', process.cwd())
+  .argument('[target]', 'Target directory or file to optimize', process.cwd())
   .option('-r, --reset', 'Reset status file and start fresh')
   .option('-v, --verbose', 'Show detailed processing information')
-  .action(async (directory, options) => {
+  .action(async (target, options) => {
     try {
-      const targetDir = path.resolve(directory);
+      const targetPath = path.resolve(target);
       
       if (options.reset) {
+        // For reset, we need to determine if it's a file or directory
+        const targetDir = fs.existsSync(targetPath) && fs.statSync(targetPath).isDirectory() 
+          ? targetPath 
+          : path.dirname(targetPath);
         resetStatus(targetDir);
         return;
       }
       
       console.log('\n🚀 Image Video Optimizer\n');
-      console.log('Target directory: ' + targetDir);
+      console.log('Target: ' + targetPath);
       
-      await optimize(targetDir, options.verbose);
+      await optimize(targetPath, options.verbose);
       
       console.log('\n✅ Optimization complete!\n');
     } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "image-video-optimizer",
-  "version": "3.3.33",
+  "version": "3.5.1",
   "description": "CLI tool to optimize and compress images and videos with configurable settings",
   "main": "src/index.js",
   "bin": {

package/src/imageProcessor.js

@@ -3,98 +3,165 @@ const sharp = require('sharp');
 const path = require('path');
 
 /**
- * Process a single image file
+ * Get compression options for a specific format
+ * @param {string} format - Output format (jpg, png, webp, avif)
+ * @returns {object} Sharp compression options
+ */
+function getCompressionOptions(format) {
+  const options = {
+    jpg: { quality: 80, progressive: true },
+    jpeg: { quality: 80, progressive: true },
+    png: { compressionLevel: 9 },
+    webp: { quality: 80 },
+    avif: { quality: 75 }
+  };
+  return options[format.toLowerCase()] || options.jpg;
+}
+
+/**
+ * Compress image to a specific format
+ * @param {object} image - Sharp image object
+ * @param {string} format - Target format
+ * @returns {object} Sharp pipeline with format applied
+ */
+function applyFormat(image, format) {
+  const formatLower = format.toLowerCase();
+  const options = getCompressionOptions(formatLower);
+
+  switch (formatLower) {
+    case 'jpg':
+    case 'jpeg':
+      return image.jpeg(options);
+    case 'png':
+      return image.png(options);
+    case 'webp':
+      return image.webp(options);
+    case 'avif':
+      return image.avif(options);
+    case 'gif':
+      return image.gif();
+    case 'tiff':
+      return image.tiff();
+    default:
+      return image.jpeg(options);
+  }
+}
+
+/**
+ * Process image with multiple formats and keep the smallest
  * @param {string} imagePath - Path to the image
  * @param {object} config - Configuration object
- * @returns {Promise<{success: boolean, originalSize: number, optimizedSize: number, message: string}>}
+ * @returns {Promise<{success: boolean, originalSize: number, optimizedSize: number, message: string, filePath: string}>}
  */
 async function processImage(imagePath, config) {
   try {
     const stat = await fs.promises.stat(imagePath);
     const originalSize = stat.size;
-    const tmpPath = imagePath + '.tmp';
     const ext = path.extname(imagePath).toLowerCase();
     const directory = path.dirname(imagePath);
     const filename = path.basename(imagePath, ext);
 
-    // Determine output format
-    const outputFormat = config.img_format.toLowerCase();
-    const outputExt = outputFormat === 'jpg' ? '.jpg' : `.${outputFormat}`;
-    const finalPath = path.join(directory, filename + outputExt);
-
-    // Check if format conversion is needed
-    const needsFormatConversion = ext !== outputExt && ext !== (outputFormat === 'jpg' ? '.jpeg' : outputExt);
+    // Get max_image_width from config (default to 720)
+    const maxImageWidth = config.max_image_width || 720;
 
-    // Read and process image
+    // Read and get metadata
     let image = sharp(imagePath);
-
-    // Get image metadata
     const metadata = await image.metadata();
 
-    // Resize if width exceeds max_width
-    let wasResized = false;
-    if (metadata.width > config.img_max_width) {
-      image = image.resize(config.img_max_width, null, {
-        withoutEnlargement: true
+    // Step 1: Apply conditional crop/resize based on max_image_width
+    let wasCropped = false;
+    if (metadata.width > maxImageWidth) {
+      image = image.resize(maxImageWidth, null, {
+        withoutEnlargement: true,
+        fit: 'inside'
       });
-      wasResized = true;
+      wasCropped = true;
     }
 
-    // Convert to target format with optimization
-    if (outputFormat === 'jpg' || outputFormat === 'jpeg') {
-      image = image.jpeg({ quality: 80, progressive: true });
-    } else if (outputFormat === 'png') {
-      image = image.png({ compressionLevel: 9 });
-    } else if (outputFormat === 'webp') {
-      image = image.webp({ quality: 80 });
-    } else if (outputFormat === 'gif') {
-      image = image.gif();
-    } else if (outputFormat === 'tiff') {
-      image = image.tiff();
-    } else {
-      // Default to jpeg for unknown formats
-      image = image.jpeg({ quality: 80, progressive: true });
-    }
+    // Step 2: Compress original image format to temp file
+    const originalTmpPath = path.join(directory, `${filename}.original.tmp`);
+    const originalFormatImage = applyFormat(image.clone(), ext.replace('.', ''));
+    await originalFormatImage.toFile(originalTmpPath);
+    const originalTmpStat = await fs.promises.stat(originalTmpPath);
+    const originalCompressedSize = originalTmpStat.size;
+
+    // Step 3: Compress to AVIF and WebP formats to temp files
+    const avifTmpPath = path.join(directory, `${filename}.avif.tmp`);
+    const webpTmpPath = path.join(directory, `${filename}.webp.tmp`);
+
+    const avifImage = applyFormat(image.clone(), 'avif');
+    await avifImage.toFile(avifTmpPath);
+    const avifTmpStat = await fs.promises.stat(avifTmpPath);
+    const avifCompressedSize = avifTmpStat.size;
 
-    // Write to temporary file
-    await image.toFile(tmpPath);
+    const webpImage = applyFormat(image.clone(), 'webp');
+    await webpImage.toFile(webpTmpPath);
+    const webpTmpStat = await fs.promises.stat(webpTmpPath);
+    const webpCompressedSize = webpTmpStat.size;
 
-    // Check if optimized file is smaller
-    const tmpStat = await fs.promises.stat(tmpPath);
-    const optimizedSize = tmpStat.size;
+    // Step 4: Compare sizes and determine best format
+    const formatComparison = [
+      { format: 'original', size: originalCompressedSize, tmpPath: originalTmpPath },
+      { format: 'avif', size: avifCompressedSize, tmpPath: avifTmpPath },
+      { format: 'webp', size: webpCompressedSize, tmpPath: webpTmpPath }
+    ];
 
-    // Decide whether to replace: if smaller OR if format conversion needed OR if resized
-    const shouldReplace = optimizedSize < originalSize || needsFormatConversion || wasResized;
+    // Sort by size to find the smallest
+    formatComparison.sort((a, b) => a.size - b.size);
+    const bestFormat = formatComparison[0];
+
+    // Step 5: Calculate compression savings
+    const optimizedSize = bestFormat.size;
+    const savedSize = originalSize - optimizedSize;
+    const savedPercent = ((savedSize / originalSize) * 100).toFixed(1);
+
+    // Step 6: Decide whether to replace
+    const shouldReplace = optimizedSize < originalSize || wasCropped;
 
     if (shouldReplace) {
-      // Remove original and rename temp to final path
-      if (finalPath !== imagePath) {
-        await fs.promises.unlink(imagePath);
-      }
-      await fs.promises.rename(tmpPath, finalPath);
+      // Read the best file and save it with original filename + extension
+      const bestFileContent = await fs.promises.readFile(bestFormat.tmpPath);
+      const finalPath = imagePath; // Keep original filename and extension
+
+      await fs.promises.writeFile(finalPath, bestFileContent);
 
-      const action = needsFormatConversion ? `${path.basename(imagePath)} → ${path.basename(finalPath)}` : path.basename(finalPath);
-      const sizeInfo = optimizedSize < originalSize 
-        ? `(${(originalSize / 1024).toFixed(1)}KB → ${(optimizedSize / 1024).toFixed(1)}KB)`
-        : `(${(originalSize / 1024).toFixed(1)}KB)`;
+      // Clean up temp files
+      await Promise.all([
+        fs.promises.unlink(originalTmpPath).catch(() => {}),
+        fs.promises.unlink(avifTmpPath).catch(() => {}),
+        fs.promises.unlink(webpTmpPath).catch(() => {})
+      ]);
+
+      const compressionInfo = wasCropped ? `[CROPPED to ${maxImageWidth}px] ` : '';
+      const sizeInfo = `${(originalSize / 1024).toFixed(1)}KB → ${(optimizedSize / 1024).toFixed(1)}KB (${savedPercent}% saved)`;
+      const formatInfo = bestFormat.format !== 'original' ? ` [${bestFormat.format.toUpperCase()} codec]` : '';
 
       return {
         success: true,
         originalSize,
         optimizedSize,
-        message: `✓ ${action} ${sizeInfo}`,
-        filePath: finalPath
+        savedSize,
+        savedPercent: parseFloat(savedPercent),
+        message: `✓ ${path.basename(imagePath)} ${compressionInfo}${sizeInfo}${formatInfo}`,
+        filePath: finalPath,
+        usedFormat: bestFormat.format,
+        wasCropped
       };
     } else {
-      // Remove temp file if not replacing
-      await fs.promises.unlink(tmpPath);
+      // Clean up temp files
+      await Promise.all([
+        fs.promises.unlink(originalTmpPath).catch(() => {}),
+        fs.promises.unlink(avifTmpPath).catch(() => {}),
+        fs.promises.unlink(webpTmpPath).catch(() => {})
+      ]);
 
       return {
         success: false,
         originalSize,
-        optimizedSize,
+        optimizedSize: originalSize,
         message: `○ ${path.basename(imagePath)} - Already optimized (${(originalSize / 1024).toFixed(1)}KB)`,
-        filePath: imagePath
+        filePath: imagePath,
+        usedFormat: 'original'
       };
     }
   } catch (error) {

package/src/index.js

@@ -7,8 +7,7 @@ const audioProcessor = require('./audioProcessor');
 const pdfProcessor = require('./pdfProcessor');
 
 const DEFAULT_CONFIG = {
-  img_max_width: 1080,
-  img_format: 'jpg',
+  max_image_width: 720,
   video_max_width: 720,
   video_encode: 'h264',
   audio_ext: 'mp3',
@@ -70,8 +69,7 @@ function ensureConfigFile(targetDir) {
     const configContent = `# Image Video Optimizer Configuration
 # Generated automatically
 
-img_max_width=${DEFAULT_CONFIG.img_max_width}          # Maximum width for images (pixels)
-img_format=${DEFAULT_CONFIG.img_format}              # Target format for image conversion
+max_image_width=${DEFAULT_CONFIG.max_image_width}         # Compress images wider than this (pixels)
 video_max_width=${DEFAULT_CONFIG.video_max_width}         # Maximum width for videos (pixels)
 video_encode=${DEFAULT_CONFIG.video_encode}           # Video encoding format
 audio_ext=${DEFAULT_CONFIG.audio_ext}                 # Audio extension for audio files
@@ -178,15 +176,19 @@ function markFailed(filePath, error, status, targetDir) {
 
 /**
  * Main optimization function
- * @param {string} targetDir - Target directory to optimize
+ * @param {string} targetPath - Target directory or file to optimize
  * @param {boolean} verbose - Show detailed processing information
  */
-async function optimize(targetDir, verbose = false) {
-  // Validate directory exists
-  if (!fs.existsSync(targetDir)) {
-    throw new Error(`Directory does not exist: ${targetDir}`);
+async function optimize(targetPath, verbose = false) {
+  // Validate target exists
+  if (!fs.existsSync(targetPath)) {
+    throw new Error(`Target does not exist: ${targetPath}`);
   }
 
+  const stats = fs.statSync(targetPath);
+  const isFile = stats.isFile();
+  const targetDir = isFile ? path.dirname(targetPath) : targetPath;
+
   // Ensure config file exists
   ensureConfigFile(targetDir);
 
@@ -196,8 +198,7 @@ async function optimize(targetDir, verbose = false) {
   const status = loadStatus(targetDir);
 
   console.log('Configuration:');
-  console.log(`  Image Max Width: ${config.img_max_width}px`);
-  console.log(`  Image Format: ${config.img_format}`);
+  console.log(`  Image Max Width: ${config.max_image_width}px`);
   console.log(`  Video Max Width: ${config.video_max_width}px`);
   console.log(`  Video Encode: ${config.video_encode}`);
   console.log(`  Audio Extension: ${config.audio_ext}`);
@@ -208,9 +209,33 @@ async function optimize(targetDir, verbose = false) {
   }
   console.log('');
 
-  // Search for media files
+  // Search for media files or process single file
   console.log('🔍 Searching for media files...');
-  const { images, videos, audio, documents } = await fileSearcher.searchMediaFiles(targetDir, { verbose });
+  
+  let images = [], videos = [], audio = [], documents = [];
+  
+  if (isFile) {
+    // Handle single file
+    const ext = path.extname(targetPath).toLowerCase().slice(1);
+    if (fileSearcher.SUPPORTED_IMAGES.includes(ext)) {
+      images = [targetPath];
+    } else if (fileSearcher.SUPPORTED_VIDEOS.includes(ext)) {
+      videos = [targetPath];
+    } else if (fileSearcher.SUPPORTED_AUDIO.includes(ext)) {
+      audio = [targetPath];
+    } else if (fileSearcher.SUPPORTED_DOCUMENTS.includes(ext)) {
+      documents = [targetPath];
+    } else {
+      throw new Error(`Unsupported file type: ${ext}`);
+    }
+  } else {
+    // Handle directory
+    const result = await fileSearcher.searchMediaFiles(targetDir, { verbose });
+    images = result.images;
+    videos = result.videos;
+    audio = result.audio;
+    documents = result.documents;
+  }
 
   // Filter out already processed files
   const pendingImages = images.filter(img => !isProcessed(img, status));

package/src/config.js

@@ -1,57 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-const DEFAULT_CONFIG = {
-  img_max_width: 1080,
-  img_format: 'jpg',
-  video_max_width: 720,
-  video_encode: 'h264'
-};
-
-class Config {
-  constructor(targetDir) {
-    this.targetDir = targetDir;
-    this.configPath = path.join(targetDir, '.image-video-optimizer.conf');
-    this.config = { ...DEFAULT_CONFIG };
-    this.loadConfig();
-  }
-
-  loadConfig() {
-    try {
-      if (fs.existsSync(this.configPath)) {
-        const configContent = fs.readFileSync(this.configPath, 'utf8');
-        const lines = configContent.split('\n');
-        
-        lines.forEach(line => {
-          line = line.trim();
-          if (line && !line.startsWith('#')) {
-            const [key, value] = line.split('=').map(s => s.trim());
-            if (key && value) {
-              if (key.includes('width') || key.includes('max_width')) {
-                this.config[key] = parseInt(value, 10);
-              } else {
-                this.config[key] = value;
-              }
-            }
-          }
-        });
-        
-        console.log(`Loaded configuration from ${this.configPath}`);
-      } else {
-        console.log('Using default configuration');
-      }
-    } catch (error) {
-      console.warn('Error loading configuration file, using defaults:', error.message);
-    }
-  }
-
-  get(key) {
-    return this.config[key];
-  }
-
-  getAll() {
-    return { ...this.config };
-  }
-}
-
-module.exports = Config;