image-video-optimizer 1.0.0

package/.image-video-optimizer.conf

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

package/README.md

@@ -0,0 +1,144 @@
+# Image Video Optimizer
+
+A powerful CLI tool to optimize images and videos with configurable resize and compression settings.
+
+## Features
+
+- **Image Optimization**: Resize and convert images to specified formats
+- **Video Optimization**: Resize videos and encode to specified formats
+- **Configurable Settings**: Use `.image-video-optimizer.conf` files for custom settings
+- **Smart Compression**: Only keeps optimized files if compression is effective (>1%)
+- **Recursive Search**: Finds all media files in subdirectories
+- **Detailed Logging**: Shows processing progress and summary statistics
+
+## Installation
+
+```bash
+npm install -g image-video-optimizer
+```
+
+## Usage
+
+### Basic Usage
+
+```bash
+image-video-optimizer /path/to/directory
+```
+
+### Options
+
+```bash
+image-video-optimizer /path/to/directory [options]
+```
+
+- `<directory>`: Target directory to optimize (required)
+- `-d, --dry-run`: Show what would be processed without making changes
+- `-v, --verbose`: Enable verbose logging
+- `-V, --version`: Show version number
+- `-h, --help`: Show help
+
+## Configuration
+
+Create a `.image-video-optimizer.conf` file in your target directory to customize settings:
+
+```ini
+# Image settings
+img_max_width=1080          # Maximum width for images (pixels)
+img_format=jpg              # Target format for image conversion
+
+# Video settings
+video_max_width=720         # Maximum width for videos (pixels)
+video_encode=h264           # Video encoding format
+```
+
+### Default Configuration
+
+If no configuration file is found, these defaults are used:
+- `img_max_width`: 1080
+- `img_format`: jpg
+- `video_max_width`: 720
+- `video_encode`: h264
+
+## Supported Formats
+
+### Images
+- Input: jpg, jpeg, png, gif, bmp, tiff, webp
+- Output: jpg, png, webp (configurable)
+
+### Videos
+- Input: avi, mov, wmv, flv, webm, mkv, m4v, mp4
+- Output: mp4 (with configurable encoding)
+
+## Processing Logic
+
+### Image Processing
+1. Searches for image files recursively
+2. Checks if image width exceeds `img_max_width`
+3. Resizes if necessary while maintaining aspect ratio
+4. Converts to target format if different
+5. Compares file sizes and keeps optimized version only if compression > 1%
+
+### Video Processing
+1. Searches for video files recursively
+2. Checks if video width exceeds `video_max_width`
+3. Resizes if necessary while maintaining aspect ratio
+4. Encodes to target format (default: H.264)
+5. Converts to MP4 format
+6. Compares file sizes and keeps optimized version only if compression > 1%
+
+## Examples
+
+### Optimize a directory with default settings
+```bash
+image-video-optimizer ./photos
+```
+
+### Dry run to see what would be processed
+```bash
+image-video-optimizer ./photos --dry-run
+```
+
+### Custom configuration
+Create `.image-video-optimizer.conf`:
+```ini
+img_max_width=1920
+img_format=webp
+video_max_width=1080
+video_encode=h265
+```
+
+Then run:
+```bash
+image-video-optimizer ./media
+```
+
+## Dependencies
+
+- [sharp](https://sharp.pixelplumbing.com/) - Image processing
+- [fluent-ffmpeg](https://github.com/fluent-ffmpeg/node-fluent-ffmpeg) - Video processing
+- [commander](https://github.com/tj/commander.js) - CLI framework
+- [chalk](https://github.com/chalk/chalk) - Terminal styling
+
+## System Requirements
+
+- Node.js >= 14.0.0
+- FFmpeg (for video processing)
+
+### Installing FFmpeg
+
+**Ubuntu/Debian:**
+```bash
+sudo apt update && sudo apt install ffmpeg
+```
+
+**macOS:**
+```bash
+brew install ffmpeg
+```
+
+**Windows:**
+Download from [ffmpeg.org](https://ffmpeg.org/download.html) and add to PATH
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const path = require('path');
+const chalk = require('chalk');
+const ImageVideoOptimizer = require('../src/index');
+
+const program = new Command();
+
+program
+  .name('image-video-optimizer')
+  .description('CLI tool to optimize images and videos with configurable resize and compression settings')
+  .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) => {
+    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;
+      }
+      
+      await optimizer.optimize();
+      
+    } catch (error) {
+      console.error(chalk.red('Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/licence.txt

@@ -0,0 +1,6 @@
+proprietary license restricts to share or gain knowledge, GPL or GNU license is the opposite, we have MIT and BSD that benefits conqueror company (* still using bsd under the hood and * using purchased qdos)
+
+i hope rest of the people will become humanbeings. knowledge, experience, information will be free[please dont force to reverse eng., its better not to have any software or hardware with secret sauce]. A humanbeing without a driving license is much better than a person having a driving license, i wonder govt. dont provide a license to own a computer system but i need a license to run os on it?
+the english word free is not enough, let me put this way : a book can have a price not the content and i must be able to share it.
+
+praise to mukteshwar, hope one day licence raaj will be over till my work is under nirvána license and the terms and conditions are listed below

package/package.json

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

package/src/config.js

@@ -0,0 +1,57 @@
+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;

package/src/fileSearcher.js

@@ -0,0 +1,75 @@
+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'];
+  }
+
+  findMediaFiles() {
+    const imageFiles = this.findFilesByExtensions(this.imageExtensions);
+    const videoFiles = this.findFilesByExtensions(this.videoExtensions);
+    
+    return {
+      images: imageFiles,
+      videos: videoFiles
+    };
+  }
+
+  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);
+            }
+          }
+        }
+      } 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);
+  }
+
+  isVideoFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase().slice(1);
+    return this.videoExtensions.includes(ext);
+  }
+
+  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;
+  }
+}
+
+module.exports = FileSearcher;

package/src/imageProcessor.js

@@ -0,0 +1,105 @@
+const sharp = require('sharp');
+const fs = require('fs');
+const path = require('path');
+
+class ImageProcessor {
+  constructor(config) {
+    this.config = config;
+  }
+
+  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' };
+      }
+
+      const outputPath = this.generateOutputPath(inputPath, targetFormat);
+      
+      // Check if output path would be same as input path
+      if (outputPath === inputPath) {
+        console.log(`Output path same as input, skipping: ${path.basename(inputPath)}`);
+        return { processed: false, reason: 'same_path' };
+      }
+      
+      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(outputPath);
+      
+      const compressionResult = this.checkCompression(inputPath, outputPath);
+      
+      if (compressionResult.effective) {
+        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(outputPath);
+        return { processed: false, reason: 'ineffective_compression' };
+      }
+      
+    } catch (error) {
+      console.error(`Error processing image ${inputPath}:`, error.message);
+      return { processed: false, error: error.message };
+    }
+  }
+
+  generateOutputPath(inputPath, targetFormat) {
+    const parsedPath = path.parse(inputPath);
+    return path.join(parsedPath.dir, `${parsedPath.name}.${targetFormat}`);
+  }
+
+  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
+    };
+  }
+}
+
+module.exports = ImageProcessor;

package/src/index.js

@@ -0,0 +1,141 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+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: []
+    };
+  }
+
+  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('');
+
+    if (!fs.existsSync(this.targetDir)) {
+      console.error(chalk.red(`Error: Target directory does not exist: ${this.targetDir}`));
+      return;
+    }
+
+    const mediaFiles = this.fileSearcher.findMediaFiles();
+    
+    console.log(chalk.yellow(`Found ${mediaFiles.images.length} images and ${mediaFiles.videos.length} videos`));
+    console.log('');
+
+    if (mediaFiles.images.length === 0 && mediaFiles.videos.length === 0) {
+      console.log(chalk.green('No media files found to process.'));
+      return;
+    }
+
+    await this.processImages(mediaFiles.images);
+    await this.processVideos(mediaFiles.videos);
+    
+    this.printSummary();
+  }
+
+  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 });
+      }
+    }
+    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 });
+      }
+    }
+    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)}`);
+    
+    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!'));
+  }
+}
+
+module.exports = ImageVideoOptimizer;

package/src/videoProcessor.js

@@ -0,0 +1,128 @@
+const ffmpeg = require('fluent-ffmpeg');
+const ffmpegInstaller = require('@ffmpeg-installer/ffmpeg');
+ffmpeg.setFfmpegPath(ffmpegInstaller.path);
+const fs = require('fs');
+const path = require('path');
+
+class VideoProcessor {
+  constructor(config) {
+    this.config = config;
+  }
+
+  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);
+        
+        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 ffmpegCommand = ffmpeg(inputPath);
+          
+          if (needsResize) {
+            const newHeight = Math.round((maxWidth / videoStream.width) * videoStream.height);
+            ffmpegCommand = ffmpegCommand.videoFilters(`scale=${maxWidth}:${newHeight}`);
+            console.log(`Resizing to: ${maxWidth}x${newHeight}`);
+          }
+          
+          switch (encodeFormat.toLowerCase()) {
+            case 'h264':
+              ffmpegCommand = ffmpegCommand.videoCodec('libx264').audioCodec('aac');
+              break;
+            case 'h265':
+              ffmpegCommand = ffmpegCommand.videoCodec('libx265').audioCodec('aac');
+              break;
+            case 'vp9':
+              ffmpegCommand = ffmpegCommand.videoCodec('libvpx-vp9').audioCodec('libvorbis');
+              break;
+            default:
+              ffmpegCommand = ffmpegCommand.videoCodec('libx264').audioCodec('aac');
+          }
+          
+          ffmpegCommand
+            .outputOptions('-crf 23')
+            .outputOptions('-preset medium')
+            .format('mp4')
+            .output(outputPath)
+            .on('end', () => {
+              const compressionResult = this.checkCompression(inputPath, outputPath);
+              
+              if (compressionResult.effective) {
+                console.log(`✓ Processed: ${path.basename(inputPath)} (${compressionResult.compressionPercent}% reduction)`);
+                resolve({
+                  processed: true,
+                  outputPath,
+                  originalSize: compressionResult.originalSize,
+                  newSize: compressionResult.newSize,
+                  compressionPercent: compressionResult.compressionPercent
+                });
+              } else {
+                console.log(`✗ Ineffective compression, keeping original: ${path.basename(inputPath)}`);
+                fs.unlinkSync(outputPath);
+                resolve({ processed: false, reason: 'ineffective_compression' });
+              }
+            })
+            .on('error', (err) => {
+              console.error(`Error processing video ${inputPath}:`, err.message);
+              if (fs.existsSync(outputPath)) {
+                fs.unlinkSync(outputPath);
+              }
+              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
+    };
+  }
+}
+
+module.exports = VideoProcessor;