image-video-optimizer 2.0.3 → 3.0.1

package/bin/cli.js

@@ -1,26 +1,26 @@
 #!/usr/bin/env node
 
 const { program } = require('commander');
-const chalk = require('chalk');
 const path = require('path');
 const optimizer = require('../src/index');
 
 program
   .name('image-video-optimizer')
   .description('Optimize and compress images and videos in a directory')
-  .version('1.0.0')
+  .version('3.0.1')
   .argument('[target-dir]', 'Target directory to optimize (default: current directory)', process.cwd())
   .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.1",
+  "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,7 +1,6 @@
 const ffmpeg = require('fluent-ffmpeg');
 const fs = require('fs');
 const path = require('path');
-const chalk = require('chalk');
 
 /**
  * Process a single video file
@@ -18,7 +17,7 @@ async function processVideo(videoPath, config) {
             success: false,
             originalSize: 0,
             optimizedSize: 0,
-            message: `${chalk.red('✗')} ${path.basename(videoPath)} - Cannot access file`,
+            message: `✗ ${path.basename(videoPath)} - Cannot access file`,
             error: true
           });
         }
@@ -72,7 +71,7 @@ async function processVideo(videoPath, config) {
                   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)`,
+                  message: `✓ ${path.basename(videoPath)} → ${path.basename(finalPath)} (${(originalSize / 1024 / 1024).toFixed(1)}MB → ${(optimizedSize / 1024 / 1024).toFixed(1)}MB)`,
                   filePath: finalPath
                 });
               } else {
@@ -83,7 +82,7 @@ async function processVideo(videoPath, config) {
                   success: false,
                   originalSize,
                   optimizedSize,
-                  message: `${chalk.yellow('○')} ${path.basename(videoPath)} - Already optimized (${(originalSize / 1024 / 1024).toFixed(1)}MB)`,
+                  message: `○ ${path.basename(videoPath)} - Already optimized (${(originalSize / 1024 / 1024).toFixed(1)}MB)`,
                   filePath: videoPath
                 });
               }
@@ -92,7 +91,7 @@ async function processVideo(videoPath, config) {
                 success: false,
                 originalSize,
                 optimizedSize: 0,
-                message: `${chalk.red('✗')} ${path.basename(videoPath)} - Post-processing error: ${error.message}`,
+                message: `✗ ${path.basename(videoPath)} - Post-processing error: ${error.message}`,
                 error: true
               });
             }
@@ -117,7 +116,7 @@ async function processVideo(videoPath, config) {
                 success: false,
                 originalSize,
                 optimizedSize: 0,
-                message: `${chalk.red('✗')} ${path.basename(videoPath)} - ${errorMsg}`,
+                message: `✗ ${path.basename(videoPath)} - ${errorMsg}`,
                 error: true
               });
             });
@@ -129,7 +128,7 @@ async function processVideo(videoPath, config) {
         success: false,
         originalSize: 0,
         optimizedSize: 0,
-        message: `${chalk.red('✗')} ${path.basename(videoPath)} - Error: ${error.message}`,
+        message: `✗ ${path.basename(videoPath)} - Error: ${error.message}`,
         error: true
       });
     }