image-video-optimizer 1.2.1 → 2.0.0

package/.image-video-optimizer.conf

@@ -1,4 +1,4 @@
 img_max_width=1080
-img_format=webp
+img_format=jpg
 video_max_width=720
 video_encode=h264

package/README.md

@@ -128,6 +128,8 @@ image-video-optimizer ./media
 
 **Ubuntu/Debian:**
 ```bash
+sudo pacman -Syu ffmpeg x264
+
 sudo apt update && sudo apt install ffmpeg
 ```
 

package/bin/cli.js

@@ -1,44 +1,28 @@
 #!/usr/bin/env node
 
-const { Command } = require('commander');
-const path = require('path');
+const { program } = require('commander');
 const chalk = require('chalk');
-const ImageVideoOptimizer = require('../src/index');
-
-const program = new Command();
+const path = require('path');
+const optimizer = require('../src/index');
 
 program
   .name('image-video-optimizer')
-  .description('CLI tool to optimize images and videos with configurable resize and compression settings')
+  .description('Optimize and compress images and videos in a directory')
   .version('1.0.0')
-  .argument('[directory]', 'Target directory to optimize (default: current directory)', process.cwd())
-  .option('-d, --dry-run', 'Show what would be processed without making changes')
-  .option('-v, --verbose', 'Enable verbose logging')
-  .action(async (directory, options) => {
+  .argument('[target-dir]', 'Target directory to optimize (default: current directory)', process.cwd())
+  .action(async (targetDir) => {
     try {
-      const targetDir = path.resolve(directory);
-      
-      if (options.dryRun) {
-        console.log(chalk.yellow('🔍 DRY RUN MODE - No files will be modified'));
-        console.log('');
-      }
-      
-      const optimizer = new ImageVideoOptimizer(targetDir);
-      
-      if (options.dryRun) {
-        optimizer.dryRun = true;
-      }
-      
-      if (options.verbose) {
-        optimizer.verbose = true;
-      }
+      const resolvedPath = path.resolve(targetDir);
+      console.log(chalk.blue.bold('\n🚀 Image Video Optimizer\n'));
+      console.log(chalk.gray(`Target directory: ${resolvedPath}`));
       
-      await optimizer.optimize();
+      await optimizer.optimize(resolvedPath);
       
+      console.log(chalk.green.bold('\n✅ Optimization complete!\n'));
     } catch (error) {
-      console.error(chalk.red('Error:'), error.message);
+      console.error(chalk.red.bold('\n❌ Error:\n'), chalk.red(error.message));
       process.exit(1);
     }
   });
 
-program.parse();
+program.parse(process.argv);

package/package.json

@@ -1,33 +1,37 @@
 {
   "name": "image-video-optimizer",
-  "version": "1.2.1",
-  "description": "CLI tool to optimize images and videos with configurable resize and compression settings",
+  "version": "2.0.0",
+  "description": "CLI tool to optimize and compress images and videos with configurable settings",
   "main": "src/index.js",
   "bin": {
     "image-video-optimizer": "./bin/cli.js"
   },
   "scripts": {
-    "start": "node src/index.js",
+    "start": "node bin/cli.js",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "keywords": [
     "image",
     "video",
-    "optimization",
-    "compression",
-    "resize",
+    "optimizer",
+    "compress",
+    "ffmpeg",
     "cli"
   ],
   "author": "",
-  "license": "nirvána",
+  "license": "MIT",
   "dependencies": {
-    "sharp": "^0.32.6",
-    "@ffmpeg-installer/ffmpeg": "^1.1.0",
-    "fluent-ffmpeg": "^2.1.2",
     "commander": "^11.0.0",
-    "chalk": "^4.1.2"
+    "chalk": "^5.3.0",
+    "sharp": "^0.32.0",
+    "fluent-ffmpeg": "^2.1.2"
   },
+  "devDependencies": {},
   "engines": {
     "node": ">=14.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": ""
   }
-}
+}

package/src/fileSearcher.js

@@ -1,75 +1,51 @@
 const fs = require('fs');
 const path = require('path');
 
-class FileSearcher {
-  constructor(targetDir) {
-    this.targetDir = targetDir;
-    this.imageExtensions = ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'tiff', 'webp'];
-    this.videoExtensions = ['avi', 'mov', 'wmv', 'flv', 'webm', 'mkv', 'm4v', 'mp4'];
-  }
+const SUPPORTED_IMAGES = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff', '.webp'];
+const SUPPORTED_VIDEOS = ['.avi', '.mov', '.wmv', '.flv', '.webm', '.mkv', '.m4v', '.mp4'];
 
-  findMediaFiles() {
-    const imageFiles = this.findFilesByExtensions(this.imageExtensions);
-    const videoFiles = this.findFilesByExtensions(this.videoExtensions);
-    
-    return {
-      images: imageFiles,
-      videos: videoFiles
-    };
-  }
+/**
+ * Recursively search for media files in a directory
+ * @param {string} dirPath - Directory path to search
+ * @returns {Promise<{images: Array, videos: Array}>} Found media files
+ */
+async function searchMediaFiles(dirPath) {
+  const images = [];
+  const videos = [];
+
+  async function walk(currentPath) {
+    try {
+      const files = await fs.promises.readdir(currentPath);
 
-  findFilesByExtensions(extensions) {
-    const files = [];
-    
-    const walkDirectory = (dir) => {
-      try {
-        const items = fs.readdirSync(dir);
-        
-        for (const item of items) {
-          const fullPath = path.join(dir, item);
-          const stat = fs.statSync(fullPath);
-          
-          if (stat.isDirectory()) {
-            walkDirectory(fullPath);
-          } else if (stat.isFile()) {
-            const ext = path.extname(item).toLowerCase().slice(1);
-            if (extensions.includes(ext)) {
-              files.push(fullPath);
-            }
+      for (const file of files) {
+        const filePath = path.join(currentPath, file);
+        const stat = await fs.promises.stat(filePath);
+
+        if (stat.isDirectory()) {
+          // Recursively search subdirectories
+          await walk(filePath);
+        } else if (stat.isFile()) {
+          const ext = path.extname(file).toLowerCase();
+
+          if (SUPPORTED_IMAGES.includes(ext)) {
+            images.push(filePath);
+          } else if (SUPPORTED_VIDEOS.includes(ext)) {
+            videos.push(filePath);
           }
         }
-      } catch (error) {
-        console.warn(`Warning: Cannot access directory ${dir}: ${error.message}`);
       }
-    };
-    
-    walkDirectory(this.targetDir);
-    return files;
-  }
-
-  isImageFile(filePath) {
-    const ext = path.extname(filePath).toLowerCase().slice(1);
-    return this.imageExtensions.includes(ext);
+    } catch (error) {
+      console.warn(`Warning: Could not read directory ${currentPath}: ${error.message}`);
+    }
   }
 
-  isVideoFile(filePath) {
-    const ext = path.extname(filePath).toLowerCase().slice(1);
-    return this.videoExtensions.includes(ext);
-  }
+  await walk(dirPath);
 
-  generateOutputPath(filePath, targetType, targetFormat) {
-    const parsedPath = path.parse(filePath);
-    const dir = parsedPath.dir;
-    const name = parsedPath.name;
-    
-    if (targetType === 'image') {
-      return path.join(dir, `${name}.${targetFormat}`);
-    } else if (targetType === 'video') {
-      return path.join(dir, `${name}.mp4`);
-    }
-    
-    return filePath;
-  }
+  return { images, videos };
 }
 
-module.exports = FileSearcher;
+module.exports = {
+  searchMediaFiles,
+  SUPPORTED_IMAGES,
+  SUPPORTED_VIDEOS
+};

package/src/imageProcessor.js

@@ -1,107 +1,109 @@
 const sharp = require('sharp');
 const fs = require('fs');
 const path = require('path');
+const chalk = require('chalk');
 
-class ImageProcessor {
-  constructor(config) {
-    this.config = config;
-  }
+/**
+ * Process a single image file
+ * @param {string} imagePath - Path to the image
+ * @param {object} config - Configuration object
+ * @returns {Promise<{success: boolean, originalSize: number, optimizedSize: number, message: 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);
 
-  async processImage(inputPath) {
-    try {
-      const metadata = await sharp(inputPath).metadata();
-      const maxWidth = this.config.get('img_max_width');
-      const targetFormat = this.config.get('img_format');
-      
-      console.log(`Processing image: ${path.basename(inputPath)}`);
-      console.log(`Original dimensions: ${metadata.width}x${metadata.height}`);
-      
-      let needsResize = metadata.width > maxWidth;
-      let needsFormatChange = path.extname(inputPath).toLowerCase().slice(1) !== targetFormat;
-      
-      if (!needsResize && !needsFormatChange) {
-        console.log(`Image already optimized, skipping: ${path.basename(inputPath)}`);
-        return { processed: false, reason: 'already_optimized' };
-      }
+    // Determine output format
+    const outputFormat = config.img_format.toLowerCase();
+    const outputExt = outputFormat === 'jpg' ? '.jpg' : `.${outputFormat}`;
+    const finalPath = path.join(directory, filename + outputExt);
 
-      const outputPath = this.generateOutputPath(inputPath, targetFormat);
-      const parsedPath = path.parse(inputPath);
-      
-      // Always use temporary file for processing
-      const tempPath = path.join(parsedPath.dir, `${parsedPath.name}_temp.${targetFormat}`);
-      console.log(`Using temporary path for processing: ${path.basename(tempPath)}`);
-      
-      let sharpInstance = sharp(inputPath);
-      
-      if (needsResize) {
-        const newHeight = Math.round((maxWidth / metadata.width) * metadata.height);
-        sharpInstance = sharpInstance.resize(maxWidth, newHeight, {
-          fit: 'inside',
-          withoutEnlargement: true
-        });
-        console.log(`Resizing to: ${maxWidth}x${newHeight}`);
-      }
-      
-      switch (targetFormat.toLowerCase()) {
-        case 'jpg':
-        case 'jpeg':
-          sharpInstance = sharpInstance.jpeg({ quality: 85 });
-          break;
-        case 'png':
-          sharpInstance = sharpInstance.png({ compressionLevel: 8 });
-          break;
-        case 'webp':
-          sharpInstance = sharpInstance.webp({ quality: 85 });
-          break;
-        default:
-          sharpInstance = sharpInstance.jpeg({ quality: 85 });
-      }
-      
-      await sharpInstance.toFile(tempPath);
-      
-      const compressionResult = this.checkCompression(inputPath, tempPath);
-      
-      if (compressionResult.effective) {
-        // Replace original with processed file
-        fs.unlinkSync(inputPath);
-        fs.renameSync(tempPath, outputPath);
-        console.log(`✓ Processed: ${path.basename(inputPath)} (${compressionResult.compressionPercent}% reduction)`);
-        return {
-          processed: true,
-          outputPath,
-          originalSize: compressionResult.originalSize,
-          newSize: compressionResult.newSize,
-          compressionPercent: compressionResult.compressionPercent
-        };
-      } else {
-        console.log(`✗ Ineffective compression, keeping original: ${path.basename(inputPath)}`);
-        fs.unlinkSync(tempPath);
-        return { processed: false, reason: 'ineffective_compression' };
-      }
-      
-    } catch (error) {
-      console.error(`Error processing image ${inputPath}:`, error.message);
-      return { processed: false, error: error.message };
+    // Check if format conversion is needed
+    const needsFormatConversion = ext !== outputExt && ext !== (outputFormat === 'jpg' ? '.jpeg' : outputExt);
+
+    // Read and process image
+    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
+      });
+      wasResized = true;
     }
-  }
 
-  generateOutputPath(inputPath, targetFormat) {
-    const parsedPath = path.parse(inputPath);
-    return path.join(parsedPath.dir, `${parsedPath.name}.${targetFormat}`);
-  }
+    // 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 {
+      image = image[outputFormat]({ quality: 80 });
+    }
+
+    // Write to temporary file
+    await image.toFile(tmpPath);
+
+    // Check if optimized file is smaller
+    const tmpStat = await fs.promises.stat(tmpPath);
+    const optimizedSize = tmpStat.size;
 
-  checkCompression(originalPath, processedPath) {
-    const originalSize = fs.statSync(originalPath).size;
-    const newSize = fs.statSync(processedPath).size;
-    const compressionPercent = Math.round(((originalSize - newSize) / originalSize) * 100);
-    
+    // Decide whether to replace: if smaller OR if format conversion needed OR if resized
+    const shouldReplace = optimizedSize < originalSize || needsFormatConversion || wasResized;
+
+    if (shouldReplace) {
+      // Remove original and rename temp to final path
+      if (finalPath !== imagePath) {
+        await fs.promises.unlink(imagePath);
+      }
+      await fs.promises.rename(tmpPath, finalPath);
+
+      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)`;
+
+      return {
+        success: true,
+        originalSize,
+        optimizedSize,
+        message: `${chalk.green('✓')} ${action} ${sizeInfo}`,
+        filePath: finalPath
+      };
+    } else {
+      // Remove temp file if not replacing
+      await fs.promises.unlink(tmpPath);
+
+      return {
+        success: false,
+        originalSize,
+        optimizedSize,
+        message: `${chalk.yellow('○')} ${path.basename(imagePath)} - Already optimized (${(originalSize / 1024).toFixed(1)}KB)`,
+        filePath: imagePath
+      };
+    }
+  } catch (error) {
     return {
-      originalSize,
-      newSize,
-      compressionPercent,
-      effective: compressionPercent >= 1
+      success: false,
+      originalSize: 0,
+      optimizedSize: 0,
+      message: `${chalk.red('✗')} ${path.basename(imagePath)} - Error: ${error.message}`,
+      error: true
     };
   }
 }
 
-module.exports = ImageProcessor;
+module.exports = {
+  processImage
+};

package/src/index.js

@@ -1,141 +1,173 @@
 const fs = require('fs');
 const path = require('path');
 const chalk = require('chalk');
+const fileSearcher = require('./fileSearcher');
+const imageProcessor = require('./imageProcessor');
+const videoProcessor = require('./videoProcessor');
 
-const Config = require('./config');
-const FileSearcher = require('./fileSearcher');
-const ImageProcessor = require('./imageProcessor');
-const VideoProcessor = require('./videoProcessor');
-
-class ImageVideoOptimizer {
-  constructor(targetDir) {
-    this.targetDir = path.resolve(targetDir);
-    this.config = new Config(this.targetDir);
-    this.fileSearcher = new FileSearcher(this.targetDir);
-    this.imageProcessor = new ImageProcessor(this.config);
-    this.videoProcessor = new VideoProcessor(this.config);
-    
-    this.stats = {
-      imagesProcessed: 0,
-      videosProcessed: 0,
-      imagesSkipped: 0,
-      videosSkipped: 0,
-      totalSizeSaved: 0,
-      errors: []
-    };
-  }
+const DEFAULT_CONFIG = {
+  img_max_width: 1080,
+  img_format: 'jpg',
+  video_max_width: 720,
+  video_encode: 'h264'
+};
 
-  async optimize() {
-    console.log(chalk.blue.bold('🎬 Image Video Optimizer'));
-    console.log(chalk.gray(`Target directory: ${this.targetDir}`));
-    console.log(chalk.gray('Configuration:'), this.config.getAll());
-    console.log('');
+const CONFIG_FILENAME = '.image-video-optimizer.conf';
 
-    if (!fs.existsSync(this.targetDir)) {
-      console.error(chalk.red(`Error: Target directory does not exist: ${this.targetDir}`));
-      return;
+/**
+ * Parse configuration file
+ * @param {string} configPath - Path to configuration file
+ * @returns {object} Parsed configuration
+ */
+function parseConfig(configPath) {
+  try {
+    if (!fs.existsSync(configPath)) {
+      return DEFAULT_CONFIG;
     }
 
-    const mediaFiles = this.fileSearcher.findMediaFiles();
-    
-    console.log(chalk.yellow(`Found ${mediaFiles.images.length} images and ${mediaFiles.videos.length} videos`));
-    console.log('');
+    const content = fs.readFileSync(configPath, 'utf-8');
+    const config = { ...DEFAULT_CONFIG };
 
-    if (mediaFiles.images.length === 0 && mediaFiles.videos.length === 0) {
-      console.log(chalk.green('No media files found to process.'));
-      return;
+    const lines = content.split('\n');
+    for (const line of lines) {
+      const trimmed = line.trim();
+      
+      // Skip comments and empty lines
+      if (!trimmed || trimmed.startsWith('#')) continue;
+
+      const [key, value] = trimmed.split('=').map(s => s.trim());
+
+      if (!key || !value) continue;
+
+      // Parse appropriate types
+      if (key === 'img_max_width' || key === 'video_max_width') {
+        config[key] = parseInt(value, 10);
+      } else {
+        config[key] = value;
+      }
     }
 
-    await this.processImages(mediaFiles.images);
-    await this.processVideos(mediaFiles.videos);
-    
-    this.printSummary();
+    return config;
+  } catch (error) {
+    console.warn(chalk.yellow(`Warning: Could not parse config file: ${error.message}`));
+    return DEFAULT_CONFIG;
   }
+}
 
-  async processImages(imageFiles) {
-    if (imageFiles.length === 0) return;
-    
-    console.log(chalk.cyan.bold('📸 Processing Images...'));
-    console.log('');
-    
-    for (const imagePath of imageFiles) {
-      try {
-        const result = await this.imageProcessor.processImage(imagePath);
-        
-        if (result.processed) {
-          this.stats.imagesProcessed++;
-          this.stats.totalSizeSaved += result.originalSize - result.newSize;
-          
-          if (fs.existsSync(imagePath) && imagePath !== result.outputPath) {
-            fs.unlinkSync(imagePath);
-          }
-        } else if (result.reason === 'already_optimized' || result.reason === 'same_path') {
-          this.stats.imagesSkipped++;
-        } else if (result.error) {
-          this.stats.errors.push({ file: imagePath, error: result.error });
-        }
-      } catch (error) {
-        console.error(chalk.red(`Unexpected error processing ${imagePath}:`, error.message));
-        this.stats.errors.push({ file: imagePath, error: error.message });
+/**
+ * Create default configuration file if it doesn't exist
+ * @param {string} targetDir - Target directory
+ */
+function ensureConfigFile(targetDir) {
+  const configPath = path.join(targetDir, CONFIG_FILENAME);
+
+  if (!fs.existsSync(configPath)) {
+    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
+video_max_width=${DEFAULT_CONFIG.video_max_width}         # Maximum width for videos (pixels)
+video_encode=${DEFAULT_CONFIG.video_encode}           # Video encoding format
+`;
+
+    try {
+      fs.writeFileSync(configPath, configContent);
+      console.log(chalk.cyan(`📝 Created default config: ${CONFIG_FILENAME}`));
+    } catch (error) {
+      console.warn(chalk.yellow(`Warning: Could not create config file: ${error.message}`));
+    }
+  }
+}
+
+/**
+ * Main optimization function
+ * @param {string} targetDir - Target directory to optimize
+ */
+async function optimize(targetDir) {
+  // Validate directory exists
+  if (!fs.existsSync(targetDir)) {
+    throw new Error(`Directory does not exist: ${targetDir}`);
+  }
+
+  // Ensure config file exists
+  ensureConfigFile(targetDir);
+
+  // Load configuration
+  const configPath = path.join(targetDir, CONFIG_FILENAME);
+  const config = parseConfig(configPath);
+
+  console.log(chalk.gray('Configuration:'));
+  console.log(chalk.gray(`  Image Max Width: ${config.img_max_width}px`));
+  console.log(chalk.gray(`  Image Format: ${config.img_format}`));
+  console.log(chalk.gray(`  Video Max Width: ${config.video_max_width}px`));
+  console.log(chalk.gray(`  Video Encode: ${config.video_encode}\n`));
+
+  // Search for media files
+  console.log(chalk.blue('🔍 Searching for media files...'));
+  const { images, videos } = await fileSearcher.searchMediaFiles(targetDir);
+
+  console.log(chalk.gray(`Found ${images.length} image(s) and ${videos.length} video(s)\n`));
+
+  if (images.length === 0 && videos.length === 0) {
+    console.log(chalk.yellow('No media files found to optimize.'));
+    return;
+  }
+
+  let totalOriginalSize = 0;
+  let totalOptimizedSize = 0;
+  let successCount = 0;
+
+  // Process images
+  if (images.length > 0) {
+    console.log(chalk.blue('📷 Processing images...'));
+    for (const imagePath of images) {
+      const result = await imageProcessor.processImage(imagePath, config);
+      console.log(result.message);
+      
+      totalOriginalSize += result.originalSize;
+      totalOptimizedSize += result.optimizedSize;
+      
+      if (result.success) {
+        successCount++;
       }
     }
     console.log('');
   }
 
-  async processVideos(videoFiles) {
-    if (videoFiles.length === 0) return;
-    
-    console.log(chalk.cyan.bold('🎥 Processing Videos...'));
-    console.log('');
-    
-    for (const videoPath of videoFiles) {
-      try {
-        const result = await this.videoProcessor.processVideo(videoPath);
-        
-        if (result.processed) {
-          this.stats.videosProcessed++;
-          this.stats.totalSizeSaved += result.originalSize - result.newSize;
-          
-          if (fs.existsSync(videoPath) && videoPath !== result.outputPath) {
-            fs.unlinkSync(videoPath);
-          }
-        } else if (result.reason === 'already_optimized') {
-          this.stats.videosSkipped++;
-        } else if (result.error) {
-          this.stats.errors.push({ file: videoPath, error: result.error });
-        }
-      } catch (error) {
-        console.error(chalk.red(`Unexpected error processing ${videoPath}:`, error.message));
-        this.stats.errors.push({ file: videoPath, error: error.message });
+  // Process videos
+  if (videos.length > 0) {
+    console.log(chalk.blue('🎬 Processing videos...'));
+    for (const videoPath of videos) {
+      const result = await videoProcessor.processVideo(videoPath, config);
+      console.log(result.message);
+      
+      totalOriginalSize += result.originalSize;
+      totalOptimizedSize += result.optimizedSize;
+      
+      if (result.success) {
+        successCount++;
       }
     }
     console.log('');
   }
 
-  printSummary() {
-    console.log(chalk.green.bold('📊 Optimization Summary'));
-    console.log(chalk.gray('='.repeat(40)));
-    console.log(`Images processed: ${chalk.cyan(this.stats.imagesProcessed)}`);
-    console.log(`Videos processed: ${chalk.cyan(this.stats.videosProcessed)}`);
-    console.log(`Images skipped: ${chalk.yellow(this.stats.imagesSkipped)}`);
-    console.log(`Videos skipped: ${chalk.yellow(this.stats.videosSkipped)}`);
+  // Print summary
+  console.log(chalk.blue('📊 Summary:'));
+  console.log(chalk.gray(`  Files optimized: ${successCount}/${images.length + videos.length}`));
+  
+  if (totalOriginalSize > 0) {
+    const savedSize = totalOriginalSize - totalOptimizedSize;
+    const savedPercent = ((savedSize / totalOriginalSize) * 100).toFixed(1);
     
-    if (this.stats.totalSizeSaved > 0) {
-      const savedMB = (this.stats.totalSizeSaved / 1024 / 1024).toFixed(2);
-      console.log(`Total space saved: ${chalk.green.bold(savedMB + ' MB')}`);
-    }
-    
-    if (this.stats.errors.length > 0) {
-      console.log('');
-      console.log(chalk.red.bold(`Errors encountered: ${this.stats.errors.length}`));
-      this.stats.errors.forEach(({ file, error }) => {
-        console.log(chalk.red(`  ${path.basename(file)}: ${error}`));
-      });
-    }
-    
-    console.log('');
-    console.log(chalk.green.bold('✨ Optimization complete!'));
+    console.log(chalk.gray(`  Original size: ${(totalOriginalSize / 1024 / 1024).toFixed(2)}MB`));
+    console.log(chalk.gray(`  Optimized size: ${(totalOptimizedSize / 1024 / 1024).toFixed(2)}MB`));
+    console.log(chalk.green(`  Space saved: ${(savedSize / 1024 / 1024).toFixed(2)}MB (${savedPercent}%)`));
   }
 }
 
-module.exports = ImageVideoOptimizer;
+module.exports = {
+  optimize,
+  parseConfig,
+  ensureConfigFile
+};

package/src/videoProcessor.js

@@ -1,141 +1,140 @@
 const ffmpeg = require('fluent-ffmpeg');
-const ffmpegInstaller = require('@ffmpeg-installer/ffmpeg');
-ffmpeg.setFfmpegPath(ffmpegInstaller.path);
 const fs = require('fs');
 const path = require('path');
+const chalk = require('chalk');
 
-class VideoProcessor {
-  constructor(config) {
-    this.config = config;
-  }
+/**
+ * Process a single video file
+ * @param {string} videoPath - Path to the video
+ * @param {object} config - Configuration object
+ * @returns {Promise<{success: boolean, originalSize: number, optimizedSize: number, message: string}>}
+ */
+async function processVideo(videoPath, config) {
+  return new Promise((resolve) => {
+    try {
+      fs.stat(videoPath, async (err, stat) => {
+        if (err) {
+          return resolve({
+            success: false,
+            originalSize: 0,
+            optimizedSize: 0,
+            message: `${chalk.red('✗')} ${path.basename(videoPath)} - Cannot access file`,
+            error: true
+          });
+        }
 
-  async processVideo(inputPath) {
-    return new Promise((resolve) => {
-      try {
-        const maxWidth = this.config.get('video_max_width');
-        const encodeFormat = this.config.get('video_encode');
-        
-        console.log(`Processing video: ${path.basename(inputPath)}`);
-        
-        const outputPath = this.generateOutputPath(inputPath);
-        const parsedPath = path.parse(inputPath);
+        const originalSize = stat.size;
+        const tmpPath = videoPath + '.tmp.mp4';
+        const ext = path.extname(videoPath).toLowerCase();
+        const directory = path.dirname(videoPath);
+        const filename = path.basename(videoPath, ext);
+        const finalPath = path.join(directory, filename + '.mp4');
+
+        // Create ffmpeg command
+        // Map codec names to ffmpeg codec names
+        const codecMap = {
+          'h264': 'libx264',
+          'h265': 'libx265',
+          'vp8': 'libvpx',
+          'vp9': 'libvpx-vp9'
+        };
         
-        // Always use temporary file for processing
-        const tempPath = path.join(parsedPath.dir, `${parsedPath.name}_temp.mp4`);
-        console.log(`Using temporary path for processing: ${path.basename(tempPath)}`);
+        const outputCodec = codecMap[config.video_encode.toLowerCase()] || config.video_encode || 'libx264';
         
-        ffmpeg.ffprobe(inputPath, (err, metadata) => {
-          if (err) {
-            console.error(`Error reading video metadata for ${inputPath}:`, err.message);
-            resolve({ processed: false, error: err.message });
-            return;
-          }
-          
-          const videoStream = metadata.streams.find(stream => stream.codec_type === 'video');
-          if (!videoStream) {
-            console.error(`No video stream found in: ${inputPath}`);
-            resolve({ processed: false, error: 'No video stream found' });
-            return;
-          }
-          
-          console.log(`Original dimensions: ${videoStream.width}x${videoStream.height}`);
-          
-          let needsResize = videoStream.width > maxWidth;
-          let alreadyMp4 = path.extname(inputPath).toLowerCase() === '.mp4';
-          
-          if (!needsResize && alreadyMp4) {
-            console.log(`Video already optimized, skipping: ${path.basename(inputPath)}`);
-            resolve({ processed: false, reason: 'already_optimized' });
-            return;
-          }
-          
-          let tempFfmpegCommand = ffmpeg(inputPath);
-          
-          if (needsResize) {
-            const newHeight = Math.round((maxWidth / videoStream.width) * videoStream.height);
-            tempFfmpegCommand = tempFfmpegCommand.videoFilters(`scale=${maxWidth}:${newHeight}`);
-            console.log(`Resizing to: ${maxWidth}x${newHeight}`);
-          }
-          
-          switch (encodeFormat.toLowerCase()) {
-            case 'h264':
-              tempFfmpegCommand = tempFfmpegCommand.videoCodec('libx264').audioCodec('aac');
-              break;
-            case 'h265':
-              tempFfmpegCommand = tempFfmpegCommand.videoCodec('libx265').audioCodec('aac');
-              break;
-            case 'vp9':
-              tempFfmpegCommand = tempFfmpegCommand.videoCodec('libvpx-vp9').audioCodec('libvorbis');
-              break;
-            default:
-              tempFfmpegCommand = tempFfmpegCommand.videoCodec('libx264').audioCodec('aac');
-          }
-          
-          // Add input/output options with proper quoting
-          tempFfmpegCommand = tempFfmpegCommand.inputOptions(['-fflags', '+genpts']);
-          tempFfmpegCommand = tempFfmpegCommand.outputOptions(['-crf', '23', '-preset', 'medium', '-y']);
-          tempFfmpegCommand = tempFfmpegCommand.format('mp4');
-          tempFfmpegCommand = tempFfmpegCommand.output(tempPath);
-          
-          tempFfmpegCommand
-            .on('start', (commandLine) => {
-              console.log(`FFmpeg command: ${commandLine}`);
-            })
-            .on('end', () => {
-              const compressionResult = this.checkCompression(inputPath, tempPath);
-              
-              if (compressionResult.effective) {
-                // Replace original with processed file
-                fs.unlinkSync(inputPath);
-                fs.renameSync(tempPath, outputPath);
-                console.log(`✓ Processed: ${path.basename(inputPath)} (${compressionResult.compressionPercent}% reduction)`);
+        const command = ffmpeg(videoPath)
+          .videoCodec(outputCodec)
+          .size(`${config.video_max_width}x?`)
+          .aspect('16:9')
+          .autopad()
+          .outputOptions([
+            '-preset fast',
+            '-crf 28'
+          ])
+          .output(tmpPath);
+
+        command
+          .on('end', async () => {
+            try {
+              const tmpStat = await new Promise((res, rej) => {
+                fs.stat(tmpPath, (err, stat) => {
+                  if (err) rej(err);
+                  else res(stat);
+                });
+              });
+
+              const optimizedSize = tmpStat.size;
+
+              if (optimizedSize < originalSize) {
+                // Remove original and rename temp to final
+                await fs.promises.unlink(videoPath);
+                await fs.promises.rename(tmpPath, finalPath);
+
                 resolve({
-                  processed: true,
-                  outputPath,
-                  originalSize: compressionResult.originalSize,
-                  newSize: compressionResult.newSize,
-                  compressionPercent: compressionResult.compressionPercent
+                  success: true,
+                  originalSize,
+                  optimizedSize,
+                  message: `${chalk.green('✓')} ${path.basename(videoPath)} → ${path.basename(finalPath)} (${(originalSize / 1024 / 1024).toFixed(1)}MB → ${(optimizedSize / 1024 / 1024).toFixed(1)}MB)`,
+                  filePath: finalPath
                 });
               } else {
-                console.log(`✗ Ineffective compression, keeping original: ${path.basename(inputPath)}`);
-                fs.unlinkSync(tempPath);
-                resolve({ processed: false, reason: 'ineffective_compression' });
+                // Remove temp file if not smaller
+                await fs.promises.unlink(tmpPath);
+
+                resolve({
+                  success: false,
+                  originalSize,
+                  optimizedSize,
+                  message: `${chalk.yellow('○')} ${path.basename(videoPath)} - Already optimized (${(originalSize / 1024 / 1024).toFixed(1)}MB)`,
+                  filePath: videoPath
+                });
               }
-            })
-            .on('error', (err) => {
-              console.error(`Error processing video ${inputPath}:`, err.message);
-              console.error(`FFmpeg stderr: ${err.stderr || 'No stderr available'}`);
-              if (fs.existsSync(tempPath)) {
-                fs.unlinkSync(tempPath);
+            } catch (error) {
+              resolve({
+                success: false,
+                originalSize,
+                optimizedSize: 0,
+                message: `${chalk.red('✗')} ${path.basename(videoPath)} - Post-processing error: ${error.message}`,
+                error: true
+              });
+            }
+          })
+          .on('error', (err) => {
+            // Clean up temp file on error
+            fs.unlink(tmpPath, () => {
+              let errorMsg = err.message;
+              
+              // Provide helpful suggestions for common errors
+              if (err.message.includes('Unknown encoder') || err.message.includes('Encoder')) {
+                errorMsg = `Video codec error. Check available codecs with: ffmpeg -encoders | grep lib`;
+              } else if (err.message.includes('is not available')) {
+                errorMsg = `Codec not available. Verify FFmpeg installation: ffmpeg -version`;
+              } else if (err.message.includes('ENOENT') || err.message.includes('ffmpeg')) {
+                errorMsg = `FFmpeg not found. Install with: brew install ffmpeg (macOS) or apt-get install ffmpeg (Linux)`;
               }
-              resolve({ processed: false, error: err.message });
-            })
-            .run();
-        });
-      } catch (error) {
-        console.error(`Error processing video ${inputPath}:`, error.message);
-        resolve({ processed: false, error: error.message });
-      }
-    });
-  }
-
-  generateOutputPath(inputPath) {
-    const parsedPath = path.parse(inputPath);
-    return path.join(parsedPath.dir, `${parsedPath.name}.mp4`);
-  }
-
-  checkCompression(originalPath, processedPath) {
-    const originalSize = fs.statSync(originalPath).size;
-    const newSize = fs.statSync(processedPath).size;
-    const compressionPercent = Math.round(((originalSize - newSize) / originalSize) * 100);
-    
-    return {
-      originalSize,
-      newSize,
-      compressionPercent,
-      effective: compressionPercent >= 1
-    };
-  }
+              
+              resolve({
+                success: false,
+                originalSize,
+                optimizedSize: 0,
+                message: `${chalk.red('✗')} ${path.basename(videoPath)} - ${errorMsg}`,
+                error: true
+              });
+            });
+          })
+          .run();
+      });
+    } catch (error) {
+      resolve({
+        success: false,
+        originalSize: 0,
+        optimizedSize: 0,
+        message: `${chalk.red('✗')} ${path.basename(videoPath)} - Error: ${error.message}`,
+        error: true
+      });
+    }
+  });
 }
 
-module.exports = VideoProcessor;
+module.exports = {
+  processVideo
+};