image-video-optimizer 3.0.9 → 3.3.3

package/bin/cli.js

@@ -1,21 +1,33 @@
 #!/usr/bin/env node
 
-const { program } = require('commander');
+const { Command } = require('commander');
 const path = require('path');
-const optimizer = require('../src/index');
+const { optimize, resetStatus } = require('../src/index');
+
+const program = new Command();
 
 program
   .name('image-video-optimizer')
-  .description('Optimize and compress images and videos in a directory')
-  .version('3.0.5')
-  .argument('[target-dir]', 'Target directory to optimize (default: current directory)', process.cwd())
-  .action(async (targetDir) => {
+  .description('CLI tool to optimize and compress images, videos, audio, and PDFs')
+  .version('3.2.0');
+
+program
+  .argument('[directory]', 'Target directory to optimize', process.cwd())
+  .option('-r, --reset', 'Reset status file and start fresh')
+  .option('-v, --verbose', 'Show detailed processing information')
+  .action(async (directory, options) => {
     try {
-      const resolvedPath = path.resolve(targetDir);
+      const targetDir = path.resolve(directory);
+      
+      if (options.reset) {
+        resetStatus(targetDir);
+        return;
+      }
+      
       console.log('\n🚀 Image Video Optimizer\n');
-      console.log('Target directory: ' + resolvedPath);
+      console.log('Target directory: ' + targetDir);
       
-      await optimizer.optimize(resolvedPath);
+      await optimize(targetDir, options.verbose);
       
       console.log('\n✅ Optimization complete!\n');
     } catch (error) {

package/package.json

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

package/src/audioProcessor.js

@@ -0,0 +1,99 @@
+const ffmpeg = require('fluent-ffmpeg');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Process audio file with compression
+ * @param {string} audioPath - Path to audio file
+ * @param {object} config - Configuration object
+ * @returns {Promise<object>} Processing result
+ */
+async function processAudio(audioPath, config = {}) {
+  return new Promise((resolve, reject) => {
+    const originalSize = fs.statSync(audioPath).size;
+    const parsedPath = path.parse(audioPath);
+    const outputExt = config.audio_ext || 'mp3';
+    const finalPath = path.join(parsedPath.dir, `${parsedPath.name}.${outputExt}`);
+    
+    // Check if already in target format and no processing needed
+    if (path.extname(audioPath).toLowerCase().slice(1) === outputExt) {
+      // For now, assume audio files are already optimized if they're in target format
+      resolve({
+        success: false,
+        originalSize,
+        optimizedSize: originalSize,
+        message: `○ ${path.basename(audioPath)} - Already optimized (${(originalSize / 1024 / 1024).toFixed(1)}MB)`,
+        filePath: audioPath
+      });
+      return;
+    }
+    
+    // Use temporary file to avoid conflicts
+    const tmpPath = path.join(parsedPath.dir, `${parsedPath.name}_tmp.${outputExt}`);
+
+    const command = ffmpeg(audioPath)
+      .audioCodec('libmp3lame')
+      .audioChannels(1)
+      .audioFrequency(16000)
+      .audioBitrate('32k')
+      .outputOptions([
+        '-ar 16000',
+        '-q:a 9'
+      ])
+      .output(tmpPath);
+
+    command
+      .on('end', async () => {
+        try {
+          // Wait a bit for the file to be fully written
+          await new Promise(resolve => setTimeout(resolve, 100));
+          
+          const tmpStat = await new Promise((res, rej) => {
+            fs.stat(tmpPath, (err, stat) => {
+              if (err) rej(err);
+              else res(stat);
+            });
+          });
+
+          const optimizedSize = tmpStat.size;
+
+          // Always replace with compressed version for audio
+          await fs.promises.unlink(audioPath);
+          await fs.promises.rename(tmpPath, finalPath);
+
+          resolve({
+            success: true,
+            originalSize,
+            optimizedSize,
+            message: `✓ ${path.basename(audioPath)} → ${path.basename(finalPath)} (${(originalSize / 1024 / 1024).toFixed(1)}MB → ${(optimizedSize / 1024 / 1024).toFixed(1)}MB)`,
+            filePath: finalPath
+          });
+        } catch (error) {
+          // Clean up temp file on error
+          try {
+            await fs.promises.unlink(tmpPath);
+          } catch (cleanupError) {
+            // Ignore cleanup errors
+          }
+          reject(error);
+        }
+      })
+      .on('error', async (error) => {
+        // Clean up temp file on error
+        try {
+          await fs.promises.unlink(tmpPath);
+        } catch (cleanupError) {
+          // Ignore cleanup errors
+        }
+        
+        const errorMessage = error.message || 'Unknown error';
+        reject(new Error(`Audio processing failed for ${path.basename(audioPath)}: ${errorMessage}`));
+      });
+
+    command.run();
+  });
+}
+
+module.exports = {
+  processAudio
+};

package/src/fileSearcher.js

@@ -3,6 +3,8 @@ 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_AUDIO = ['mp3', 'wav', 'flac', 'aac', 'ogg', 'm4a'];
+const SUPPORTED_DOCUMENTS = ['pdf'];
 
 /**
  * Recursively search for media files in a directory
@@ -13,6 +15,8 @@ const SUPPORTED_VIDEOS = ['avi', 'mov', 'wmv', 'flv', 'webm', 'mkv', 'm4v', 'mp4
 async function searchMediaFiles(dirPath, options = {}) {
   const images = [];
   const videos = [];
+  const audio = [];
+  const documents = [];
   const verbose = options.verbose || false;
 
   async function walk(currentPath) {
@@ -39,6 +43,16 @@ async function searchMediaFiles(dirPath, options = {}) {
               if (verbose) {
                 console.log(`  Found video: ${fullPath}`);
               }
+            } else if (SUPPORTED_AUDIO.includes(ext)) {
+              audio.push(fullPath);
+              if (verbose) {
+                console.log(`  Found audio: ${fullPath}`);
+              }
+            } else if (SUPPORTED_DOCUMENTS.includes(ext)) {
+              documents.push(fullPath);
+              if (verbose) {
+                console.log(`  Found document: ${fullPath}`);
+              }
             }
           }
         } catch (error) {
@@ -59,7 +73,9 @@ async function searchMediaFiles(dirPath, options = {}) {
   return {
     images,
     videos,
-    total: images.length + videos.length
+    audio,
+    documents,
+    total: images.length + videos.length + audio.length + documents.length
   };
 }
 
@@ -95,5 +111,7 @@ module.exports = {
   getFileSize,
   formatFileSize,
   SUPPORTED_IMAGES,
-  SUPPORTED_VIDEOS
+  SUPPORTED_VIDEOS,
+  SUPPORTED_AUDIO,
+  SUPPORTED_DOCUMENTS
 };

package/src/index.js

@@ -3,15 +3,20 @@ const path = require('path');
 const fileSearcher = require('./fileSearcher');
 const imageProcessor = require('./imageProcessor');
 const videoProcessor = require('./videoProcessor');
+const audioProcessor = require('./audioProcessor');
+const pdfProcessor = require('./pdfProcessor');
 
 const DEFAULT_CONFIG = {
   img_max_width: 1080,
   img_format: 'jpg',
   video_max_width: 720,
-  video_encode: 'h264'
+  video_encode: 'h264',
+  audio_ext: 'mp3',
+  pdf_compress: true
 };
 
 const CONFIG_FILENAME = '.image-video-optimizer.conf';
+const STATUS_FILENAME = '.image-video-optimizer-status.json';
 
 /**
  * Parse configuration file
@@ -69,6 +74,8 @@ img_max_width=${DEFAULT_CONFIG.img_max_width}          # Maximum width for image
 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
+audio_ext=${DEFAULT_CONFIG.audio_ext}                 # Audio extension for audio files
+pdf_compress=${DEFAULT_CONFIG.pdf_compress}           # Enable/disable PDF compression
 `;
 
     try {
@@ -80,11 +87,101 @@ video_encode=${DEFAULT_CONFIG.video_encode}           # Video encoding format
   }
 }
 
+/**
+ * Load status file
+ * @param {string} targetDir - Target directory
+ * @returns {object} Status object
+ */
+function loadStatus(targetDir) {
+  const statusPath = path.join(targetDir, STATUS_FILENAME);
+  try {
+    if (fs.existsSync(statusPath)) {
+      const content = fs.readFileSync(statusPath, 'utf8');
+      return JSON.parse(content);
+    }
+  } catch (error) {
+    console.warn(`Warning: Could not read status file: ${error.message}`);
+  }
+  
+  // Create initial status file if it doesn't exist
+  const initialStatus = {
+    processed: [],
+    failed: [],
+    startTime: null,
+    lastRun: null
+  };
+  
+  try {
+    fs.writeFileSync(statusPath, JSON.stringify(initialStatus, null, 2));
+  } catch (error) {
+    console.warn(`Warning: Could not create status file: ${error.message}`);
+  }
+  
+  return initialStatus;
+}
+
+/**
+ * Save status file
+ * @param {string} targetDir - Target directory
+ * @param {object} status - Status object
+ */
+function saveStatus(targetDir, status) {
+  const statusPath = path.join(targetDir, STATUS_FILENAME);
+  try {
+    status.lastRun = new Date().toISOString();
+    fs.writeFileSync(statusPath, JSON.stringify(status, null, 2));
+  } catch (error) {
+    console.warn(`Warning: Could not save status file: ${error.message}`);
+  }
+}
+
+/**
+ * Check if file was already processed
+ * @param {string} filePath - File path to check
+ * @param {object} status - Status object
+ * @returns {boolean} True if already processed
+ */
+function isProcessed(filePath, status) {
+  return status.processed.includes(filePath);
+}
+
+/**
+ * Mark file as processed
+ * @param {string} filePath - File path to mark
+ * @param {object} status - Status object
+ * @param {string} targetDir - Target directory for saving status
+ */
+function markProcessed(filePath, status, targetDir) {
+  if (!status.processed.includes(filePath)) {
+    status.processed.push(filePath);
+    // Save status immediately after each file is processed
+    saveStatus(targetDir, status);
+  }
+}
+
+/**
+ * Mark file as failed
+ * @param {string} filePath - File path to mark
+ * @param {string} error - Error message
+ * @param {object} status - Status object
+ * @param {string} targetDir - Target directory for saving status
+ */
+function markFailed(filePath, error, status, targetDir) {
+  status.failed.push({
+    file: filePath,
+    error: error,
+    timestamp: new Date().toISOString()
+  });
+  // Save status immediately after each file fails
+  saveStatus(targetDir, status);
+}
+
 /**
  * Main optimization function
  * @param {string} targetDir - Target directory to optimize
+ * @param {boolean} verbose - Show detailed processing information
  */
-async function optimize(targetDir) {
+async function optimize(targetDir, verbose = false) {
   // Validate directory exists
   if (!fs.existsSync(targetDir)) {
     throw new Error(`Directory does not exist: ${targetDir}`);
@@ -93,24 +190,42 @@ async function optimize(targetDir) {
   // Ensure config file exists
   ensureConfigFile(targetDir);
 
-  // Load configuration
+  // Load configuration and status (create status file early)
   const configPath = path.join(targetDir, CONFIG_FILENAME);
   const config = parseConfig(configPath);
+  const status = loadStatus(targetDir);
 
   console.log('Configuration:');
   console.log(`  Image Max Width: ${config.img_max_width}px`);
   console.log(`  Image Format: ${config.img_format}`);
   console.log(`  Video Max Width: ${config.video_max_width}px`);
-  console.log(`  Video Encode: ${config.video_encode}\n`);
+  console.log(`  Video Encode: ${config.video_encode}`);
+  console.log(`  Audio Extension: ${config.audio_ext}`);
+  console.log(`  PDF Compression: ${config.pdf_compress ? 'Enabled' : 'Disabled'}`);
+  
+  if (status.processed.length > 0) {
+    console.log(`  Resume: ${status.processed.length} files already processed`);
+  }
+  console.log('');
 
   // Search for media files
   console.log('🔍 Searching for media files...');
-  const { images, videos } = await fileSearcher.searchMediaFiles(targetDir);
+  const { images, videos, audio, documents } = await fileSearcher.searchMediaFiles(targetDir, { verbose });
 
-  console.log(`Found ${images.length} image(s) and ${videos.length} video(s)\n`);
+  // Filter out already processed files
+  const pendingImages = images.filter(img => !isProcessed(img, status));
+  const pendingVideos = videos.filter(vid => !isProcessed(vid, status));
+  const pendingAudio = audio.filter(aud => !isProcessed(aud, status));
+  const pendingDocuments = documents.filter(doc => !isProcessed(doc, status));
 
-  if (images.length === 0 && videos.length === 0) {
-    console.log('No media files found to optimize.');
+  const totalFound = images.length + videos.length + audio.length + documents.length;
+  const totalPending = pendingImages.length + pendingVideos.length + pendingAudio.length + pendingDocuments.length;
+  const alreadyProcessed = totalFound - totalPending;
+
+  console.log(`Found ${totalFound} file(s) (${alreadyProcessed} already processed, ${totalPending} pending)\n`);
+
+  if (totalPending === 0) {
+    console.log('All files have been processed. Use --reset to clear status and start over.');
     return;
   }
 
@@ -119,34 +234,96 @@ async function optimize(targetDir) {
   let successCount = 0;
 
   // Process images
-  if (images.length > 0) {
+  if (pendingImages.length > 0) {
     console.log('📷 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++;
+    for (const imagePath of pendingImages) {
+      try {
+        const result = await imageProcessor.processImage(imagePath, config);
+        console.log(result.message);
+        
+        totalOriginalSize += result.originalSize;
+        totalOptimizedSize += result.optimizedSize;
+        
+        // Mark as processed if success OR if already optimized (no processing needed)
+        if (result.success || result.message.includes('Already optimized')) {
+          successCount++;
+          markProcessed(imagePath, status, targetDir);
+        }
+      } catch (error) {
+        console.log(`❌ ${path.basename(imagePath)}: ${error.message}`);
+        markFailed(imagePath, error.message, status, targetDir);
       }
     }
     console.log('');
   }
 
   // Process videos
-  if (videos.length > 0) {
+  if (pendingVideos.length > 0) {
     console.log('🎬 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++;
+    for (const videoPath of pendingVideos) {
+      try {
+        const result = await videoProcessor.processVideo(videoPath, config);
+        console.log(result.message);
+        
+        totalOriginalSize += result.originalSize;
+        totalOptimizedSize += result.optimizedSize;
+        
+        // Mark as processed if success OR if already optimized (no processing needed)
+        if (result.success || result.message.includes('Already optimized')) {
+          successCount++;
+          markProcessed(videoPath, status, targetDir);
+        }
+      } catch (error) {
+        console.log(`❌ ${path.basename(videoPath)}: ${error.message}`);
+        markFailed(videoPath, error.message, status, targetDir);
+      }
+    }
+    console.log('');
+  }
+
+  // Process audio
+  if (pendingAudio.length > 0) {
+    console.log('🎵 Processing audio...');
+    for (const audioPath of pendingAudio) {
+      try {
+        const result = await audioProcessor.processAudio(audioPath, config);
+        console.log(result.message);
+        
+        totalOriginalSize += result.originalSize;
+        totalOptimizedSize += result.optimizedSize;
+        
+        // Mark as processed if success OR if already optimized (no processing needed)
+        if (result.success || result.message.includes('Already optimized')) {
+          successCount++;
+          markProcessed(audioPath, status, targetDir);
+        }
+      } catch (error) {
+        console.log(`❌ ${path.basename(audioPath)}: ${error.message}`);
+        markFailed(audioPath, error.message, status, targetDir);
+      }
+    }
+    console.log('');
+  }
+
+  // Process documents
+  if (pendingDocuments.length > 0) {
+    console.log('📄 Processing documents...');
+    for (const docPath of pendingDocuments) {
+      try {
+        const result = await pdfProcessor.processPDF(docPath, config);
+        console.log(result.message);
+        
+        totalOriginalSize += result.originalSize;
+        totalOptimizedSize += result.optimizedSize;
+        
+        // Mark as processed if success OR if already optimized (no processing needed)
+        if (result.success || result.message.includes('Already optimized')) {
+          successCount++;
+          markProcessed(docPath, status, targetDir);
+        }
+      } catch (error) {
+        console.log(`❌ ${path.basename(docPath)}: ${error.message}`);
+        markFailed(docPath, error.message, status, targetDir);
       }
     }
     console.log('');
@@ -154,7 +331,13 @@ async function optimize(targetDir) {
 
   // Print summary
   console.log('📊 Summary:');
-  console.log(`  Files optimized: ${successCount}/${images.length + videos.length}`);
+  console.log(`  Files processed: ${successCount}/${totalPending}`);
+  console.log(`  Total files in directory: ${totalFound}`);
+  console.log(`  Already processed: ${alreadyProcessed}`);
+  
+  if (status.failed.length > 0) {
+    console.log(`  Failed: ${status.failed.length}`);
+  }
   
   if (totalOriginalSize > 0) {
     const savedSize = totalOriginalSize - totalOptimizedSize;
@@ -164,10 +347,32 @@ async function optimize(targetDir) {
     console.log(`  Optimized size: ${(totalOptimizedSize / 1024 / 1024).toFixed(2)}MB`);
     console.log(`  Space saved: ${(savedSize / 1024 / 1024).toFixed(2)}MB (${savedPercent}%)`);
   }
+
+  // Save status
+  saveStatus(targetDir, status);
+}
+
+/**
+ * Reset status file
+ * @param {string} targetDir - Target directory
+ */
+function resetStatus(targetDir) {
+  const statusPath = path.join(targetDir, STATUS_FILENAME);
+  try {
+    if (fs.existsSync(statusPath)) {
+      fs.unlinkSync(statusPath);
+      console.log(`✓ Status file reset: ${STATUS_FILENAME}`);
+    } else {
+      console.log('No status file found to reset.');
+    }
+  } catch (error) {
+    console.warn(`Warning: Could not reset status file: ${error.message}`);
+  }
 }
 
 module.exports = {
   optimize,
+  resetStatus,
   parseConfig,
   ensureConfigFile
 };

package/src/pdfProcessor.js

@@ -0,0 +1,139 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Process PDF file with compression
+ * @param {string} pdfPath - Path to PDF file
+ * @param {object} config - Configuration object
+ * @returns {Promise<object>} Processing result
+ */
+async function processPDF(pdfPath, config = {}) {
+  return new Promise((resolve, reject) => {
+    // Check if PDF compression is disabled
+    if (config.pdf_compress === false) {
+      const originalSize = fs.statSync(pdfPath).size;
+      resolve({
+        success: false,
+        originalSize,
+        optimizedSize: originalSize,
+        message: `○ ${path.basename(pdfPath)} - Already optimized (PDF compression disabled)`,
+        filePath: pdfPath
+      });
+      return;
+    }
+
+    const originalSize = fs.statSync(pdfPath).size;
+    const parsedPath = path.parse(pdfPath);
+    
+    // For now, assume PDF files are already optimized (no size check)
+    // In a real implementation, you might check file size, quality, etc.
+    resolve({
+      success: false,
+      originalSize,
+      optimizedSize: originalSize,
+      message: `○ ${path.basename(pdfPath)} - Already optimized (${(originalSize / 1024 / 1024).toFixed(1)}MB)`,
+      filePath: pdfPath
+    });
+    return;
+    
+    // Use temporary file to avoid conflicts
+    const tmpPath = path.join(parsedPath.dir, `${parsedPath.name}_tmp.pdf`);
+
+    // Try to use ghostscript for PDF compression
+    const command = require('child_process').spawn('gs', [
+      '-sDEVICE=pdfwrite',
+      '-dCompatibilityLevel=1.4',
+      '-dPDFSETTINGS=/screen',
+      '-dNOPAUSE',
+      '-dQUIET',
+      '-dBATCH',
+      '-sOutputFile=' + tmpPath,
+      pdfPath
+    ]);
+
+    command.on('close', async (code) => {
+      try {
+        if (code !== 0 && code !== null) {
+          // If ghostscript fails, fall back to copy
+          console.warn(`Warning: Ghostscript failed (code ${code}), falling back to copy for ${path.basename(pdfPath)}`);
+          const copyCommand = require('child_process').spawn('cp', [pdfPath, tmpPath]);
+          
+          copyCommand.on('close', async (copyCode) => {
+            if (copyCode !== 0) {
+              throw new Error(`PDF copy failed with code ${copyCode}`);
+            }
+            await processResult();
+          });
+          
+          copyCommand.on('error', (error) => {
+            reject(new Error(`PDF copy failed for ${path.basename(pdfPath)}: ${error.message}`));
+          });
+          
+          return;
+        }
+
+        await processResult();
+      } catch (error) {
+        reject(error);
+      }
+    });
+
+    async function processResult() {
+      try {
+        const tmpStat = await new Promise((res, rej) => {
+          fs.stat(tmpPath, (err, stat) => {
+            if (err) rej(err);
+            else res(stat);
+          });
+        });
+
+        const optimizedSize = tmpStat.size;
+
+        // Always replace with compressed version for PDFs
+        await fs.promises.unlink(pdfPath);
+        await fs.promises.rename(tmpPath, pdfPath);
+
+        resolve({
+          success: true,
+          originalSize,
+          optimizedSize,
+          message: `✓ ${path.basename(pdfPath)} (${(originalSize / 1024 / 1024).toFixed(1)}MB → ${(optimizedSize / 1024 / 1024).toFixed(1)}MB)`,
+          filePath: pdfPath
+        });
+      } catch (error) {
+        // Clean up temp file on error
+        try {
+          await fs.promises.unlink(tmpPath);
+        } catch (cleanupError) {
+          // Ignore cleanup errors
+        }
+        reject(error);
+      }
+    }
+
+    command.on('error', async (error) => {
+      // If ghostscript is not available, fall back to copy
+      if (error.message.includes('ENOENT')) {
+        console.warn(`Warning: Ghostscript not found, falling back to copy for ${path.basename(pdfPath)}`);
+        const copyCommand = require('child_process').spawn('cp', [pdfPath, tmpPath]);
+        
+        copyCommand.on('close', async (copyCode) => {
+          if (copyCode !== 0) {
+            throw new Error(`PDF copy failed with code ${copyCode}`);
+          }
+          await processResult();
+        });
+        
+        copyCommand.on('error', (copyError) => {
+          reject(new Error(`PDF copy failed for ${path.basename(pdfPath)}: ${copyError.message}`));
+        });
+      } else {
+        reject(new Error(`PDF processing failed for ${path.basename(pdfPath)}: ${error.message}`));
+      }
+    });
+  });
+}
+
+module.exports = {
+  processPDF
+};