image-video-optimizer 2.0.3 → 3.0.0

package/bin/cli.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 
 const { program } = require('commander');
-const chalk = require('chalk');
 const path = require('path');
 const optimizer = require('../src/index');
 
@@ -13,14 +12,15 @@ program
   .action(async (targetDir) => {
     try {
       const resolvedPath = path.resolve(targetDir);
-      console.log(chalk.blue.bold('\n🚀 Image Video Optimizer\n'));
-      console.log(chalk.gray(`Target directory: ${resolvedPath}`));
+      console.log('\n🚀 Image Video Optimizer\n');
+      console.log('Target directory: ' + resolvedPath);
       
       await optimizer.optimize(resolvedPath);
       
-      console.log(chalk.green.bold('\n✅ Optimization complete!\n'));
+      console.log('\n✅ Optimization complete!\n');
     } catch (error) {
-      console.error(chalk.red.bold('\n❌ Error:\n'), chalk.red(error.message));
+      console.error('\n❌ Error:\n');
+      console.error(error.message);
       process.exit(1);
     }
   });

package/package.json

@@ -1,43 +1,36 @@
 {
   "name": "image-video-optimizer",
-  "version": "2.0.3",
-  "description": "A CLI tool to optimize images and videos by resizing and converting them according to configuration",
+  "version": "3.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": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "start": "node bin/cli.js"
+    "start": "node bin/cli.js",
+    "test": "echo \"Error: no test specified\" && exit 1"
   },
   "keywords": [
     "image",
     "video",
     "optimizer",
-    "resize",
-    "convert",
-    "batch",
+    "compress",
+    "ffmpeg",
     "cli"
   ],
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "sharp": "^0.33.0",
-    "fluent-ffmpeg": "^2.1.3",
-    "commander": "^11.1.0",
-    "chalk": "^5.3.0",
-    "ora": "^8.0.1"
-  },
-  "devDependencies": {
-    "ffmpeg-static": "^5.2.0",
-    "ffprobe-static": "^3.1.0"
+    "commander": "^11.0.0",
+    "sharp": "^0.32.0",
+    "fluent-ffmpeg": "^2.1.2"
   },
+  "devDependencies": {},
   "engines": {
     "node": ">=14.0.0"
   },
-  "preferGlobal": true,
   "repository": {
     "type": "git",
-    "url": "https://github.com/yourusername/image-video-optimizer.git"
+    "url": "https://git.siliconpin.com/kar/image-video-optimezer-npm-cli"
   }
 }

package/src/fileSearcher.js

@@ -1,51 +1,99 @@
-const fs = require('fs');
+const fs = require('fs').promises;
 const path = require('path');
 
-const SUPPORTED_IMAGES = ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff', '.webp'];
-const SUPPORTED_VIDEOS = ['.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'];
 
 /**
  * Recursively search for media files in a directory
- * @param {string} dirPath - Directory path to search
- * @returns {Promise<{images: Array, videos: Array}>} Found media files
+ * @param {string} dirPath - Starting directory path
+ * @param {Object} options - Search options
+ * @returns {Promise<Object>} Object with images and videos arrays
  */
-async function searchMediaFiles(dirPath) {
+async function searchMediaFiles(dirPath, options = {}) {
   const images = [];
   const videos = [];
+  const verbose = options.verbose || false;
 
   async function walk(currentPath) {
     try {
-      const files = await fs.promises.readdir(currentPath);
-
-      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);
+      const entries = await fs.readdir(currentPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(currentPath, entry.name);
+
+        try {
+          if (entry.isDirectory()) {
+            // Recursively walk subdirectories
+            await walk(fullPath);
+          } else if (entry.isFile()) {
+            const ext = path.extname(entry.name).toLowerCase().slice(1);
+
+            if (SUPPORTED_IMAGES.includes(ext)) {
+              images.push(fullPath);
+              if (verbose) {
+                console.log(`  Found image: ${fullPath}`);
+              }
+            } else if (SUPPORTED_VIDEOS.includes(ext)) {
+              videos.push(fullPath);
+              if (verbose) {
+                console.log(`  Found video: ${fullPath}`);
+              }
+            }
+          }
+        } catch (error) {
+          if (verbose) {
+            console.warn(`  Warning: Could not process ${fullPath}: ${error.message}`);
           }
         }
       }
     } catch (error) {
-      console.warn(`Warning: Could not read directory ${currentPath}: ${error.message}`);
+      if (verbose) {
+        console.warn(`  Warning: Could not read directory ${currentPath}: ${error.message}`);
+      }
     }
   }
 
   await walk(dirPath);
 
-  return { images, videos };
+  return {
+    images,
+    videos,
+    total: images.length + videos.length
+  };
+}
+
+/**
+ * Get file size in bytes
+ * @param {string} filePath - Path to file
+ * @returns {Promise<number>} File size in bytes
+ */
+async function getFileSize(filePath) {
+  try {
+    const stats = await fs.stat(filePath);
+    return stats.size;
+  } catch (error) {
+    throw new Error(`Could not get file size for ${filePath}: ${error.message}`);
+  }
+}
+
+/**
+ * Get human-readable file size
+ * @param {number} bytes - Size in bytes
+ * @returns {string} Human-readable size
+ */
+function formatFileSize(bytes) {
+  if (bytes === 0) return '0 Bytes';
+  const k = 1024;
+  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + ' ' + sizes[i];
 }
 
 module.exports = {
   searchMediaFiles,
+  getFileSize,
+  formatFileSize,
   SUPPORTED_IMAGES,
   SUPPORTED_VIDEOS
 };

package/src/imageProcessor.js

@@ -1,7 +1,6 @@
-const sharp = require('sharp');
 const fs = require('fs');
+const sharp = require('sharp');
 const path = require('path');
-const chalk = require('chalk');
 
 /**
  * Process a single image file
@@ -78,7 +77,7 @@ async function processImage(imagePath, config) {
         success: true,
         originalSize,
         optimizedSize,
-        message: `${chalk.green('✓')} ${action} ${sizeInfo}`,
+        message: `✓ ${action} ${sizeInfo}`,
         filePath: finalPath
       };
     } else {
@@ -89,7 +88,7 @@ async function processImage(imagePath, config) {
         success: false,
         originalSize,
         optimizedSize,
-        message: `${chalk.yellow('○')} ${path.basename(imagePath)} - Already optimized (${(originalSize / 1024).toFixed(1)}KB)`,
+        message: `○ ${path.basename(imagePath)} - Already optimized (${(originalSize / 1024).toFixed(1)}KB)`,
         filePath: imagePath
       };
     }
@@ -98,7 +97,7 @@ async function processImage(imagePath, config) {
       success: false,
       originalSize: 0,
       optimizedSize: 0,
-      message: `${chalk.red('✗')} ${path.basename(imagePath)} - Error: ${error.message}`,
+      message: `✗ ${path.basename(imagePath)} - Error: ${error.message}`,
       error: true
     };
   }

package/src/index.js

@@ -1,6 +1,5 @@
 const fs = require('fs');
 const path = require('path');
-const chalk = require('chalk');
 const fileSearcher = require('./fileSearcher');
 const imageProcessor = require('./imageProcessor');
 const videoProcessor = require('./videoProcessor');
@@ -49,7 +48,7 @@ function parseConfig(configPath) {
 
     return config;
   } catch (error) {
-    console.warn(chalk.yellow(`Warning: Could not parse config file: ${error.message}`));
+    console.warn(`Warning: Could not parse config file: ${error.message}`);
     return DEFAULT_CONFIG;
   }
 }
@@ -73,9 +72,9 @@ video_encode=${DEFAULT_CONFIG.video_encode}           # Video encoding format
 
     try {
       fs.writeFileSync(configPath, configContent);
-      console.log(chalk.cyan(`📝 Created default config: ${CONFIG_FILENAME}`));
+      console.log(`📝 Created default config: ${CONFIG_FILENAME}`);
     } catch (error) {
-      console.warn(chalk.yellow(`Warning: Could not create config file: ${error.message}`));
+      console.warn(`Warning: Could not create config file: ${error.message}`);
     }
   }
 }
@@ -97,20 +96,20 @@ async function optimize(targetDir) {
   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`));
+  console.log('Configuration:');
+  console.log(`  Image Max Width: ${config.img_max_width}px`);
+  console.log(`  Image Format: ${config.img_format}`);
+  console.log(`  Video Max Width: ${config.video_max_width}px`);
+  console.log(`  Video Encode: ${config.video_encode}\n`);
 
   // Search for media files
-  console.log(chalk.blue('🔍 Searching for media files...'));
+  console.log('🔍 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`));
+  console.log(`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.'));
+    console.log('No media files found to optimize.');
     return;
   }
 
@@ -120,7 +119,7 @@ async function optimize(targetDir) {
 
   // Process images
   if (images.length > 0) {
-    console.log(chalk.blue('📷 Processing images...'));
+    console.log('📷 Processing images...');
     for (const imagePath of images) {
       const result = await imageProcessor.processImage(imagePath, config);
       console.log(result.message);
@@ -137,7 +136,7 @@ async function optimize(targetDir) {
 
   // Process videos
   if (videos.length > 0) {
-    console.log(chalk.blue('🎬 Processing videos...'));
+    console.log('🎬 Processing videos...');
     for (const videoPath of videos) {
       const result = await videoProcessor.processVideo(videoPath, config);
       console.log(result.message);
@@ -153,16 +152,16 @@ async function optimize(targetDir) {
   }
 
   // Print summary
-  console.log(chalk.blue('📊 Summary:'));
-  console.log(chalk.gray(`  Files optimized: ${successCount}/${images.length + videos.length}`));
+  console.log('📊 Summary:');
+  console.log(`  Files optimized: ${successCount}/${images.length + videos.length}`);
   
   if (totalOriginalSize > 0) {
     const savedSize = totalOriginalSize - totalOptimizedSize;
     const savedPercent = ((savedSize / totalOriginalSize) * 100).toFixed(1);
     
-    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}%)`));
+    console.log(`  Original size: ${(totalOriginalSize / 1024 / 1024).toFixed(2)}MB`);
+    console.log(`  Optimized size: ${(totalOptimizedSize / 1024 / 1024).toFixed(2)}MB`);
+    console.log(`  Space saved: ${(savedSize / 1024 / 1024).toFixed(2)}MB (${savedPercent}%)`);
   }
 }
 

package/src/videoProcessor.js

@@ -1,141 +1,134 @@
 const ffmpeg = require('fluent-ffmpeg');
-const fs = require('fs');
 const path = require('path');
-const chalk = require('chalk');
+const fs = require('fs').promises;
+
+// Set ffmpeg and ffprobe paths if using static binaries
+try {
+  const ffmpegStatic = require('ffmpeg-static');
+  const ffprobeStatic = require('ffprobe-static');
+  ffmpeg.setFfmpegPath(ffmpegStatic);
+  ffmpeg.setFfprobePath(ffprobeStatic.path);
+} catch (error) {
+  // Fallback to system ffmpeg/ffprobe if static binaries not available
+  console.warn('Note: ffmpeg-static not found, using system ffmpeg/ffprobe');
+}
 
 /**
- * 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}>}
+ * Get video metadata (width, height, duration, etc.)
+ * @param {string} videoPath - Path to video file
+ * @returns {Promise<Object>} Video metadata
  */
-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
+function getVideoMetadata(videoPath) {
+  return new Promise((resolve, reject) => {
+    ffmpeg.ffprobe(videoPath, (err, metadata) => {
+      if (err) {
+        reject(new Error(`Could not read video metadata: ${err.message}`));
+      } else {
+        const videoStream = metadata.streams.find(s => s.codec_type === 'video');
+        if (videoStream) {
+          resolve({
+            width: videoStream.width,
+            height: videoStream.height,
+            duration: metadata.format.duration,
+            codec: videoStream.codec_name,
+            bitrate: metadata.format.bit_rate
           });
+        } else {
+          reject(new Error('No video stream found in file'));
         }
+      }
+    });
+  });
+}
+
+/**
+ * Process (resize and encode) a video
+ * @param {string} inputPath - Path to input video
+ * @param {string} outputPath - Path to output video
+ * @param {Object} config - Configuration object
+ * @returns {Promise<Object>} Processing result
+ */
+function processVideo(inputPath, outputPath, config) {
+  return new Promise(async (resolve) => {
+    try {
+      const metadata = await getVideoMetadata(inputPath);
+      const currentWidth = metadata.width;
+      const currentHeight = metadata.height;
+      const maxWidth = parseInt(config.video_max_width) || 720;
+      const videoEncode = config.video_encode || 'h264';
 
-        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');
+      let command = ffmpeg(inputPath)
+        .videoCodec(videoEncode)
+        .audioCodec('aac')
+        .audioChannels(2)
+        .audioFrequency(48000)
+        .format('mp4');
 
-        // Create ffmpeg command
-        // Map codec names to ffmpeg codec names
-        const codecMap = {
-          'h264': 'libx264',
-          'h265': 'libx265',
-          'vp8': 'libvpx',
-          'vp9': 'libvpx-vp9'
-        };
+      // Only resize if video is wider than max_width
+      if (currentWidth > maxWidth) {
+        const scaleFactor = maxWidth / currentWidth;
+        const newHeight = Math.round(currentHeight * scaleFactor);
         
-        const outputCodec = codecMap[config.video_encode.toLowerCase()] || config.video_encode || 'libx264';
+        // Ensure dimensions are even (required for most codecs)
+        const finalHeight = newHeight % 2 === 0 ? newHeight : newHeight - 1;
+        const finalWidth = maxWidth % 2 === 0 ? maxWidth : maxWidth - 1;
         
-        const command = ffmpeg(videoPath)
-          .videoCodec(outputCodec)
-          .size(`${config.video_max_width}x?`)
-          .outputOptions([
-            '-preset fast',
-            '-crf 28',
-            '-c:a aac'  // Use AAC for audio (widely compatible)
-          ])
-          .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);
-                });
-              });
+        command = command.size(`${finalWidth}x${finalHeight}`);
+      }
 
-              const optimizedSize = tmpStat.size;
+      // Set bitrate based on resolution to maintain quality while reducing size
+      const bitrate = currentWidth > maxWidth ? '2000k' : '3000k';
+      command = command.videoBitrate(bitrate);
 
-              if (optimizedSize < originalSize) {
-                // Remove original and rename temp to final
-                await fs.promises.unlink(videoPath);
-                await fs.promises.rename(tmpPath, finalPath);
-
-                resolve({
-                  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 {
-                // Remove temp file if not smaller
-                await fs.promises.unlink(tmpPath);
+      command
+        .on('start', (cmdline) => {
+          // Processing started
+        })
+        .on('end', () => {
+          resolve({
+            success: true,
+            inputPath,
+            outputPath,
+            originalWidth: currentWidth,
+            originalHeight: currentHeight,
+            resized: currentWidth > maxWidth,
+            duration: metadata.duration
+          });
+        })
+        .on('error', (err) => {
+          resolve({
+            success: false,
+            inputPath,
+            error: err.message
+          });
+        })
+        .output(outputPath)
+        .run();
 
-                resolve({
-                  success: false,
-                  originalSize,
-                  optimizedSize,
-                  message: `${chalk.yellow('○')} ${path.basename(videoPath)} - Already optimized (${(originalSize / 1024 / 1024).toFixed(1)}MB)`,
-                  filePath: videoPath
-                });
-              }
-            } 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)`;
-              } else if (err.message.includes('Conversion failed') || err.message.includes('exited with code')) {
-                errorMsg = `Video encoding failed. Try a different codec in config: video_encode=h265 or video_encode=vp8`;
-              }
-              
-              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
+        inputPath,
+        error: error.message
       });
     }
   });
 }
 
+/**
+ * Check if ffmpeg is available on the system
+ * @returns {Promise<boolean>} True if ffmpeg is available
+ */
+function isFfmpegAvailable() {
+  return new Promise((resolve) => {
+    ffmpeg.getAvailableFormats((err) => {
+      resolve(!err);
+    });
+  });
+}
+
 module.exports = {
-  processVideo
+  processVideo,
+  getVideoMetadata,
+  isFfmpegAvailable
 };