ultimate-jekyll-manager 0.0.53 → 0.0.54

package/dist/assets/js/modules/redirect.js

@@ -5,10 +5,28 @@
  */
 
 const performRedirect = () => {
+  // Debug: Log initial state
+  console.log('[Redirect] Script started at', new Date().toISOString());
+  console.log('[Redirect] Document readyState:', document.readyState);
+  console.log('[Redirect] Current URL:', window.location.href);
+  console.log('[Redirect] User Agent:', navigator.userAgent);
+  
+  // Check for spinner element to verify DOM is loaded
+  const $spinner = document.querySelector('.spinner-border');
+  console.log('[Redirect] Spinner element found:', !!$spinner);
+  if ($spinner) {
+    console.log('[Redirect] Spinner classes:', $spinner.className);
+    console.log('[Redirect] Spinner computed display:', window.getComputedStyle($spinner).display);
+    console.log('[Redirect] Spinner computed visibility:', window.getComputedStyle($spinner).visibility);
+    console.log('[Redirect] Spinner animation:', window.getComputedStyle($spinner).animation);
+  }
+  
   // Get redirect configuration element
   const $redirectConfig = document.getElementById('redirect-config');
   if (!$redirectConfig) {
     console.error('[Redirect] Configuration element #redirect-config not found');
+    console.error('[Redirect] Available IDs in document:', 
+      Array.from(document.querySelectorAll('[id]')).map(el => el.id));
     return;
   }
 
@@ -33,6 +51,8 @@ const performRedirect = () => {
   // Parse URLs
   const currentUrl = new URL(window.location.href);
   const siteUrl = new URL(config.siteUrl);
+  console.log('[Redirect] Current URL:', currentUrl.toString());
+  console.log('[Redirect] Site URL:', siteUrl.toString());
 
   // Parse modifier function
   let modifierFunction = (url) => url;
@@ -40,6 +60,7 @@ const performRedirect = () => {
     try {
       // Safely evaluate modifier function
       modifierFunction = new Function('url', `return (${config.modifier})(url)`);
+      console.log('[Redirect] Modifier function parsed successfully');
     } catch (error) {
       console.warn('[Redirect] Failed to parse modifier function:', error);
       console.warn('[Redirect] Modifier string:', config.modifier);
@@ -49,6 +70,8 @@ const performRedirect = () => {
   // Determine redirect delay
   const isDevelopment = config.environment === 'development';
   const timeout = isDevelopment ? 3000 : 1;
+  console.log('[Redirect] Environment:', config.environment);
+  console.log('[Redirect] Timeout:', timeout, 'ms');
 
   // Build redirect URL
   let redirectUrl;
@@ -67,6 +90,7 @@ const performRedirect = () => {
       // Default to site home page
       redirectUrl = new URL(siteUrl);
     }
+    console.log('[Redirect] Redirect URL built:', redirectUrl.toString());
   } catch (error) {
     console.error('[Redirect] Invalid redirect URL:', config.url, error);
     redirectUrl = new URL(siteUrl);
@@ -93,7 +117,7 @@ const performRedirect = () => {
   }
 
   // Log redirect details
-  console.group('[Redirect] Configuration');
+  console.group('[Redirect] Summary');
   console.log('Original URL:', config.url);
   console.log('Querystring forwarding:', shouldForwardQuerystring);
   console.log('Modifier:', config.modifier);
@@ -108,17 +132,23 @@ const performRedirect = () => {
   }
 
   // Perform the redirect
+  console.log('[Redirect] Setting timeout for redirect');
   setTimeout(() => {
+    console.log('[Redirect] Timeout fired, redirecting to:', finalUrl);
     window.location.href = finalUrl;
   }, timeout);
 };
 
 // Initialize based on Manager availability and DOM state
+console.log('[Redirect] Initial document.readyState:', document.readyState);
+
 if (document.readyState === 'loading') {
   // Wait for DOM if still loading
+  console.log('[Redirect] Waiting for DOMContentLoaded');
   document.addEventListener('DOMContentLoaded', performRedirect);
 } else {
   // DOM is already ready
+  console.log('[Redirect] Document already loaded, running immediately');
   performRedirect();
 }
 

package/dist/gulp/tasks/imagemin.js

@@ -51,6 +51,9 @@ async function imagemin(complete) {
   // Log
   logger.log('Starting...');
 
+  // Track timing
+  const startTime = Date.now();
+
   // Initialize cache on first run
   if (index === 0) {
     // Log responsive configurations
@@ -66,6 +69,18 @@ async function imagemin(complete) {
     return complete();
   }
 
+  // Track statistics
+  const stats = {
+    totalImages: 0,
+    fromCache: 0,
+    optimized: 0,
+    cachedFiles: [],
+    optimizedFiles: [],
+    sizeBefore: 0,
+    sizeAfter: 0,
+    savedBytes: 0
+  };
+
   // Get all images
   const files = glob(input);
   if (files.length === 0) {
@@ -73,6 +88,7 @@ async function imagemin(complete) {
     return complete();
   }
 
+  stats.totalImages = files.length;
   logger.log(`Found ${files.length} images to process`);
 
   // Load metadata
@@ -85,16 +101,34 @@ async function imagemin(complete) {
   }
 
   // Determine what needs processing
-  const { filesToProcess, validCachePaths } = await determineFilesToProcess(files, meta, githubCache);
+  const { filesToProcess, validCachePaths } = await determineFilesToProcess(files, meta, githubCache, stats);
 
   // Handle case where all files are from cache
   if (filesToProcess.length === 0) {
     logger.log('✅ All images from cache');
-    await handleCacheOnlyUpdate(githubCache, metaPath, meta, validCachePaths, files.length);
+
+    // Calculate timing
+    const endTime = Date.now();
+    const elapsedMs = endTime - startTime;
+
+    // Log statistics
+    logImageStatistics(stats, startTime, endTime);
+
+    await handleCacheOnlyUpdate(githubCache, metaPath, meta, validCachePaths, files.length, stats, { startTime, endTime, elapsedMs });
     return complete();
   }
 
   logger.log(`🔄 Processing ${filesToProcess.length} images`);
+  stats.optimized = filesToProcess.length;
+
+  // Track sizes for optimization
+  for (const file of filesToProcess) {
+    const fileStats = jetpack.inspect(file);
+    if (fileStats) {
+      stats.sizeBefore += fileStats.size;
+    }
+    stats.optimizedFiles.push(path.relative(rootPathProject, file));
+  }
 
   // Process images
   return src(filesToProcess, { base: 'src/assets/images' })
@@ -113,8 +147,24 @@ async function imagemin(complete) {
       const relativePath = path.relative(path.join(rootPathProject, output), file.path);
       const cachePath = path.join(CACHE_DIR, 'images', relativePath);
       jetpack.copy(file.path, cachePath, { overwrite: true });
+
+      // Track size after optimization
+      const fileStats = jetpack.inspect(file.path);
+      if (fileStats) {
+        stats.sizeAfter += fileStats.size;
+      }
     })
     .on('finish', async () => {
+      // Calculate final statistics
+      stats.savedBytes = stats.sizeBefore - stats.sizeAfter;
+
+      // Calculate timing
+      const endTime = Date.now();
+      const elapsedMs = endTime - startTime;
+
+      // Log statistics
+      logImageStatistics(stats, startTime, endTime);
+
       // Save metadata and push cache
       if (githubCache && githubCache.hasCredentials()) {
         githubCache.saveMetadata(metaPath, meta);
@@ -129,8 +179,23 @@ async function imagemin(complete) {
             timestamp: new Date().toISOString(),
             sourceCount: files.length,
             cachedCount: allCacheFiles.length - 1,
-            processedNow: filesToProcess.length,
-            fromCache: files.length - filesToProcess.length
+            processedNow: stats.optimized,
+            fromCache: stats.fromCache,
+            newlyProcessed: stats.optimized,
+            timing: {
+              startTime,
+              endTime,
+              elapsedMs
+            },
+            imageStats: {
+              totalImages: stats.totalImages,
+              optimized: stats.optimized,
+              skipped: stats.fromCache,
+              totalSizeBefore: stats.sizeBefore,
+              totalSizeAfter: stats.sizeAfter,
+              totalSaved: stats.savedBytes
+            },
+            details: `Optimized ${stats.optimized} images, ${stats.fromCache} from cache\n\n### Files from cache:\n${stats.cachedFiles.length > 0 ? stats.cachedFiles.map(f => `- ${f}`).join('\n') : 'None'}\n\n### Newly optimized files:\n${stats.optimizedFiles.length > 0 ? stats.optimizedFiles.map(f => `- ${f}`).join('\n') : 'None'}`
           }
         });
       }
@@ -221,7 +286,7 @@ async function initializeCache() {
 }
 
 // Determine which files need processing
-async function determineFilesToProcess(files, meta, githubCache) {
+async function determineFilesToProcess(files, meta, githubCache, stats) {
   const filesToProcess = [];
   const validCachePaths = new Set();
 
@@ -263,6 +328,24 @@ async function determineFilesToProcess(files, meta, githubCache) {
           jetpack.copy(src, dst, { overwrite: true });
         });
         logger.log(`📦 Using cache: ${relativePath}`);
+        stats.fromCache++;
+        stats.cachedFiles.push(relativePath);
+
+        // Track size of cached files
+        outputs.forEach(name => {
+          const cachePath = path.join(CACHE_DIR, 'images', dirName, name);
+          const fileStats = jetpack.inspect(cachePath);
+          if (fileStats) {
+            stats.sizeAfter += fileStats.size;
+          }
+        });
+
+        // Track original size
+        const originalStats = jetpack.inspect(file);
+        if (originalStats) {
+          stats.sizeBefore += originalStats.size;
+        }
+
         continue;
       }
     }
@@ -272,11 +355,11 @@ async function determineFilesToProcess(files, meta, githubCache) {
     meta[relativePath] = { hash, timestamp: new Date().toISOString() };
   }
 
-  return { filesToProcess, validCachePaths };
+  return { filesToProcess, validCachePaths, cacheStats: stats };
 }
 
 // Handle cache-only update (when no files need processing)
-async function handleCacheOnlyUpdate(githubCache, metaPath, meta, validCachePaths, fileCount) {
+async function handleCacheOnlyUpdate(githubCache, metaPath, meta, validCachePaths, fileCount, stats, timing) {
   if (!githubCache || !githubCache.hasCredentials()) {
     return;
   }
@@ -299,9 +382,66 @@ async function handleCacheOnlyUpdate(githubCache, metaPath, meta, validCachePath
         timestamp: new Date().toISOString(),
         sourceCount: fileCount,
         cachedCount: allCacheFiles.length - 1, // Subtract meta.json
-        processedNow: 0,
-        fromCache: fileCount
+        processedNow: stats.totalImages,
+        fromCache: stats.fromCache,
+        newlyProcessed: stats.optimized,
+        timing: timing,
+        imageStats: {
+          totalImages: stats.totalImages,
+          optimized: stats.optimized,
+          skipped: stats.fromCache,
+          totalSizeBefore: stats.sizeBefore,
+          totalSizeAfter: stats.sizeAfter,
+          totalSaved: stats.sizeBefore - stats.sizeAfter
+        },
+        details: `All ${fileCount} images served from cache`
       }
     });
   }
 }
+
+// Log image statistics
+function logImageStatistics(stats, startTime, endTime) {
+  const elapsedMs = endTime - startTime;
+  const elapsedSeconds = Math.floor(elapsedMs / 1000);
+  const elapsedMinutes = Math.floor(elapsedSeconds / 60);
+  const elapsedFormatted = elapsedMinutes > 0
+    ? `${elapsedMinutes}m ${elapsedSeconds % 60}s`
+    : `${elapsedSeconds}s`;
+
+  logger.log('\n📊 Image Optimization Statistics:');
+  logger.log('═══════════════════════════════════════');
+
+  // Timing
+  logger.log('⏱️  Timing:');
+  logger.log(`   Start time:      ${new Date(startTime).toLocaleTimeString()}`);
+  logger.log(`   End time:        ${new Date(endTime).toLocaleTimeString()}`);
+  logger.log(`   Total elapsed:   ${elapsedFormatted}`);
+
+  // File processing stats
+  logger.log('\n📁 File Processing:');
+  logger.log(`   Total images:        ${stats.totalImages}`);
+  logger.log(`   From cache:          ${stats.fromCache} (${((stats.fromCache / stats.totalImages) * 100).toFixed(1)}%)`);
+  logger.log(`   Newly optimized:     ${stats.optimized} (${((stats.optimized / stats.totalImages) * 100).toFixed(1)}%)`);
+
+  // Size reduction stats
+  if (stats.sizeBefore > 0 && stats.sizeAfter > 0) {
+    const savedPercent = ((stats.savedBytes / stats.sizeBefore) * 100).toFixed(1);
+    logger.log('\n💾 Size Reduction:');
+    logger.log(`   Original size:       ${formatBytes(stats.sizeBefore)}`);
+    logger.log(`   Optimized size:      ${formatBytes(stats.sizeAfter)}`);
+    logger.log(`   Total saved:         ${formatBytes(stats.savedBytes)} (${savedPercent}%)`);
+  }
+
+  logger.log('═══════════════════════════════════════\n');
+}
+
+// Helper to format bytes
+function formatBytes(bytes, decimals = 2) {
+  if (bytes === 0) return '0 Bytes';
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
+}

package/dist/gulp/tasks/jekyll.js

@@ -88,6 +88,11 @@ async function jekyll(complete) {
   // Build Jekyll
   await execute(command.join(' '), {log: true});
 
+  // Reposition "/blog/index.html" to "/blog.html" for compatibility
+  // This is needed because Jekyll creates a folder for the blog index page
+  // but we want it to be at the root level for compatibility with various hosting providers
+  await fixBlogIndex();
+
   // Run buildpost hook
   await hook('build:post', index);
 
@@ -287,6 +292,30 @@ async function getRuntimeConfig() {
   }
 }
 
+// Fix blog index positioning
+async function fixBlogIndex() {
+  try {
+    const blogIndexPath = '_site/blog/index.html';
+    const blogTargetPath = '_site/blog.html';
+    
+    // Check if blog/index.html exists
+    if (jetpack.exists(blogIndexPath)) {
+      // Move blog/index.html to blog.html
+      jetpack.move(blogIndexPath, blogTargetPath, { overwrite: true });
+      
+      // Remove empty blog directory if it exists and is empty
+      const blogDir = '_site/blog';
+      if (jetpack.exists(blogDir) && jetpack.list(blogDir).length === 0) {
+        jetpack.remove(blogDir);
+      }
+      
+      logger.log('Moved blog/index.html to blog.html');
+    }
+  } catch (e) {
+    logger.error('Error fixing blog index:', e);
+  }
+}
+
 // Create build.json
 async function createBuildJSON() {
   // Create build log JSON

package/dist/gulp/tasks/serve.js

@@ -275,16 +275,17 @@ async function processRequestMiddleware(req, res, next) {
     req.url = newURL;
   }
 
-  // Special case: Rewrite /blog to blog.html since Jekyll fucks it up locally (probably due to pagination)
-  if (pathname === '/blog') {
-    req.url = '/blog/index.html';
-  }
+  // Special LOCAL case: Rewrite /blog to blog.html since Jekyll fucks it up locally (probably due to pagination)
+  // Disaboed because we moved it to the jekyll task
+  // if (pathname === '/blog') {
+  //   req.url = '/blog/index.html';
+  // }
 
   // Strip query parameters and hash fragments from the URL for file path lookup
   const cleanUrl = req.url.split('?')[0].split('#')[0];
   const rawFilePath = path.join(rootPathProject, '_site', cleanUrl);
 
-  // Serve 404.html if the file does not exist
+  // Special LOCAL case: Serve 404.html if the file does not exist
   if (!jetpack.exists(rawFilePath) && rawFilePath.endsWith('.html')) {
     // Log
     logger.log(`File not found: ${req.url}. Serving 404.html instead.`);

package/dist/gulp/tasks/translation.js

@@ -161,6 +161,9 @@ async function processTranslation() {
   const enabled = config?.translation?.enabled !== false;
   const languages = config?.translation?.languages || [];
   const updatedFiles = new Set();
+  
+  // Track timing
+  const startTime = Date.now();
 
   // Quit if translation is disabled or no languages are configured
   if (!enabled) {
@@ -216,9 +219,17 @@ async function processTranslation() {
     metas[lang] = { meta, path: metaPath, skipped: new Set() };
   }
 
-  // Track token usage
+  // Track token usage and statistics
   const tokens = { input: 0, output: 0 };
   const queue = [];
+  const stats = {
+    fromCache: 0,
+    newlyProcessed: 0,
+    totalProcessed: 0,
+    failedFiles: [],
+    cachedFiles: [],
+    processedFiles: []
+  };
 
   for (const filePath of allFiles) {
     // Get relative path and original HTML
@@ -302,6 +313,8 @@ async function processTranslation() {
         ) {
           translated = jetpack.read(cachePath);
           logger.log(`📦 Success: ${logTag} - Using cache`);
+          stats.fromCache++;
+          stats.cachedFiles.push(logTag);
         } else {
           try {
             const { result, usage } = await translateWithAPI(openAIKey, bodyText, lang);
@@ -322,6 +335,8 @@ async function processTranslation() {
 
             // Set result
             setResult(true);
+            stats.newlyProcessed++;
+            stats.processedFiles.push(logTag);
           } catch (e) {
             const elapsedTime = ((Date.now() - startTime) / 1000).toFixed(2);
             logger.error(`❌ Failed: ${logTag} — ${e.message} (Elapsed time: ${elapsedTime}s)`);
@@ -331,6 +346,7 @@ async function processTranslation() {
 
             // Save failure to cache
             setResult(false);
+            stats.failedFiles.push(logTag);
           }
         }
 
@@ -448,6 +464,7 @@ async function processTranslation() {
         // Track updated files
         updatedFiles.add(cachePath);
         updatedFiles.add(metas[lang].path);
+        stats.totalProcessed++;
       };
 
       // Add to queue
@@ -487,35 +504,83 @@ async function processTranslation() {
     jetpack.write(metas[lang].path, metas[lang].meta);
   }
 
+  // Calculate timing
+  const endTime = Date.now();
+  const elapsedMs = endTime - startTime;
+  const elapsedSeconds = Math.floor(elapsedMs / 1000);
+  const elapsedMinutes = Math.floor(elapsedSeconds / 60);
+  const elapsedFormatted = elapsedMinutes > 0 
+    ? `${elapsedMinutes}m ${elapsedSeconds % 60}s`
+    : `${elapsedSeconds}s`;
+
   // Calculate costs using AI pricing (per 1M tokens)
   const inputCost = (tokens.input / 1000000) * AI.inputCost;
   const outputCost = (tokens.output / 1000000) * AI.outputCost;
   const totalCost = inputCost + outputCost;
 
-  // Log total token usage
-  logger.log('🧠 OpenAI Token Usage Summary:');
-  logger.log(`   🟣 Input tokens:      ${tokens.input.toLocaleString()}`);
-  logger.log(`   🟢 Output tokens:     ${tokens.output.toLocaleString()}`);
-  logger.log(`   🔵 Total tokens:      ${(tokens.input + tokens.output).toLocaleString()}`);
+  // Log detailed statistics
+  logger.log('\n📊 Translation Statistics:');
+  logger.log('═══════════════════════════════════════');
+  
+  // Timing
+  logger.log('⏱️  Timing:');
+  logger.log(`   Start time:      ${new Date(startTime).toLocaleTimeString()}`);
+  logger.log(`   End time:        ${new Date(endTime).toLocaleTimeString()}`);
+  logger.log(`   Total elapsed:   ${elapsedFormatted}`);
+  
+  // File processing stats
+  logger.log('\n📁 File Processing:');
+  logger.log(`   Total processed:     ${stats.totalProcessed}`);
+  logger.log(`   From cache:          ${stats.fromCache} (${((stats.fromCache / stats.totalProcessed) * 100).toFixed(1)}%)`);
+  logger.log(`   Newly translated:    ${stats.newlyProcessed} (${((stats.newlyProcessed / stats.totalProcessed) * 100).toFixed(1)}%)`);
+  if (stats.failedFiles.length > 0) {
+    logger.log(`   Failed:              ${stats.failedFiles.length}`);
+  }
 
-  // Cost summary
-  logger.log('💰 Cost Breakdown:');
-  logger.log(`   📥 Input cost:  $${inputCost.toFixed(4)}`);
-  logger.log(`   📤 Output cost: $${outputCost.toFixed(4)}`);
-  logger.log(`   💵 Total cost:  $${totalCost.toFixed(4)}`);
+  // Token usage
+  if (tokens.input > 0 || tokens.output > 0) {
+    logger.log('\n🧠 OpenAI Token Usage:');
+    logger.log(`   Input tokens:        ${tokens.input.toLocaleString()}`);
+    logger.log(`   Output tokens:       ${tokens.output.toLocaleString()}`);
+    logger.log(`   Total tokens:        ${(tokens.input + tokens.output).toLocaleString()}`);
+
+    // Cost summary
+    logger.log('\n💰 Cost Breakdown:');
+    logger.log(`   Input cost:          $${inputCost.toFixed(4)}`);
+    logger.log(`   Output cost:         $${outputCost.toFixed(4)}`);
+    logger.log(`   Total cost:          $${totalCost.toFixed(4)}`);
+  }
+  
+  logger.log('═══════════════════════════════════════\n');
 
   // Push updated translation cache back to cache branch
   if (githubCache && githubCache.hasCredentials()) {
     // Collect all cache files to push
     const allCacheFiles = glob(path.join(CACHE_DIR, '**/*'), { nodir: true });
 
-    // Push to GitHub
+    // Push to GitHub with detailed stats
     await githubCache.pushBranch(allCacheFiles, {
       stats: {
         timestamp: new Date().toISOString(),
         sourceCount: allFiles.length,
         cachedCount: allCacheFiles.length,
-        details: `Translated ${allFiles.length} pages to ${languages.length} languages`
+        processedNow: stats.totalProcessed,
+        fromCache: stats.fromCache,
+        newlyProcessed: stats.newlyProcessed,
+        timing: {
+          startTime,
+          endTime,
+          elapsedMs
+        },
+        tokenUsage: tokens.input > 0 || tokens.output > 0 ? {
+          inputTokens: tokens.input,
+          outputTokens: tokens.output,
+          totalTokens: tokens.input + tokens.output,
+          inputCost,
+          outputCost,
+          totalCost
+        } : undefined,
+        details: `Translated ${allFiles.length} pages to ${languages.length} languages\n\n### Files from cache:\n${stats.cachedFiles.length > 0 ? stats.cachedFiles.map(f => `- ${f}`).join('\n') : 'None'}\n\n### Newly translated files:\n${stats.processedFiles.length > 0 ? stats.processedFiles.map(f => `- ${f}`).join('\n') : 'None'}${stats.failedFiles.length > 0 ? `\n\n### Failed files:\n${stats.failedFiles.map(f => `- ${f}`).join('\n')}` : ''}`
       }
     });
   }

package/dist/gulp/tasks/utils/github-cache.js

@@ -557,14 +557,73 @@ This branch stores ${this.description}.
       readme += `- **Cached Files:** ${stats.cachedCount}\n`;
     }
 
+    // Add timing information if provided
+    if (stats.timing) {
+      const { startTime, endTime, elapsedMs } = stats.timing;
+      const elapsedFormatted = this.formatElapsedTime(elapsedMs);
+      readme += `
+## Timing Information
+
+- **Start Time:** ${new Date(startTime).toLocaleTimeString()}
+- **End Time:** ${new Date(endTime).toLocaleTimeString()}
+- **Total Elapsed:** ${elapsedFormatted}
+`;
+    }
+
     // Add last run stats if provided
-    if (stats.processedNow !== undefined || stats.fromCache !== undefined) {
+    if (stats.processedNow !== undefined || stats.fromCache !== undefined || stats.newlyProcessed !== undefined) {
       readme += `
 ## Last Run Statistics
 
-- **Processed:** ${stats.processedNow || 0} files
-- **From Cache:** ${stats.fromCache || 0} files
+- **Total Files Processed:** ${stats.processedNow || 0}
+- **Files From Cache:** ${stats.fromCache || 0}
+- **Newly Processed:** ${stats.newlyProcessed || 0}
+`;
+      
+      // Add percentage if both values exist
+      if (stats.processedNow && stats.fromCache !== undefined) {
+        const cacheRate = ((stats.fromCache / stats.processedNow) * 100).toFixed(1);
+        readme += `- **Cache Hit Rate:** ${cacheRate}%\n`;
+      }
+    }
+
+    // Add token usage and costs for translation
+    if (stats.tokenUsage) {
+      const { inputTokens, outputTokens, totalTokens, inputCost, outputCost, totalCost } = stats.tokenUsage;
+      readme += `
+## Token Usage & Costs
+
+- **Input Tokens:** ${(inputTokens || 0).toLocaleString()}
+- **Output Tokens:** ${(outputTokens || 0).toLocaleString()}
+- **Total Tokens:** ${(totalTokens || 0).toLocaleString()}
+
+### Cost Breakdown
+- **Input Cost:** $${(inputCost || 0).toFixed(4)}
+- **Output Cost:** $${(outputCost || 0).toFixed(4)}
+- **Total Cost:** $${(totalCost || 0).toFixed(4)}
+`;
+    }
+
+    // Add image optimization stats if provided
+    if (stats.imageStats) {
+      const { totalImages, optimized, skipped, totalSizeBefore, totalSizeAfter, totalSaved } = stats.imageStats;
+      readme += `
+## Image Optimization Statistics
+
+- **Total Images:** ${totalImages || 0}
+- **Optimized:** ${optimized || 0}
+- **Skipped (from cache):** ${skipped || 0}
 `;
+      
+      if (totalSizeBefore && totalSizeAfter) {
+        const savedPercent = ((totalSaved / totalSizeBefore) * 100).toFixed(1);
+        readme += `
+### Size Reduction
+- **Original Size:** ${this.formatBytes(totalSizeBefore)}
+- **Optimized Size:** ${this.formatBytes(totalSizeAfter)}
+- **Total Saved:** ${this.formatBytes(totalSaved)} (${savedPercent}%)
+`;
+      }
     }
 
     // Add custom details section if provided
@@ -584,6 +643,31 @@ ${stats.details}
     return readme;
   }
 
+  // Helper to format elapsed time
+  formatElapsedTime(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    
+    if (hours > 0) {
+      return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+    } else if (minutes > 0) {
+      return `${minutes}m ${seconds % 60}s`;
+    } else {
+      return `${seconds}s`;
+    }
+  }
+
+  // Helper to format bytes
+  formatBytes(bytes, decimals = 2) {
+    if (bytes === 0) return '0 Bytes';
+    const k = 1024;
+    const dm = decimals < 0 ? 0 : decimals;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
+  }
+
   // Calculate file hash
   calculateHash(filePath) {
     const content = jetpack.read(filePath, 'buffer');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ultimate-jekyll-manager",
-  "version": "0.0.53",
+  "version": "0.0.54",
   "description": "Ultimate Jekyll dependency manager",
   "main": "dist/index.js",
   "exports": {