ultimate-jekyll-manager 0.0.92 → 0.0.94

package/dist/commands/minify-html.js

@@ -0,0 +1,19 @@
+// Libraries
+const Manager = new (require('../build.js'));
+const logger = Manager.logger('minify');
+const { execute } = require('node-powertools');
+
+// Load package
+const package = Manager.getPackage('main');
+const project = Manager.getPackage('project');
+
+module.exports = async function (options) {
+  // Log
+  logger.log(`Starting minify...`);
+
+  // Build environment variables with all options
+  const envVars = `UJ_MINIFY_HTML_FORCE=true`;
+
+  // Run the full build process with minify force enabled
+  await execute(`${envVars} bundle exec npm run gulp -- minifyHtml`, { log: true })
+};

package/dist/gulp/tasks/minifyHtml.js

@@ -2,7 +2,8 @@
 const Manager = new (require('../../build.js'));
 const logger = Manager.logger('minifyHtml');
 const { src, dest, series } = require('gulp');
-const { minify } = require('html-minifier-terser');
+const { minify: minifyRust } = require('@minify-html/node');
+const { minify: minifyJs } = require('terser');
 const through2 = require('through2');
 
 // Load package
@@ -19,6 +20,33 @@ const input = [
 ];
 const output = '_site';
 
+// Helper function to minify a single file's content using Rust-based minifier
+async function minifyFileContent(htmlContent, options, filePath) {
+  // Extract and temporarily replace JSON-LD scripts
+  const { content: contentAfterJsonLd, extracted: jsonLdScripts } = extractJsonLdScripts(htmlContent);
+
+  // Extract and temporarily replace inline scripts (minified with Terser)
+  const { content: contentAfterScripts, extracted: inlineScripts } = await extractInlineScripts(contentAfterJsonLd, filePath);
+
+  // Extract and temporarily replace IE conditional comments
+  const { content: contentAfterComments, extracted: conditionalComments } = extractConditionalComments(contentAfterScripts);
+
+  // Minify the HTML content using Rust-based minifier (synchronous, much faster)
+  const minifiedBuffer = minifyRust(Buffer.from(contentAfterComments), options);
+  const minified = minifiedBuffer.toString();
+
+  // Restore the conditional comments
+  let finalHtml = restoreConditionalComments(minified, conditionalComments);
+
+  // Restore the inline scripts
+  finalHtml = restoreInlineScripts(finalHtml, inlineScripts);
+
+  // Restore the JSON-LD scripts
+  finalHtml = restoreJsonLdScripts(finalHtml, jsonLdScripts);
+
+  return finalHtml;
+}
+
 // Main task
 function minifyHtmlTask(complete) {
   // Check if we should minify
@@ -33,92 +61,248 @@ function minifyHtmlTask(complete) {
   logger.log('Starting...');
   Manager.logMemory(logger, 'Start');
 
-  // Configure minify options
+  // Configure minify options for @minify-html/node (Rust-based)
+  // NOTE: Inline scripts are extracted before minification to avoid bugs in minify-js
   const options = {
-    collapseWhitespace: true,
-    removeComments: true,
-    removeAttributeQuotes: true,
-    removeRedundantAttributes: true,
-    removeScriptTypeAttributes: true,
-    removeStyleLinkTypeAttributes: true,
-    useShortDoctype: true,
-    removeEmptyAttributes: true,
-    removeOptionalTags: false,
-    minifyCSS: true,
-    minifyJS: true
+    keep_closing_tags: false,
+    keep_comments: false,
+    keep_html_and_head_opening_tags: false,
+    keep_spaces_between_attributes: false,
+    keep_ssi_comments: false,
+    minify_css: true,
+    minify_js: false, // Disabled - inline scripts are extracted, so nothing to minify
+    remove_bangs: false,
+    remove_processing_instructions: false
   };
 
+  // Get concurrency limit from environment or use default
+  const CONCURRENCY_LIMIT = parseInt(process.env.UJ_MINIFY_CONCURRENCY || '1', 10);
+  logger.log(`Concurrency: ${CONCURRENCY_LIMIT} files at a time`);
+
+  // Collect files for batch processing
+  const fileQueue = [];
+  const processed = { count: 0 };
+
   // Process HTML files
   return src(input)
-    .pipe(through2.obj(async function(file, enc, callback) {
+    .pipe(through2.obj(function(file, _enc, callback) {
       if (file.isBuffer()) {
-        try {
-          let htmlContent = file.contents.toString();
-
-          // Extract and temporarily replace JSON-LD scripts
-          const jsonLdScripts = [];
-          const jsonLdRegex = /<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
-
-          htmlContent = htmlContent.replace(jsonLdRegex, (match, jsonContent) => {
-            // Minify the JSON content
-            try {
-              const parsed = JSON.parse(jsonContent);
-              const minifiedJson = JSON.stringify(parsed);
-              jsonLdScripts.push(minifiedJson);
-            } catch (e) {
-              jsonLdScripts.push(jsonContent);
-            }
-            return `__JSON_LD_PLACEHOLDER_${jsonLdScripts.length - 1}__`;
-          });
-
-          // Extract and temporarily replace IE conditional comments
-          const conditionalComments = [];
-          const conditionalRegex = /<!--\[if[^>]*\]>([\s\S]*?)<!\[endif\]-->/gi;
-
-          htmlContent = htmlContent.replace(conditionalRegex, (match, content) => {
-            // Minify the content inside the conditional comment
-            try {
-              const minifiedContent = content
-                .replace(/\s+/g, ' ')
-                .replace(/>\s+</g, '><')
-                .trim();
-              conditionalComments.push(match.replace(content, minifiedContent));
-            } catch (e) {
-              conditionalComments.push(match);
-            }
-            return `__CONDITIONAL_COMMENT_PLACEHOLDER_${conditionalComments.length - 1}__`;
-          });
-
-          // Minify the HTML content
-          const minified = await minify(htmlContent, options);
-
-          // Restore the JSON-LD scripts and conditional comments
-          let finalHtml = minified;
-          jsonLdScripts.forEach((jsonContent, index) => {
-            const scriptTag = `<script type=application/ld+json>${jsonContent}</script>`;
-            finalHtml = finalHtml.replace(`__JSON_LD_PLACEHOLDER_${index}__`, scriptTag);
-          });
-
-          conditionalComments.forEach((commentContent, index) => {
-            finalHtml = finalHtml.replace(`__CONDITIONAL_COMMENT_PLACEHOLDER_${index}__`, commentContent);
-          });
-
-          file.contents = Buffer.from(finalHtml);
-        } catch (err) {
-          logger.error(`Error minifying ${file.path}: ${err.message}`);
+        fileQueue.push({ file });
+        callback();
+      } else {
+        callback(null, file);
+      }
+    }, async function(callback) {
+      // This function is called when all files have been queued
+      if (fileQueue.length === 0) {
+        logger.log('No HTML files to minify');
+        return callback();
+      }
+
+      const totalFiles = fileQueue.length;
+      logger.log(`Minifying ${totalFiles} HTML files...`);
+
+      try {
+        // Process files in batches
+        for (let i = 0; i < fileQueue.length; i += CONCURRENCY_LIMIT) {
+          const batch = fileQueue.slice(i, i + CONCURRENCY_LIMIT);
+
+          // Process batch in parallel
+          const processedFiles = await Promise.all(
+            batch.map(async ({ file }) => {
+              try {
+                const htmlContent = file.contents.toString();
+                const finalHtml = await minifyFileContent(htmlContent, options, file.path);
+                file.contents = Buffer.from(finalHtml);
+                processed.count++;
+
+                // Log progress every 50 files or on last file
+                if (processed.count % 50 === 0 || processed.count === totalFiles) {
+                  const percentage = ((processed.count / totalFiles) * 100).toFixed(1);
+                  logger.log(`Progress: ${processed.count}/${totalFiles} files (${percentage}%)`);
+                  Manager.logMemory(logger, `After ${processed.count} files`);
+                }
+
+                return file;
+              } catch (err) {
+                logger.error(`Error minifying ${file.path}: ${err.message}`);
+                return file;
+              }
+            })
+          );
+
+          // Push processed files to the stream
+          processedFiles.forEach(file => this.push(file));
         }
+
+        callback();
+      } catch (err) {
+        logger.error(`Batch processing error: ${err.message}`);
+        callback(err);
       }
-      callback(null, file);
     }))
     .pipe(dest(output))
     .on('finish', () => {
       // Log
       logger.log('Finished!');
+      Manager.logMemory(logger, 'End');
 
       // Complete
-      return complete();
+      complete();
     });
 }
 
+// Helper: Extract JSON-LD scripts and replace with placeholders
+function extractJsonLdScripts(htmlContent) {
+  const extracted = [];
+  // Match both quoted and unquoted type attributes (minifier removes quotes)
+  const jsonLdRegex = /<script[^>]*type=(?:["']?application\/ld\+json["']?)[^>]*>([\s\S]*?)<\/script>/gi;
+
+  const content = htmlContent.replace(jsonLdRegex, (match, jsonContent) => {
+    // Minify the JSON content
+    try {
+      const parsed = JSON.parse(jsonContent);
+      const minifiedJson = JSON.stringify(parsed);
+      extracted.push(minifiedJson);
+    } catch (e) {
+      extracted.push(jsonContent);
+    }
+    return `__JSON_LD_PLACEHOLDER_${extracted.length - 1}__`;
+  });
+
+  return { content, extracted };
+}
+
+// Helper: Restore JSON-LD scripts from placeholders
+function restoreJsonLdScripts(htmlContent, jsonLdScripts) {
+  let content = htmlContent;
+
+  jsonLdScripts.forEach((jsonContent, index) => {
+    const scriptTag = `<script type=application/ld+json>${jsonContent}</script>`;
+    content = content.replace(`__JSON_LD_PLACEHOLDER_${index}__`, scriptTag);
+  });
+
+  return content;
+}
+
+// Helper: Extract inline scripts, minify with Terser, and replace with placeholders
+async function extractInlineScripts(htmlContent, filePath) {
+  const extracted = [];
+  const scripts = [];
+
+  // Match <script> tags that are NOT application/ld+json (those are already extracted)
+  // This regex excludes external scripts (those with src attribute)
+  // Handles both quoted and unquoted type attributes (minifier removes quotes)
+  const scriptRegex = /<script(?![^>]*type=(?:["']?application\/ld\+json["']?))(?![^>]*src=)([^>]*)>([\s\S]*?)<\/script>/gi;
+
+  // First pass: collect all scripts and create placeholders
+  const content = htmlContent.replace(scriptRegex, (fullMatch, attributes, jsCode) => {
+    const index = scripts.length;
+    scripts.push({ fullMatch, attributes, jsCode });
+    return `__INLINE_SCRIPT_PLACEHOLDER_${index}__`;
+  });
+
+  // Second pass: minify all scripts in parallel
+  const minifyPromises = scripts.map(async ({ fullMatch, attributes, jsCode }, scriptIndex) => {
+    // Skip empty scripts
+    if (!jsCode.trim()) {
+      return fullMatch;
+    }
+
+    // Try to minify the JavaScript with Terser
+    try {
+      const minified = await minifyJs(jsCode, {
+        compress: {
+          dead_code: true,
+          drop_console: false,
+          drop_debugger: true,
+          keep_classnames: false,
+          keep_fargs: true,
+          keep_fnames: false,
+          keep_infinity: false,
+        },
+        mangle: false, // Don't mangle variable names to avoid breaking code
+        format: {
+          comments: false,
+        },
+      });
+
+      if (minified && minified.code) {
+        return `<script${attributes}>${minified.code}</script>`;
+      }
+
+      return fullMatch;
+    } catch (err) {
+      // Minification failed - use original and log detailed error
+      const preview = jsCode.length > 100 ? jsCode.substring(0, 100) + '...' : jsCode;
+      const lines = jsCode.split('\n');
+
+      logger.error(`Failed to minify inline script in ${filePath}`);
+      logger.error(`  Script #${scriptIndex + 1} (${lines.length} lines)`);
+      logger.error(`  Error: ${err.message}`);
+
+      if (err.line !== undefined) {
+        logger.error(`  Line ${err.line}, Column ${err.col || '?'}`);
+      }
+
+      logger.error(`  Preview: ${preview.replace(/\n/g, ' ')}`);
+
+      return fullMatch;
+    }
+  });
+
+  // Wait for all minification to complete
+  const minifiedScripts = await Promise.all(minifyPromises);
+
+  // Add all minified scripts to extracted array
+  minifiedScripts.forEach(script => extracted.push(script));
+
+  return { content, extracted };
+}
+
+// Helper: Restore inline scripts from placeholders
+function restoreInlineScripts(htmlContent, inlineScripts) {
+  let content = htmlContent;
+
+  inlineScripts.forEach((scriptContent, index) => {
+    content = content.replace(`__INLINE_SCRIPT_PLACEHOLDER_${index}__`, scriptContent);
+  });
+
+  return content;
+}
+
+// Helper: Extract IE conditional comments and replace with placeholders
+function extractConditionalComments(htmlContent) {
+  const extracted = [];
+  const conditionalRegex = /<!--\[if[^>]*\]>([\s\S]*?)<!\[endif\]-->/gi;
+
+  const content = htmlContent.replace(conditionalRegex, (match, commentContent) => {
+    // Minify the content inside the conditional comment
+    try {
+      const minifiedContent = commentContent
+        .replace(/\s+/g, ' ')
+        .replace(/>\s+</g, '><')
+        .trim();
+      extracted.push(match.replace(commentContent, minifiedContent));
+    } catch (e) {
+      extracted.push(match);
+    }
+    return `__CONDITIONAL_COMMENT_PLACEHOLDER_${extracted.length - 1}__`;
+  });
+
+  return { content, extracted };
+}
+
+// Helper: Restore IE conditional comments from placeholders
+function restoreConditionalComments(htmlContent, conditionalComments) {
+  let content = htmlContent;
+
+  conditionalComments.forEach((commentContent, index) => {
+    content = content.replace(`__CONDITIONAL_COMMENT_PLACEHOLDER_${index}__`, commentContent);
+  });
+
+  return content;
+}
+
 // Default Task (no watcher for minifyHtml as it runs after Jekyll build)
 module.exports = minifyHtmlTask;

package/dist/gulp/tasks/utils/BU/minifyHtml.js

@@ -0,0 +1,183 @@
+// Libraries
+const Manager = new (require('../../build.js'));
+const logger = Manager.logger('minifyHtml');
+const { src, dest, series } = require('gulp');
+const { minify } = require('html-minifier-terser');
+const through2 = require('through2');
+
+// Load package
+const package = Manager.getPackage('main');
+const project = Manager.getPackage('project');
+const config = Manager.getConfig('project');
+const rootPathPackage = Manager.getRootPath('main');
+const rootPathProject = Manager.getRootPath('project');
+
+// Glob
+const input = [
+  // Files to include
+  '_site/**/*.html',
+];
+const output = '_site';
+
+// Helper function to minify a single file's content
+async function minifyFileContent(htmlContent, options) {
+  // Extract and temporarily replace JSON-LD scripts
+  const jsonLdScripts = [];
+  const jsonLdRegex = /<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+
+  htmlContent = htmlContent.replace(jsonLdRegex, (match, jsonContent) => {
+    // Minify the JSON content
+    try {
+      const parsed = JSON.parse(jsonContent);
+      const minifiedJson = JSON.stringify(parsed);
+      jsonLdScripts.push(minifiedJson);
+    } catch (e) {
+      jsonLdScripts.push(jsonContent);
+    }
+    return `__JSON_LD_PLACEHOLDER_${jsonLdScripts.length - 1}__`;
+  });
+
+  // Extract and temporarily replace IE conditional comments
+  const conditionalComments = [];
+  const conditionalRegex = /<!--\[if[^>]*\]>([\s\S]*?)<!\[endif\]-->/gi;
+
+  htmlContent = htmlContent.replace(conditionalRegex, (match, content) => {
+    // Minify the content inside the conditional comment
+    try {
+      const minifiedContent = content
+        .replace(/\s+/g, ' ')
+        .replace(/>\s+</g, '><')
+        .trim();
+      conditionalComments.push(match.replace(content, minifiedContent));
+    } catch (e) {
+      conditionalComments.push(match);
+    }
+    return `__CONDITIONAL_COMMENT_PLACEHOLDER_${conditionalComments.length - 1}__`;
+  });
+
+  // Minify the HTML content
+  const minified = await minify(htmlContent, options);
+
+  // Restore the JSON-LD scripts and conditional comments
+  let finalHtml = minified;
+  jsonLdScripts.forEach((jsonContent, index) => {
+    const scriptTag = `<script type=application/ld+json>${jsonContent}</script>`;
+    finalHtml = finalHtml.replace(`__JSON_LD_PLACEHOLDER_${index}__`, scriptTag);
+  });
+
+  conditionalComments.forEach((commentContent, index) => {
+    finalHtml = finalHtml.replace(`__CONDITIONAL_COMMENT_PLACEHOLDER_${index}__`, commentContent);
+  });
+
+  return finalHtml;
+}
+
+// Helper function to process files in batches
+async function processBatch(batch, options, processed, total) {
+  return Promise.all(batch.map(async ({ file }) => {
+    try {
+      const htmlContent = file.contents.toString();
+      const finalHtml = await minifyFileContent(htmlContent, options);
+      file.contents = Buffer.from(finalHtml);
+      processed.count++;
+
+      // Log progress every 10 files or on last file
+      if (processed.count % 10 === 0 || processed.count === total) {
+        const percentage = ((processed.count / total) * 100).toFixed(1);
+        logger.log(`Progress: ${processed.count}/${total} files (${percentage}%)`);
+        Manager.logMemory(logger, `After ${processed.count} files`);
+      }
+
+      return file;
+    } catch (err) {
+      logger.error(`Error minifying ${file.path}: ${err.message}`);
+      return file;
+    }
+  }));
+}
+
+// Main task
+function minifyHtmlTask(complete) {
+  // Check if we should minify
+  const shouldMinify = Manager.isBuildMode() || process.env.UJ_MINIFY_HTML_FORCE === 'true';
+
+  if (!shouldMinify) {
+    logger.log('Skipping HTML minification (not in production mode and UJ_MINIFY_HTML_FORCE not set)');
+    return complete();
+  }
+
+  // Get concurrency limit from environment or use default
+  const CONCURRENCY_LIMIT = parseInt(process.env.UJ_MINIFY_CONCURRENCY || '10', 10);
+
+  // Log
+  logger.log('Starting...');
+  logger.log(`Concurrency limit: ${CONCURRENCY_LIMIT} files at a time`);
+  Manager.logMemory(logger, 'Start');
+
+  // Configure minify options
+  const options = {
+    collapseWhitespace: true,
+    removeComments: true,
+    removeAttributeQuotes: true,
+    removeRedundantAttributes: true,
+    removeScriptTypeAttributes: true,
+    removeStyleLinkTypeAttributes: true,
+    useShortDoctype: true,
+    removeEmptyAttributes: true,
+    removeOptionalTags: false,
+    minifyCSS: true,
+    minifyJS: true
+  };
+
+  // Collect files for batch processing
+  const fileQueue = [];
+  const processed = { count: 0 };
+
+  // Process HTML files
+  return src(input)
+    .pipe(through2.obj(function(file, _enc, callback) {
+      if (file.isBuffer()) {
+        fileQueue.push({ file });
+        callback();
+      } else {
+        callback(null, file);
+      }
+    }, async function(callback) {
+      // This function is called when all files have been queued
+      if (fileQueue.length === 0) {
+        logger.log('No HTML files to minify');
+        return callback();
+      }
+
+      const totalFiles = fileQueue.length;
+      logger.log(`Minifying ${totalFiles} HTML files...`);
+
+      try {
+        // Process files in batches
+        for (let i = 0; i < fileQueue.length; i += CONCURRENCY_LIMIT) {
+          const batch = fileQueue.slice(i, i + CONCURRENCY_LIMIT);
+          const processedFiles = await processBatch(batch, options, processed, totalFiles);
+
+          // Push processed files to the stream
+          processedFiles.forEach(file => this.push(file));
+        }
+
+        callback();
+      } catch (err) {
+        logger.error(`Batch processing error: ${err.message}`);
+        callback(err);
+      }
+    }))
+    .pipe(dest(output))
+    .on('finish', () => {
+      // Log
+      logger.log('Finished!');
+      Manager.logMemory(logger, 'End');
+
+      // Complete
+      complete();
+    });
+}
+
+// Default Task (no watcher for minifyHtml as it runs after Jekyll build)
+module.exports = minifyHtmlTask;

package/dist/gulp/tasks/utils/BU/minifyHtml.worker.js

@@ -0,0 +1,72 @@
+// Worker thread for HTML minification
+const { parentPort, workerData } = require('worker_threads');
+const { minify } = require('html-minifier-terser');
+
+// Listen for messages from parent
+parentPort.on('message', async (data) => {
+  const { htmlContent, options, index } = data;
+
+  try {
+    // Extract and temporarily replace JSON-LD scripts
+    const jsonLdScripts = [];
+    const jsonLdRegex = /<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+
+    let processedContent = htmlContent.replace(jsonLdRegex, (match, jsonContent) => {
+      // Minify the JSON content
+      try {
+        const parsed = JSON.parse(jsonContent);
+        const minifiedJson = JSON.stringify(parsed);
+        jsonLdScripts.push(minifiedJson);
+      } catch (e) {
+        jsonLdScripts.push(jsonContent);
+      }
+      return `__JSON_LD_PLACEHOLDER_${jsonLdScripts.length - 1}__`;
+    });
+
+    // Extract and temporarily replace IE conditional comments
+    const conditionalComments = [];
+    const conditionalRegex = /<!--\[if[^>]*\]>([\s\S]*?)<!\[endif\]-->/gi;
+
+    processedContent = processedContent.replace(conditionalRegex, (match, content) => {
+      // Minify the content inside the conditional comment
+      try {
+        const minifiedContent = content
+          .replace(/\s+/g, ' ')
+          .replace(/>\s+</g, '><')
+          .trim();
+        conditionalComments.push(match.replace(content, minifiedContent));
+      } catch (e) {
+        conditionalComments.push(match);
+      }
+      return `__CONDITIONAL_COMMENT_PLACEHOLDER_${conditionalComments.length - 1}__`;
+    });
+
+    // Minify the HTML content
+    const minified = await minify(processedContent, options);
+
+    // Restore the JSON-LD scripts and conditional comments
+    let finalHtml = minified;
+    jsonLdScripts.forEach((jsonContent, idx) => {
+      const scriptTag = `<script type=application/ld+json>${jsonContent}</script>`;
+      finalHtml = finalHtml.replace(`__JSON_LD_PLACEHOLDER_${idx}__`, scriptTag);
+    });
+
+    conditionalComments.forEach((commentContent, idx) => {
+      finalHtml = finalHtml.replace(`__CONDITIONAL_COMMENT_PLACEHOLDER_${idx}__`, commentContent);
+    });
+
+    // Send result back to parent
+    parentPort.postMessage({
+      success: true,
+      index,
+      result: finalHtml
+    });
+  } catch (err) {
+    // Send error back to parent
+    parentPort.postMessage({
+      success: false,
+      index,
+      error: err.message
+    });
+  }
+});

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

@@ -6,6 +6,7 @@ const jetpack = require('fs-jetpack');
 const crypto = require('crypto');
 const { Octokit } = require('@octokit/rest');
 const AdmZip = require('adm-zip');
+const { execute } = require('node-powertools');
 
 class GitHubCache {
   constructor(options = {}) {
@@ -21,16 +22,39 @@ class GitHubCache {
 
   // Initialize GitHub API client
   async init() {
+    // Ensure GH_TOKEN is set
     if (!process.env.GH_TOKEN) {
       throw new Error('GH_TOKEN environment variable not set');
     }
-    
+
+    // Auto-detect repository if not set
+    if (!process.env.GITHUB_REPOSITORY) {
+      try {
+        const result = await execute('git remote get-url origin', { log: false });
+
+        // Parse GitHub repository from remote URL
+        // Supports: https://github.com/owner/repo.git, git@github.com:owner/repo.git
+        const match = result.match(/github\.com[:/]([^/]+\/[^.\s]+)/);
+
+        if (match) {
+          process.env.GITHUB_REPOSITORY = match[1];
+          this.logger.log(`📦 Auto-detected repository from git remote: ${process.env.GITHUB_REPOSITORY}`);
+        }
+      } catch (e) {
+        // Ignore errors from git command
+        this.logger.warn(`⚠️ Could not auto-detect repository from git remote: ${e.message}`);
+      }
+    }
+
+    // Final check
     if (!process.env.GITHUB_REPOSITORY) {
-      throw new Error('GITHUB_REPOSITORY environment variable not set');
+      throw new Error('GITHUB_REPOSITORY environment variable not set and could not auto-detect from git remote');
     }
 
+    // Set owner and repo
     [this.owner, this.repo] = process.env.GITHUB_REPOSITORY.split('/');
-    
+
+    // Initialize Octokit
     if (!this.octokit) {
       this.octokit = new Octokit({
         auth: process.env.GH_TOKEN,
@@ -42,22 +66,22 @@ class GitHubCache {
 
   // Check if credentials are available
   hasCredentials() {
-    return !!(process.env.GH_TOKEN && process.env.GITHUB_REPOSITORY);
+    return !!process.env.GH_TOKEN;
   }
 
   // Fetch cache branch from GitHub
   async fetchBranch() {
     await this.init();
-    
+
     this.logger.log(`📥 Fetching cache from branch '${this.branchName}'`);
 
     // Check if the branch exists
     let branchExists = false;
     try {
-      await this.octokit.repos.getBranch({ 
-        owner: this.owner, 
-        repo: this.repo, 
-        branch: this.branchName 
+      await this.octokit.repos.getBranch({
+        owner: this.owner,
+        repo: this.repo,
+        branch: this.branchName
       });
       branchExists = true;
     } catch (e) {
@@ -81,15 +105,15 @@ class GitHubCache {
     const extractDir = path.dirname(this.cacheDir);
 
     jetpack.write(zipPath, Buffer.from(zipBallArchive.data));
-    
+
     const zip = new AdmZip(zipPath);
     zip.extractAllTo(extractDir, true);
 
     // Find extracted root folder
-    const extractedRoot = jetpack.list(extractDir).find(name => 
+    const extractedRoot = jetpack.list(extractDir).find(name =>
       name.startsWith(`${this.owner}-${this.repo}-`)
     );
-    
+
     if (!extractedRoot) {
       throw new Error('Could not find extracted archive root folder');
     }
@@ -105,30 +129,30 @@ class GitHubCache {
 
     // Clean up
     jetpack.remove(zipPath);
-    
+
     // Log what was fetched
     const fetchedFiles = jetpack.find(targetPath, { matching: '**/*', files: true, directories: false });
     this.logger.log(`✅ Fetched cache from branch '${this.branchName}' (${fetchedFiles.length} files total)`);
-    
+
     return true;
   }
 
   // Push files to cache branch with automatic orphan detection
   async pushBranch(updatedFiles, options = {}) {
     await this.init();
-    
+
     // Git is required
     this.requireGitCommands();
 
     // Convert Set to array if needed
     let files = Array.isArray(updatedFiles) ? updatedFiles : [...updatedFiles];
-    
+
     // Auto-add metadata file if it exists and not already included
     const metaPath = path.join(this.cacheDir, 'meta.json');
     if (jetpack.exists(metaPath) && !files.includes(metaPath)) {
       files.push(metaPath);
     }
-    
+
     // Handle orphan detection if validFiles provided
     let forceRecreate = options.forceRecreate || false;
     if (options.validFiles) {
@@ -143,11 +167,11 @@ class GitHubCache {
         }
       }
     }
-    
+
     this.logger.log(`📤 Pushing ${files.length} file(s) to cache branch '${this.branchName}'`);
 
     // Generate README if stats provided
-    const readme = options.stats ? this.generateReadme(options.stats) : 
+    const readme = options.stats ? this.generateReadme(options.stats) :
                    options.branchReadme || this.generateDefaultReadme();
 
     // If forceRecreate is true, we'll handle it in uploadFilesViaGit
@@ -160,7 +184,7 @@ class GitHubCache {
       // Normal update
       await this.ensureBranchExists(readme);
       const uploadedCount = await this.uploadFilesViaGit(files, false, readme);
-      
+
       if (uploadedCount > 0) {
         this.logger.log(`🎉 Pushed ${uploadedCount} file(s) to cache branch`);
       }
@@ -196,7 +220,7 @@ class GitHubCache {
       let source;
       let retries = 5;
       const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
-      
+
       while (retries > 0) {
         try {
           const result = await this.octokit.git.getRef({
@@ -255,12 +279,12 @@ class GitHubCache {
   // Ensure branch exists, create if needed
   async ensureBranchExists(readmeContent) {
     let branchExists = false;
-    
+
     try {
-      await this.octokit.repos.getBranch({ 
-        owner: this.owner, 
-        repo: this.repo, 
-        branch: this.branchName 
+      await this.octokit.repos.getBranch({
+        owner: this.owner,
+        repo: this.repo,
+        branch: this.branchName
       });
       branchExists = true;
     } catch (e) {
@@ -321,7 +345,7 @@ class GitHubCache {
   // Load metadata file
   loadMetadata(metaPath) {
     let meta = {};
-    
+
     if (jetpack.exists(metaPath)) {
       try {
         meta = jetpack.read(metaPath, 'json');
@@ -329,7 +353,7 @@ class GitHubCache {
         this.logger.warn('⚠️ Metadata file corrupted - starting fresh');
       }
     }
-    
+
     return meta;
   }
 
@@ -337,14 +361,14 @@ class GitHubCache {
   saveMetadata(metaPath, meta) {
     jetpack.write(metaPath, meta);
   }
-  
+
   // Clean deleted files from metadata
   cleanDeletedFromMetadata(meta, currentFiles, rootPath) {
-    const currentFilesSet = new Set(currentFiles.map(f => 
+    const currentFilesSet = new Set(currentFiles.map(f =>
       path.relative(rootPath, f)
     ));
     let removedCount = 0;
-    
+
     Object.keys(meta).forEach(key => {
       if (!currentFilesSet.has(key)) {
         delete meta[key];
@@ -352,7 +376,7 @@ class GitHubCache {
         removedCount++;
       }
     });
-    
+
     return removedCount;
   }
 
@@ -370,13 +394,13 @@ class GitHubCache {
   // Upload files using git commands (much faster for multiple files)
   async uploadFilesViaGit(files, forceRecreate = false, readme = null) {
     const { execSync } = require('child_process');
-    
+
     this.logger.log(`🚀 Using fast git upload for ${files.length} files`);
-    
+
     try {
       // Work directly in the cache directory
       const gitDir = path.join(this.cacheDir, '.git');
-      
+
       if (forceRecreate) {
         // For force recreate, remove git dir and init fresh
         this.logger.log(`🆕 Initializing fresh repository in ${this.cacheDir}...`);
@@ -387,19 +411,19 @@ class GitHubCache {
       } else if (!jetpack.exists(gitDir)) {
         // If no git dir exists, clone the branch
         this.logger.log(`📥 Initializing git in cache directory...`);
-        
+
         // Save current files temporarily
         const tempBackup = path.join(path.dirname(this.cacheDir), `${path.basename(this.cacheDir)}-backup-${Date.now()}`);
         if (jetpack.exists(this.cacheDir)) {
           jetpack.move(this.cacheDir, tempBackup);
         }
-        
+
         // Clone the branch
         execSync(
           `git clone --depth 1 --branch ${this.branchName} https://${process.env.GH_TOKEN}@github.com/${this.owner}/${this.repo}.git "${this.cacheDir}"`,
           { stdio: 'ignore' }
         );
-        
+
         // Restore backed up files (overwriting cloned files)
         if (jetpack.exists(tempBackup)) {
           jetpack.copy(tempBackup, this.cacheDir, { overwrite: true });
@@ -416,28 +440,28 @@ class GitHubCache {
           this.logger.warn('⚠️ Pull failed, will force push if needed');
         }
       }
-      
+
       // Add README if provided
       let readmeChanged = false;
       if (readme) {
         const readmePath = path.join(this.cacheDir, 'README.md');
         const existingReadme = jetpack.exists(readmePath) ? jetpack.read(readmePath) : '';
-        
+
         if (existingReadme !== readme) {
           this.logger.log('📝 README content has changed, updating...');
           readmeChanged = true;
         }
-        
+
         jetpack.write(readmePath, readme);
       }
-      
+
       // Check if there are changes
       const status = execSync('git status --porcelain', { cwd: this.cacheDir }).toString();
       if (!status.trim()) {
         this.logger.log('⏭️  No changes to commit (including README)');
         return 0;
       }
-      
+
       // Log what changed
       const changedFiles = status.trim().split('\n').length;
       if (readmeChanged && changedFiles === 1) {
@@ -447,11 +471,11 @@ class GitHubCache {
       } else {
         this.logger.log(`📝 ${changedFiles} files have changed`);
       }
-      
+
       // Add all changes
       this.logger.log(`📝 Staging changes...`);
       execSync('git add -A', { cwd: this.cacheDir, stdio: 'ignore' });
-      
+
       // Create commit message based on what changed
       let commitMessage;
       if (readmeChanged && changedFiles === 1) {
@@ -461,13 +485,13 @@ class GitHubCache {
       } else {
         commitMessage = `📦 Update cache: ${changedFiles} files`;
       }
-      
+
       // Commit
       execSync(
         `git -c user.name="GitHub Actions" -c user.email="actions@github.com" commit -m "${commitMessage}"`,
         { cwd: this.cacheDir, stdio: 'ignore' }
       );
-      
+
       // Push
       this.logger.log(`📤 Pushing to GitHub...`);
       try {
@@ -477,7 +501,7 @@ class GitHubCache {
         this.logger.warn('⚠️ Normal push failed, attempting force push...');
         execSync('git push --force origin ' + this.branchName, { cwd: this.cacheDir, stdio: 'ignore' });
       }
-      
+
       return changedFiles;
     } catch (error) {
       this.logger.error(`❌ Git command failed: ${error.message}`);
@@ -488,15 +512,15 @@ class GitHubCache {
   // Check for orphaned files in cache
   async checkForOrphans(validFiles) {
     const validSet = new Set(validFiles);
-    const cacheFiles = jetpack.find(this.cacheDir, { 
-      matching: '**/*', 
-      files: true, 
-      directories: false 
+    const cacheFiles = jetpack.find(this.cacheDir, {
+      matching: '**/*',
+      files: true,
+      directories: false
     });
-    
+
     const orphanedFiles = [];
     const validCacheFiles = [];
-    
+
     cacheFiles.forEach(file => {
       const relativePath = path.relative(this.cacheDir, file);
       if (validSet.has(relativePath) || relativePath === 'meta.json') {
@@ -508,7 +532,7 @@ class GitHubCache {
         }
       }
     });
-    
+
     return {
       hasOrphans: orphanedFiles.length > 0,
       orphanedCount: orphanedFiles.length,
@@ -531,16 +555,16 @@ This branch stores ${this.description}.
   // Generate README with stats
   generateReadme(stats = {}) {
     const date = new Date(stats.timestamp || Date.now());
-    const formattedDate = date.toLocaleString('en-US', { 
-      weekday: 'long', 
-      year: 'numeric', 
-      month: 'long', 
+    const formattedDate = date.toLocaleString('en-US', {
+      weekday: 'long',
+      year: 'numeric',
+      month: 'long',
       day: 'numeric',
       hour: '2-digit',
       minute: '2-digit',
       timeZoneName: 'short'
     });
-    
+
     let readme = `# ${this.cacheType} Cache Branch
 
 This branch stores ${this.description}.
@@ -580,7 +604,7 @@ This branch stores ${this.description}.
 - **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);
@@ -634,7 +658,7 @@ This branch stores ${this.description}.
 - **Optimized:** ${optimized || 0}
 - **Skipped (from cache):** ${skipped || 0}
 `;
-      
+
       if (totalSizeBefore && totalSizeAfter) {
         const savedPercent = ((totalSaved / totalSizeBefore) * 100).toFixed(1);
         readme += `
@@ -668,7 +692,7 @@ ${stats.details}
     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) {
@@ -695,4 +719,4 @@ ${stats.details}
   }
 }
 
-module.exports = GitHubCache;
+module.exports = GitHubCache;

package/firebase-debug.log

@@ -54,3 +54,11 @@
 [debug] [2025-10-22T06:51:09.274Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
 [debug] [2025-10-22T06:51:09.274Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
 [debug] [2025-10-22T06:51:09.274Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
+[debug] [2025-10-22T08:40:01.642Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
+[debug] [2025-10-22T08:40:01.642Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
+[debug] [2025-10-22T08:40:01.644Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
+[debug] [2025-10-22T08:40:01.644Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
+[debug] [2025-10-22T08:40:01.644Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
+[debug] [2025-10-22T08:40:01.644Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
+[debug] [2025-10-22T08:40:01.644Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
+[debug] [2025-10-22T08:40:01.644Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ultimate-jekyll-manager",
-  "version": "0.0.92",
+  "version": "0.0.94",
   "description": "Ultimate Jekyll dependency manager",
   "main": "dist/index.js",
   "exports": {
@@ -62,6 +62,7 @@
     "@babel/core": "^7.28.4",
     "@babel/preset-env": "^7.28.3",
     "@fullhuman/postcss-purgecss": "^7.0.2",
+    "@minify-html/node": "^0.16.4",
     "@octokit/rest": "^22.0.0",
     "@popperjs/core": "^2.11.8",
     "@prettier/plugin-xml": "^3.4.2",