ultimate-jekyll-manager 0.0.54 → 0.0.56

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

@@ -5,28 +5,10 @@
  */
 
 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;
   }
 
@@ -51,8 +33,6 @@ 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;
@@ -60,7 +40,6 @@ 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);
@@ -70,8 +49,6 @@ 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;
@@ -90,7 +67,6 @@ 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);
@@ -117,7 +93,7 @@ const performRedirect = () => {
   }
 
   // Log redirect details
-  console.group('[Redirect] Summary');
+  console.group('[Redirect] Configuration');
   console.log('Original URL:', config.url);
   console.log('Querystring forwarding:', shouldForwardQuerystring);
   console.log('Modifier:', config.modifier);
@@ -132,23 +108,17 @@ 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

@@ -169,6 +169,8 @@ async function imagemin(complete) {
       if (githubCache && githubCache.hasCredentials()) {
         githubCache.saveMetadata(metaPath, meta);
 
+        logger.log(`📊 Updating cache with ${stats.optimized} new optimizations and README stats...`);
+
         // Collect all cache files to push (metadata will be auto-included)
         const allCacheFiles = glob(path.join(CACHE_DIR, '**/*'), { nodir: true });
 
@@ -367,37 +369,34 @@ async function handleCacheOnlyUpdate(githubCache, metaPath, meta, validCachePath
   // Save metadata
   githubCache.saveMetadata(metaPath, meta);
 
-  // Check for orphans locally to decide if we need to push
-  const orphanCheck = await githubCache.checkForOrphans(validCachePaths);
-  if (orphanCheck.hasOrphans) {
-    logger.log(`🗑️ Found ${orphanCheck.orphanedCount} orphaned files - updating cache`);
-
-    // Collect all valid cache files
-    const allCacheFiles = glob(path.join(CACHE_DIR, '**/*'), { nodir: true });
-
-    // Push to GitHub (pushBranch will handle orphan detection internally)
-    await githubCache.pushBranch(allCacheFiles, {
-      validFiles: validCachePaths,
-      stats: {
-        timestamp: new Date().toISOString(),
-        sourceCount: fileCount,
-        cachedCount: allCacheFiles.length - 1, // Subtract meta.json
-        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`
-      }
-    });
-  }
+  // ALWAYS update README with latest stats, even if no orphans
+  logger.log(`📊 Updating cache README with latest statistics...`);
+
+  // Collect all valid cache files
+  const allCacheFiles = glob(path.join(CACHE_DIR, '**/*'), { nodir: true });
+
+  // Push to GitHub (will update README even if no file changes)
+  await githubCache.pushBranch(allCacheFiles, {
+    validFiles: validCachePaths,
+    stats: {
+      timestamp: new Date().toISOString(),
+      sourceCount: fileCount,
+      cachedCount: allCacheFiles.length - 1, // Subtract meta.json
+      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

package/dist/gulp/tasks/sass.js

@@ -175,6 +175,9 @@ function sass(complete) {
             /^animate-/,
             /^animation-/,
 
+            // Spinner
+            /^spinner-/,
+
             // Utilities that might be added dynamically
             /^[mp][trblxy]?-[0-9]+$/,
             /^text-/,

package/dist/gulp/tasks/translation.js

@@ -555,11 +555,14 @@ async function processTranslation() {
 
   // Push updated translation cache back to cache branch
   if (githubCache && githubCache.hasCredentials()) {
+    logger.log(`📊 Updating translation cache README with latest statistics...`);
+    
     // Collect all cache files to push
     const allCacheFiles = glob(path.join(CACHE_DIR, '**/*'), { nodir: true });
 
-    // Push to GitHub with detailed stats
+    // ALWAYS force recreate the branch (fresh branch with no history)
     await githubCache.pushBranch(allCacheFiles, {
+      forceRecreate: true,  // ALWAYS create a fresh branch - no history needed
       stats: {
         timestamp: new Date().toISOString(),
         sourceCount: allFiles.length,
@@ -580,7 +583,22 @@ async function processTranslation() {
           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')}` : ''}`
+        languageBreakdown: languages.map(lang => ({
+          language: lang,
+          total: stats.totalProcessed / languages.length,
+          fromCache: stats.cachedFiles.filter(f => f.startsWith(`[${lang}]`)).length,
+          newlyTranslated: stats.processedFiles.filter(f => f.startsWith(`[${lang}]`)).length,
+          failed: stats.failedFiles.filter(f => f.startsWith(`[${lang}]`)).length
+        })),
+        details: `Translated ${allFiles.length} pages to ${languages.length} languages (${languages.join(', ')})\n\n### Language Breakdown:\n${languages.map(lang => {
+          const langStats = {
+            total: stats.totalProcessed / languages.length,
+            fromCache: stats.cachedFiles.filter(f => f.startsWith(`[${lang}]`)).length,
+            newlyTranslated: stats.processedFiles.filter(f => f.startsWith(`[${lang}]`)).length,
+            failed: stats.failedFiles.filter(f => f.startsWith(`[${lang}]`)).length
+          };
+          return `**${lang.toUpperCase()}:** ${langStats.total} total (${langStats.fromCache} cached, ${langStats.newlyTranslated} new${langStats.failed > 0 ? `, ${langStats.failed} failed` : ''})`;
+        }).join('\n')}\n\n### Files from cache:\n${stats.cachedFiles.length > 0 ? stats.cachedFiles.slice(0, 10).map(f => `- ${f}`).join('\n') + (stats.cachedFiles.length > 10 ? `\n- ... and ${stats.cachedFiles.length - 10} more` : '') : 'None'}\n\n### Newly translated files:\n${stats.processedFiles.length > 0 ? stats.processedFiles.slice(0, 10).map(f => `- ${f}`).join('\n') + (stats.processedFiles.length > 10 ? `\n- ... and ${stats.processedFiles.length - 10} more` : '') : 'None'}${stats.failedFiles.length > 0 ? `\n\n### Failed translations:\n${stats.failedFiles.slice(0, 10).map(f => `- ${f}`).join('\n') + (stats.failedFiles.length > 10 ? `\n- ... and ${stats.failedFiles.length - 10} more` : '')}` : ''}`
       }
     });
   }

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

@@ -150,49 +150,20 @@ class GitHubCache {
     const readme = options.stats ? this.generateReadme(options.stats) : 
                    options.branchReadme || this.generateDefaultReadme();
 
-    // If forceRecreate is true, use safe replacement strategy
+    // If forceRecreate is true, we'll handle it in uploadFilesViaGit
     if (forceRecreate) {
-      const tempBranch = `${this.branchName}-temp-${Date.now()}`;
-      const originalBranch = this.branchName;
-      
-      try {
-        this.logger.log(`🔄 Creating temporary branch for safe replacement...`);
-        
-        // Temporarily use temp branch name
-        this.branchName = tempBranch;
-        
-        // Create new branch with clean files
-        await this.ensureBranchExists(readme);
-        const uploadedCount = await this.uploadFilesViaGit(files, true, readme);
-        
-        // Restore original branch name
-        this.branchName = originalBranch;
-        
-        // Atomically replace old branch with new one
-        await this.replaceBranch(tempBranch, originalBranch);
-        
-        this.logger.log(`🎉 Safely replaced cache branch with ${uploadedCount} file(s)`);
-        return uploadedCount;
-      } catch (error) {
-        // Restore original branch name
-        this.branchName = originalBranch;
-        
-        // Try to clean up temp branch if it exists
-        try {
-          await this.deleteBranch(tempBranch);
-        } catch (e) {
-          // Ignore cleanup errors
-        }
-        
-        this.logger.error(`❌ Failed to recreate cache branch, original remains intact`);
-        throw error;
-      }
+      this.logger.log(`🔄 Force recreating cache branch with clean files...`);
+      const uploadedCount = await this.uploadFilesViaGit(files, true, readme);
+      this.logger.log(`🎉 Recreated cache branch with ${uploadedCount} file(s)`);
+      return uploadedCount;
     } else {
       // Normal update
       await this.ensureBranchExists(readme);
       const uploadedCount = await this.uploadFilesViaGit(files, false, readme);
       
-      this.logger.log(`🎉 Pushed ${uploadedCount} file(s) to cache branch`);
+      if (uploadedCount > 0) {
+        this.logger.log(`🎉 Pushed ${uploadedCount} file(s) to cache branch`);
+      }
       return uploadedCount;
     }
   }
@@ -399,87 +370,117 @@ class GitHubCache {
   // Upload files using git commands (much faster for multiple files)
   async uploadFilesViaGit(files, forceRecreate = false, readme = null) {
     const { execSync } = require('child_process');
-    const tempDir = path.join(this.cacheDir, '../git-temp');
     
     this.logger.log(`🚀 Using fast git upload for ${files.length} files`);
     
     try {
-      // Clean and create temp directory
-      jetpack.remove(tempDir);
-      jetpack.dir(tempDir);
+      // Work directly in the cache directory
+      const gitDir = path.join(this.cacheDir, '.git');
       
       if (forceRecreate) {
-        // For force recreate, just init a new repo
-        this.logger.log(`🆕 Initializing fresh repository...`);
-        execSync('git init', { cwd: tempDir, stdio: 'ignore' });
-        execSync(`git remote add origin https://${process.env.GH_TOKEN}@github.com/${this.owner}/${this.repo}.git`, { cwd: tempDir, stdio: 'ignore' });
-        execSync(`git checkout -b ${this.branchName}`, { cwd: tempDir, stdio: 'ignore' });
-      } else {
-        // Clone the branch (shallow clone for speed)
-        this.logger.log(`📥 Cloning cache branch...`);
+        // For force recreate, remove git dir and init fresh
+        this.logger.log(`🆕 Initializing fresh repository in ${this.cacheDir}...`);
+        jetpack.remove(gitDir);
+        execSync('git init', { cwd: this.cacheDir, stdio: 'ignore' });
+        execSync(`git remote add origin https://${process.env.GH_TOKEN}@github.com/${this.owner}/${this.repo}.git`, { cwd: this.cacheDir, stdio: 'ignore' });
+        execSync(`git checkout -b ${this.branchName}`, { cwd: this.cacheDir, stdio: 'ignore' });
+      } 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 .`,
-          { cwd: tempDir, stdio: 'ignore' }
+          `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 });
+          jetpack.remove(tempBackup);
+        }
+      } else {
+        // Git dir exists, just pull latest
+        this.logger.log(`📥 Pulling latest changes...`);
+        try {
+          execSync('git fetch origin ' + this.branchName, { cwd: this.cacheDir, stdio: 'ignore' });
+          execSync('git reset --hard origin/' + this.branchName, { cwd: this.cacheDir, stdio: 'ignore' });
+        } catch (e) {
+          // If pull fails, continue anyway - we'll force push if needed
+          this.logger.warn('⚠️ Pull failed, will force push if needed');
+        }
       }
       
       // Add README if provided
+      let readmeChanged = false;
       if (readme) {
-        const readmePath = path.join(tempDir, 'README.md');
-        jetpack.write(readmePath, readme);
-      }
-      
-      // Copy all files to the temp directory
-      let copiedCount = 0;
-      for (const filePath of files) {
-        const fullPath = path.resolve(filePath);
-        if (!jetpack.exists(fullPath)) {
-          continue;
-        }
+        const readmePath = path.join(this.cacheDir, 'README.md');
+        const existingReadme = jetpack.exists(readmePath) ? jetpack.read(readmePath) : '';
         
-        // Get relative path from cache directory
-        const relativePath = path.relative(this.cacheDir, fullPath);
-        if (relativePath.startsWith('..')) {
-          continue;
+        if (existingReadme !== readme) {
+          this.logger.log('📝 README content has changed, updating...');
+          readmeChanged = true;
         }
         
-        const destPath = path.join(tempDir, relativePath);
-        jetpack.copy(fullPath, destPath, { overwrite: true });
-        copiedCount++;
+        jetpack.write(readmePath, readme);
       }
       
       // Check if there are changes
-      const status = execSync('git status --porcelain', { cwd: tempDir }).toString();
+      const status = execSync('git status --porcelain', { cwd: this.cacheDir }).toString();
       if (!status.trim()) {
-        this.logger.log('⏭️  No changes to commit');
+        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) {
+        this.logger.log('📄 Only README.md has changed, committing update...');
+      } else if (readmeChanged) {
+        this.logger.log(`📄 README.md and ${changedFiles - 1} cache files have changed`);
+      } else {
+        this.logger.log(`📝 ${changedFiles} files have changed`);
+      }
+      
       // Add all changes
-      this.logger.log(`📝 Staging ${copiedCount} files...`);
-      execSync('git add -A', { cwd: tempDir, stdio: 'ignore' });
+      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) {
+        commitMessage = '📊 Update cache statistics in README';
+      } else if (readmeChanged) {
+        commitMessage = `📦 Update cache: ${changedFiles - 1} files + README stats`;
+      } else {
+        commitMessage = `📦 Update cache: ${changedFiles} files`;
+      }
       
       // Commit
       execSync(
-        `git -c user.name="GitHub Actions" -c user.email="actions@github.com" commit -m "📦 Update cache: ${copiedCount} files"`,
-        { cwd: tempDir, stdio: 'ignore' }
+        `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...`);
-      if (forceRecreate) {
-        execSync('git push --force --set-upstream origin ' + this.branchName, { cwd: tempDir, stdio: 'ignore' });
-      } else {
-        execSync('git push', { cwd: tempDir, stdio: 'ignore' });
+      try {
+        execSync('git push origin ' + this.branchName, { cwd: this.cacheDir, stdio: 'ignore' });
+      } catch (e) {
+        // If normal push fails, try force push
+        this.logger.warn('⚠️ Normal push failed, attempting force push...');
+        execSync('git push --force origin ' + this.branchName, { cwd: this.cacheDir, stdio: 'ignore' });
       }
       
-      // Clean up
-      jetpack.remove(tempDir);
-      
-      return copiedCount;
+      return changedFiles;
     } catch (error) {
       this.logger.error(`❌ Git command failed: ${error.message}`);
-      jetpack.remove(tempDir);
       throw error; // No fallback - git is required
     }
   }
@@ -587,6 +588,25 @@ This branch stores ${this.description}.
       }
     }
 
+    // Add language breakdown for translation
+    if (stats.languageBreakdown && stats.languageBreakdown.length > 0) {
+      readme += `
+## Language Breakdown
+
+`;
+      stats.languageBreakdown.forEach(lang => {
+        const cacheRate = lang.total > 0 ? ((lang.fromCache / lang.total) * 100).toFixed(1) : 0;
+        readme += `### ${lang.language.toUpperCase()}\n`;
+        readme += `- **Total Files:** ${Math.round(lang.total)}\n`;
+        readme += `- **From Cache:** ${lang.fromCache} (${cacheRate}%)\n`;
+        readme += `- **Newly Translated:** ${lang.newlyTranslated}\n`;
+        if (lang.failed > 0) {
+          readme += `- **Failed:** ${lang.failed}\n`;
+        }
+        readme += '\n';
+      });
+    }
+
     // Add token usage and costs for translation
     if (stats.tokenUsage) {
       const { inputTokens, outputTokens, totalTokens, inputCost, outputCost, totalCost } = stats.tokenUsage;

package/dist/gulp/tasks/webpack.js

@@ -67,12 +67,11 @@ const delay = 250;
 // Bundle naming configuration
 const bundleNaming = {
   // Files that should have stable (non-hashed) names
-  stable: {
-    exact: ['main', 'project', 'service-worker'],
-    patterns: [
-      /^modules\//,  // All module files get stable names
-    ]
-  },
+  stable: [
+    /^main$/,                      // Main bundle
+    /^service-worker$/,            // Service worker
+    /^modules\//,                  // All module files get stable names
+  ],
   // Special output paths (relative to dist/assets/js/)
   specialPaths: {
     'service-worker': '../../service-worker.js'
@@ -221,13 +220,7 @@ const settings = {
 
 // Helper function to determine if a bundle should have a stable name
 function shouldHaveStableName(name) {
-  // Check exact matches
-  if (bundleNaming.stable.exact.includes(name)) {
-    return true;
-  }
-
-  // Check patterns
-  return bundleNaming.stable.patterns.some(pattern => pattern.test(name));
+  return bundleNaming.stable.some(pattern => pattern.test(name));
 }
 
 // Task
@@ -360,37 +353,18 @@ function updateEntryPoints(inputArray) {
 
   // Update from src
   const entries = files.reduce((acc, file) => {
-    const isProject = file.startsWith(rootPathProject);
-    const root = isProject ? rootPathProject : rootPathPackage;
-    const relativePath = path.relative(root, file).replace(/\\/g, '/').replace(/\.js$/, '');
-
-    // Remove known base paths
-    let name = relativePath
-      .replace(/^dist\/assets\/js\//, '')
-      .replace(/^src\/assets\/js\//, '')
-      .replace(/^src\//, '');
+    let name;
 
     // Determine naming based on file type
-    if (name.includes('pages/')) {
-      // Pages: add .main or .project suffix
-      name += isProject ? '.project' : '.main';
-    } else if (name.includes('modules/')) {
-      // Modules: keep the full path structure for clarity
-      // This ensures modules/redirect becomes modules/redirect
-      // and modules/analytics/tracker becomes modules/analytics/tracker
+    if (file.includes('/assets/js/modules/')) {
+      name = file.split('/assets/js/')[1];
     } else {
       // Everything else: just use the base filename
-      name = path.basename(name);
+      name = path.basename(file);
     }
 
-    // Don't include pages in the entry points
-    // if (
-    //   file.includes('assets/js/pages/')
-    //   || file.includes('assets/js/global.js')
-    //   || file.includes('assets/themes/')
-    // ) {
-    //   return acc;
-    // }
+    // Strip .js extension
+    name = name.replace(/\.js$/, '');
 
     // Update entry points
     acc[name] = file;

package/package.json

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