ultimate-jekyll-manager 0.0.213 → 0.0.215

package/dist/commands/setup.js

@@ -1,15 +1,13 @@
 // Libraries
 const Manager = new (require('../build.js'));
 const logger = Manager.logger('setup');
-const argv = Manager.getArguments();
 const path = require('path');
 const jetpack = require('fs-jetpack');
 const version = require('wonderful-version');
 const fetch = require('wonderful-fetch');
-const { execute, template } = require('node-powertools');
+const { execute } = require('node-powertools');
 const NPM = require('npm-api');
 const glob = require('glob').globSync;
-const { minimatch } = require('minimatch');
 const detectGitHubRepository = require('../gulp/tasks/utils/detect-github-repo');
 const { Octokit } = require('@octokit/rest');
 const sodium = require('libsodium-wrappers');
@@ -21,7 +19,7 @@ let config = Manager.getConfig('project');
 const rootPathPackage = Manager.getRootPath('main');
 const rootPathProject = Manager.getRootPath('project');
 
-// Dependency MAP
+// Map of dependencies that should be installed as devDependencies
 const DEPENDENCY_MAP = {
   'gulp': 'dev',
 }
@@ -31,17 +29,15 @@ module.exports = async function (options) {
   options = options || {};
   options.checkManager = options.checkManager !== 'false';
   options.checkNode = options.checkNode !== 'false';
-  options.checkBundler = options.checkBundler !== 'false';
   options.checkRuby = options.checkRuby !== 'false';
+  options.checkBundle = options.checkBundle !== 'false';
   options.checkPeerDependencies = options.checkPeerDependencies !== 'false';
   options.setupScripts = options.setupScripts !== 'false';
   options.ensureCoreFiles = options.ensureCoreFiles !== 'false';
   options.createCname = options.createCname !== 'false';
   options.fetchFirebaseAuth = options.fetchFirebaseAuth !== 'false';
   options.checkLocality = options.checkLocality !== 'false';
-  options.updateBundle = options.updateBundle !== 'false';
   options.publishGitHubToken = options.publishGitHubToken !== 'false';
-  options.updateGitHubPages = options.updateGitHubPages !== 'false';
   options.deduplicatePosts = options.deduplicatePosts !== 'false';
   options.migrate = options.migrate !== 'false';
 
@@ -53,139 +49,114 @@ module.exports = async function (options) {
   project.dependencies = project.dependencies || {};
   project.devDependencies = project.devDependencies || {};
 
-  try {
-    // Log current working directory
-    await logCWD();
-
-    // Run migrations
-    if (options.migrate) {
-      await migrate();
-    }
+  // Log current working directory
+  logger.log('Current working directory:', process.cwd());
 
-    // Detect GitHub repository early so it's available to all tasks/functions
-    await detectGitHubRepository(logger);
+  // Run migrations
+  if (options.migrate) {
+    await migrate();
+  }
 
-    // Ensure this package is up-to-date
-    if (options.checkManager) {
-      await updateManager();
-    }
+  // Detect GitHub repository early so it's available to all tasks/functions
+  await detectGitHubRepository(logger);
 
-    // Ensure proper node version
-    if (options.checkNode) {
-      await ensureNodeVersion();
-    }
+  // --- Version checks ---
 
-    // Ensure proper bundler version
-    if (options.checkBundler) {
-      await ensureBundlerVersion();
-    }
+  // Ensure this package is up-to-date
+  if (options.checkManager) {
+    await ensureManagerVersion();
+  }
 
-    // Ensure proper ruby version
-    if (options.checkRuby) {
-      await ensureRubyVersion();
-    }
+  // Ensure proper node version
+  if (options.checkNode) {
+    await ensureNodeVersion();
+  }
 
-    // Run the setup
-    if (options.checkPeerDependencies) {
-      await ensurePeerDependencies();
-    }
+  // Ensure proper ruby version
+  if (options.checkRuby) {
+    await ensureRubyVersion();
+  }
 
-    // Setup scripts
-    if (options.setupScripts) {
-      await setupScripts();
-    }
+  // Ensure proper bundler version + install/update gems
+  if (options.checkBundle) {
+    await ensureBundle();
+  }
 
-    // Copy all files from src/defaults/dist on first run
-    // await copyDefaultDistFiles();
+  // Ensure peer dependencies are installed
+  if (options.checkPeerDependencies) {
+    await ensurePeerDependencies();
+  }
 
-    // Ensure _config.yml exists
-    if (options.ensureCoreFiles) {
-      await ensureCoreFiles();
-    }
+  // --- Project setup ---
 
-    // Create CNAME
-    if (options.createCname) {
-      await createCname();
-    }
+  // Setup scripts in package.json
+  if (options.setupScripts) {
+    setupScripts();
+  }
 
-    // Fetch firebase-auth files
-    if (options.fetchFirebaseAuth) {
-      await fetchFirebaseAuth(options);
-    }
+  // Ensure _config.yml exists
+  if (options.ensureCoreFiles) {
+    await ensureCoreFiles();
+  }
 
-    // Check which locality we are using
-    if (options.checkLocality) {
-      await checkLocality();
-    }
+  // Create CNAME file
+  if (options.createCname) {
+    createCname();
+  }
 
-    // Publish GH_TOKEN as repository secret
-    if (options.publishGitHubToken) {
-      await publishGitHubToken();
-    }
+  // Fetch firebase-auth files
+  if (options.fetchFirebaseAuth) {
+    await fetchFirebaseAuth();
+  }
 
-    // Update GitHub Pages settings
-    // if (options.updateGitHubPages) {
-    //   await updateGitHubPages(options);
-    // }
+  // Warn if using local version
+  if (options.checkLocality) {
+    checkLocality();
+  }
 
-    // Check which locality we are using
-    if (options.updateBundle && !Manager.isServer()) {
-      await updateBundle();
-    }
+  // Publish GH_TOKEN as repository secret
+  if (options.publishGitHubToken) {
+    await publishGitHubToken();
+  }
 
-    // Deduplicate posts (remove duplicate posts with same slug but different dates)
-    if (options.deduplicatePosts) {
-      await deduplicatePosts();
-    }
-  } catch (e) {
-    // Throw error
-    throw e;
+  // Deduplicate posts (remove duplicate posts with same slug but different dates)
+  if (options.deduplicatePosts) {
+    await deduplicatePosts();
   }
 };
 
-async function logCWD() {
-  logger.log('Current working directory:', process.cwd());
-  // logger.log('Current working directory 2:', await execute('pwd'));
-  // logger.log('Current working directory 3:', await execute('ls -al'));
-}
+// --- Version check functions ---
 
-async function updateManager() {
+async function ensureManagerVersion() {
   const npm = new NPM();
-
-  // Get the latest version
   const installedVersion = project.devDependencies[package.name];
-  const latestVersion = await npm.repo(package.name)
-  .package()
-    .then((pkg) => {
-      return pkg.version;
-    }, (e) => {
-      return '0.0.0';
-    });
-  const isUpToDate = version.is(installedVersion, '>=', latestVersion);
-  const levelDifference = version.levelDifference(installedVersion, latestVersion);
 
-  // Check if installedVersion is truthy or throw error
   if (!installedVersion) {
     throw new Error(`No installed version of ${package.name} found in devDependencies.`);
   }
 
-  // Log
-  logVersionCheck(package.name, installedVersion, latestVersion, isUpToDate);
-
-  // Quit if local
+  // Skip if local
   if (installedVersion.startsWith('file:')) {
+    logVersionCheck(package.name, installedVersion, installedVersion, true);
     return;
   }
 
-  // Check if we need to update
+  const latestVersion = await npm.repo(package.name)
+    .package()
+    .then((pkg) => pkg.version, () => '0.0.0');
+
+  const isUpToDate = version.is(installedVersion, '>=', latestVersion);
+
+  logVersionCheck(package.name, installedVersion, latestVersion, isUpToDate);
+
   if (!isUpToDate) {
-    // Quit if major version difference
+    const levelDifference = version.levelDifference(installedVersion, latestVersion);
+
     if (levelDifference === 'major' && installedVersion !== 'latest') {
       return logger.error(`Major version difference detected. Please update to ${latestVersion} manually.`);
     }
 
-    // Install the latest version
-    await install(package.name, latestVersion);
+    await npmInstall(package.name, latestVersion);
   }
 }
 
@@ -194,353 +165,235 @@ async function ensureNodeVersion() {
   const requiredVersion = version.clean(package.engines.node);
   const isUpToDate = version.is(installedVersion, '>=', requiredVersion);
 
-  // Log
   logVersionCheck('Node.js', installedVersion, requiredVersion, isUpToDate);
 
-  // Check if we need to update
   if (!isUpToDate) {
     throw new Error(`Node version is out-of-date. Required version is ${requiredVersion}.`);
   }
 }
 
-async function ensureBundlerVersion() {
+async function ensureRubyVersion() {
   const installedVersion = version.clean(
-    (await execute('bundler -v', { log: false })).match(/(\d+\.\d+\.\d+)/)[0]
+    (await execute('ruby -v', { log: false })).match(/(\d+\.\d+\.\d+)/)[0]
   );
-  const requiredVersion = version.clean(package.engines.bundler);
+  const requiredVersion = version.clean(package.engines.ruby);
   const isUpToDate = version.is(installedVersion, '>=', requiredVersion);
 
-  // Log
-  logVersionCheck('Bundler', installedVersion, requiredVersion, isUpToDate);
+  logVersionCheck('Ruby', installedVersion, requiredVersion, isUpToDate);
 
-  // Check if we need to update
   if (!isUpToDate) {
-    logger.log(`Bundler is out-of-date. Installing version ${requiredVersion}...`);
-    await execute(`gem install bundler -v ${requiredVersion}`, { log: true });
+    throw new Error(`Ruby version is out-of-date. Required version is ${requiredVersion}.`);
   }
 }
 
-async function ensureRubyVersion() {
+async function ensureBundle() {
+  // Check bundler gem version
   const installedVersion = version.clean(
-    (await execute('ruby -v', { log: false })).match(/(\d+\.\d+\.\d+)/)[0]
+    (await execute('bundler -v', { log: false })).match(/(\d+\.\d+\.\d+)/)[0]
   );
-  const requiredVersion = version.clean(package.engines.ruby);
+  const requiredVersion = version.clean(package.engines.bundler);
   const isUpToDate = version.is(installedVersion, '>=', requiredVersion);
 
-  // Log
-  logVersionCheck('Ruby', installedVersion, requiredVersion, isUpToDate);
+  logVersionCheck('Bundler', installedVersion, requiredVersion, isUpToDate);
 
-  // Check if we need to update
+  // Install bundler gem + update Gemfile.lock if needed
   if (!isUpToDate) {
-    throw new Error(`Ruby version is out-of-date. Required version is ${requiredVersion}.`);
+    logger.log(`Bundler is out-of-date. Installing version ${requiredVersion}...`);
+    await execute(`gem install bundler -v ${requiredVersion}`, { log: true });
+    await execute(`bundle update --bundler`, { log: true });
+  }
+
+  // Skip bundle install/update on server
+  if (Manager.isServer()) {
+    return;
   }
+
+  // Install and update gems
+  logger.log('Running bundle install...');
+  await execute('bundle install', { log: true });
+
+  logger.log('Running bundle update...');
+  await execute('bundle update --all', { log: true });
 }
 
 async function ensurePeerDependencies() {
   const requiredPeerDependencies = package.peerDependencies || {};
 
-  // Loop through and make sure project has AT LEAST the required version
   for (let [dependency, ver] of Object.entries(requiredPeerDependencies)) {
     const projectDependencyVersion = version.clean(project?.dependencies?.[dependency] || project?.devDependencies?.[dependency]);
     const location = DEPENDENCY_MAP[dependency] === 'dev' ? '--save-dev' : '';
-    const isUpToDate = version.is(projectDependencyVersion, '>=', ver);
 
-    // Clean version if needed
     ver = version.clean(ver);
 
-    // Log
-    // logger.log('Checking peer dep:', dependency, '-->', projectDependencyVersion, '>=', ver);
+    const isUpToDate = version.is(projectDependencyVersion, '>=', ver);
     logVersionCheck(dependency, projectDependencyVersion, ver, isUpToDate);
 
-    // Install if not found
-    if (
-      // Not found
-      !projectDependencyVersion
-      // Not the right version
-      || !isUpToDate
-    ) {
-      await install(dependency, ver, location);
+    if (!projectDependencyVersion || !isUpToDate) {
+      await npmInstall(dependency, ver, location);
     }
   }
 }
 
+// --- Project setup functions ---
+
 function setupScripts() {
-  // Setup the scripts
   project.scripts = project.scripts || {};
 
-  // Setup the scripts
   Object.keys(package.projectScripts).forEach((key) => {
     project.scripts[key] = package.projectScripts[key];
   });
 
-  // Save the project
   jetpack.write(path.join(process.cwd(), 'package.json'), project);
 }
 
 async function ensureCoreFiles() {
-  // Ensure src/_config.yml exists
-  if (!jetpack.exists('src/_config.yml')) {
-    // Log
-    logger.log('No src/_config.yml found. Creating default config file...');
-
-    // Copy default _config.yml
-    const sourcePath = path.join(rootPathPackage, 'dist/defaults/src/_config.yml');
-    const targetPath = path.join(rootPathProject, 'src/_config.yml');
-
-    jetpack.copy(sourcePath, targetPath);
-    logger.log(`Copied default _config.yml to src/_config.yml`);
-
-    // Inject new config into config variable
-    config = Manager.getConfig('project');
-
-    // Run gulp defaults task since this is likely the first run
-    await execute('UJ_BUILD_MODE=true npm run gulp -- defaults', { log: true });
-  }
-}
-
-function checkLocality() {
-  const installedVersion = project.devDependencies[package.name];
-
-  // Check if installedVersion is truthy or throw error
-  if (!installedVersion) {
-    throw new Error(`No installed version of ${package.name} found in devDependencies.`);
-  }
-
-  // Log if local
-  if (installedVersion.startsWith('file:')) {
-    logger.warn(`⚠️⚠️⚠️ You are using the local version of ${package.name}. This WILL NOT WORK when published. ⚠️⚠️⚠️`);
+  if (jetpack.exists('src/_config.yml')) {
+    return;
   }
-}
-
-async function updateBundle() {
-  // Log
-  logger.log('Running bundle install...');
-  await execute('bundle install', { log: true })
-
-  // Log
-  logger.log('Running bundle update...');
-  await execute('bundle update --all', { log: true })
-}
 
-function install(package, ver, location) {
-  // Default to latest
-  ver || 'latest';
+  logger.log('No src/_config.yml found. Creating default config file...');
 
-  // Clean version if needed
-  ver = ver === 'latest' ? ver : version.clean(ver);
-
-  // Build the command
-  let command = `npm install ${package}@${ver} ${location || '--save'}`;
-
-  // Log
-  logger.log('Installing:', command);
+  const sourcePath = path.join(rootPathPackage, 'dist/defaults/src/_config.yml');
+  const targetPath = path.join(rootPathProject, 'src/_config.yml');
 
-  // Execute
-  return execute(command, { log: true })
-  .then(async () => {
-    // Read new project
-    const projectUpdated = jetpack.read(path.join(process.cwd(), 'package.json'), 'json');
+  jetpack.copy(sourcePath, targetPath);
+  logger.log(`Copied default _config.yml to src/_config.yml`);
 
-    // Log
-    logger.log('Installed:', package, ver);
+  // Inject new config into config variable
+  config = Manager.getConfig('project');
 
-    // Update package object
-    project.dependencies = projectUpdated.dependencies;
-    project.devDependencies = projectUpdated.devDependencies;
-  });
+  // Run gulp defaults task since this is likely the first run
+  await execute('UJ_BUILD_MODE=true npm run gulp -- defaults', { log: true });
 }
 
-// Create CNAME
-async function createCname() {
-  // Get the CNAME
+function createCname() {
   const url = config.url || 'https://ultimate-jekyll.itwcreativeworks.com';
-  const host = new URL(url).host
+  const host = new URL(url).host;
 
-  // Write to file
   jetpack.write('dist/CNAME', host);
-
-  // Log
   logger.log('Created CNAME');
 }
 
-// Fetch firebase-auth files
 async function fetchFirebaseAuth() {
   const app = config.web_manager.firebase.app.config || {};
-  const base = `https://${app.projectId}.firebaseapp.com`;
 
-  // Throw error if no project ID
   if (!app.projectId) {
-    // if (options.skipFirebaseIdCheck) {
-    //   return;
-    // }
-    // throw new Error('No Firebase project ID found in config.web_manager.firebase.app.config.projectId');
-    logger.warn('⚠️  Skipping fetchFirebaseAuth due to missing Firebase project ID.');
+    logger.warn('Skipping fetchFirebaseAuth due to missing Firebase project ID.');
     return;
   }
 
+  const base = `https://${app.projectId}.firebaseapp.com`;
+  const output = './dist';
+
   const files = [
-    {
-      remote: '__/auth/handler',
-      filename: 'handler.html',
-    },
-    {
-      remote: '__/auth/handler.js',
-    },
-    {
-      remote: '__/auth/experiments.js',
-    },
+    { remote: '__/auth/handler', filename: 'handler.html' },
+    { remote: '__/auth/handler.js' },
+    { remote: '__/auth/experiments.js' },
     {
       remote: '__/auth/iframe',
       filename: 'iframe.html',
-      replace: (content) => {
-        return content.replace('src="iframe.js"', 'src="iframe.js?cb={{ site.uj.cache_breaker }}"');
-      }
-    },
-    {
-      remote: '__/auth/iframe.js',
+      replace: (content) => content.replace('src="iframe.js"', 'src="iframe.js?cb={{ site.uj.cache_breaker }}"'),
     },
-    {
-      remote: '__/firebase/init.json',
-    }
-  ]
-  const promises = [];
-  const output = './dist';
+    { remote: '__/auth/iframe.js' },
+    { remote: '__/firebase/init.json' },
+  ];
 
-  // Loop through files
-  files.forEach((file) => {
-    // Get the remote URL
-    const url = `${base}/${file.remote}`;
+  logger.log('Fetching firebase-auth files...');
 
-    // Get the local path
+  const promises = files.map((file) => {
+    const url = `${base}/${file.remote}`;
     const fileName = file.filename
       ? path.basename(file.filename)
       : path.basename(file.remote);
     const filePath = path.join(path.dirname(file.remote), fileName);
     const finalPath = path.join(output, filePath);
 
-    // Push to promises
-    promises.push(
-      fetch(url, {
-        response: 'text',
-        tries: 3,
-        // log: true,
-      })
+    return fetch(url, { response: 'text', tries: 3 })
       .then((r) => {
-        // Apply replace function if it exists
-        if (file.replace && typeof file.replace === 'function') {
+        if (file.replace) {
           r = file.replace(r);
         }
 
-        // Log success for this file
         logger.log(`Fetched: ${file.remote}`);
 
-        // Write to file
         jetpack.write(finalPath,
           '---\n'
           + `permalink: /${file.remote}\n`
           + '---\n'
           + '\n'
           + r
-        )
+        );
       })
       .catch((error) => {
-        // Only log the filename that failed, not the error content
-        logger.error(`❌ Failed to fetch: ${file.remote}`);
+        logger.error(`Failed to fetch: ${file.remote}`);
         logger.error(`   URL: ${url}`);
 
-        // Check if it's a specific type of error (not HTML response)
-        // Use regex to check case-insensitive for HTML content
         const htmlPattern = /<!doctype|<html|<head|<body/i;
         if (error.message && !htmlPattern.test(error.message)) {
           logger.error(`   Error: ${error.message}`);
         }
 
-        // Re-throw to make Promise.all fail
         throw new Error(`Failed to fetch Firebase auth file: ${file.remote}`);
-      })
-    );
+      });
   });
 
-  // Log
-  logger.log('Fetching firebase-auth files...');
-
   try {
-    // Await all promises
     await Promise.all(promises);
-
-    // Log success
-    logger.log('✅ Fetched firebase-auth files');
+    logger.log('Fetched firebase-auth files');
   } catch (error) {
-    // Check if we should skip Firebase auth errors
     if (process.env.UJ_SKIP_FIREBASE_AUTH_ERRORS === 'true') {
-      logger.warn('⚠️  Failed to fetch some Firebase auth files, but continuing due to UJ_SKIP_FIREBASE_AUTH_ERRORS=true');
+      logger.warn('Failed to fetch some Firebase auth files, but continuing due to UJ_SKIP_FIREBASE_AUTH_ERRORS=true');
       return;
     }
 
-    // Error already logged above, just throw to stop execution
     throw new Error('Failed to fetch one or more Firebase auth files. Please check your Firebase project configuration.');
   }
 }
 
-function logVersionCheck(name, installedVersion, latestVersion, isUpToDate) {
-  // Quit if local
-  if (installedVersion.startsWith('file:')) {
-    isUpToDate = true;
+function checkLocality() {
+  const installedVersion = project.devDependencies[package.name];
+
+  if (!installedVersion) {
+    throw new Error(`No installed version of ${package.name} found in devDependencies.`);
   }
 
-  // Log
-  logger.log(`Checking if ${name} is up to date (${logger.format.bold(installedVersion)} >= ${logger.format.bold(latestVersion)}): ${isUpToDate ? logger.format.green('Yes') : logger.format.red('No')}`);
+  if (installedVersion.startsWith('file:')) {
+    logger.warn(`You are using the local version of ${package.name}. This WILL NOT WORK when published.`);
+  }
 }
 
-// Publish GH_TOKEN as repository secret
 async function publishGitHubToken() {
-  // Check if GH_TOKEN is available
   if (!process.env.GH_TOKEN) {
-    logger.warn('⚠️  GH_TOKEN not found in environment variables. Skipping secret publication.');
+    logger.warn('GH_TOKEN not found in environment variables. Skipping secret publication.');
     return;
   }
 
-  // Check if GITHUB_REPOSITORY is available
   if (!process.env.GITHUB_REPOSITORY) {
-    logger.warn('⚠️  GITHUB_REPOSITORY not detected. Skipping secret publication.');
+    logger.warn('GITHUB_REPOSITORY not detected. Skipping secret publication.');
     return;
   }
 
-  // Quit if in build mode
   if (Manager.isBuildMode()) {
-    logger.log('⚠️  Skipping GH_TOKEN publication in build mode.');
+    logger.log('Skipping GH_TOKEN publication in build mode.');
     return;
   }
 
   try {
-    // Parse owner and repo
     const [owner, repo] = process.env.GITHUB_REPOSITORY.split('/');
 
-    // Initialize Octokit
-    const octokit = new Octokit({
-      auth: process.env.GH_TOKEN,
-    });
+    const octokit = new Octokit({ auth: process.env.GH_TOKEN });
 
-    logger.log(`🔐 Publishing GH_TOKEN as repository secret for ${owner}/${repo}...`);
+    logger.log(`Publishing GH_TOKEN as repository secret for ${owner}/${repo}...`);
 
-    // Initialize sodium
     await sodium.ready;
 
-    // Get repository public key for encrypting secrets
-    const { data: publicKeyData } = await octokit.actions.getRepoPublicKey({
-      owner,
-      repo,
-    });
+    const { data: publicKeyData } = await octokit.actions.getRepoPublicKey({ owner, repo });
 
-    // Convert secret to Uint8Array
     const secretBytes = Buffer.from(process.env.GH_TOKEN);
     const keyBytes = Buffer.from(publicKeyData.key, 'base64');
-
-    // Encrypt the secret using libsodium
     const encryptedBytes = sodium.crypto_box_seal(secretBytes, keyBytes);
     const encryptedValue = Buffer.from(encryptedBytes).toString('base64');
 
-    // Create or update the repository secret
     await octokit.actions.createOrUpdateRepoSecret({
       owner,
       repo,
@@ -549,139 +402,16 @@ async function publishGitHubToken() {
       key_id: publicKeyData.key_id,
     });
 
-    logger.log(`✅ Successfully published GH_TOKEN as repository secret`);
-  } catch (error) {
-    logger.error(`❌ Failed to publish GH_TOKEN as repository secret: ${error.message}`);
-    // Don't throw - this is not critical for setup to continue
-  }
-}
-
-// Update GitHub Pages settings
-async function updateGitHubPages(options) {
-  options = options || {};
-
-  // Check if GH_TOKEN is available
-  if (!process.env.GH_TOKEN) {
-    logger.warn('⚠️  GH_TOKEN not found in environment variables. Skipping GitHub Pages update.');
-    return;
-  }
-
-  // Check if GITHUB_REPOSITORY is available
-  if (!process.env.GITHUB_REPOSITORY) {
-    logger.warn('⚠️  GITHUB_REPOSITORY not detected. Skipping GitHub Pages update.');
-    return;
-  }
-
-  // Quit if in build mode
-  if (Manager.isBuildMode()) {
-    logger.log('⚠️  Skipping GitHub Pages update in build mode.');
-    return;
-  }
-
-  try {
-    // Parse owner and repo
-    const [owner, repo] = process.env.GITHUB_REPOSITORY.split('/');
-
-    // Initialize Octokit
-    const octokit = new Octokit({
-      auth: process.env.GH_TOKEN,
-    });
-
-    logger.log(`📄 Configuring GitHub Pages for ${owner}/${repo}...`);
-
-    // Get current repository info to check if Pages is already enabled
-    let pagesInfo;
-    try {
-      const { data } = await octokit.repos.getPages({
-        owner,
-        repo,
-      });
-      pagesInfo = data;
-      logger.log('GitHub Pages already enabled, updating configuration...');
-    } catch (error) {
-      if (error.status === 404) {
-        logger.log('GitHub Pages not yet enabled, creating Pages site...');
-        pagesInfo = null;
-      } else {
-        throw error;
-      }
-    }
-
-    // Determine the source configuration
-    const sourceConfig = options.source || { branch: 'gh-pages', path: '/' };
-
-    // If custom domain is provided in config, use it
-    const customDomain = options.customDomain || (config.url ? new URL(config.url).host : null);
-
-    // Build options for API call
-    const pagesOptions = {
-      owner,
-      repo,
-      source: sourceConfig,
-  };
-
-    // Add custom domain if available and not github.io domain
-    if (customDomain && !customDomain.includes('github.io')) {
-      pagesOptions.cname = customDomain;
-    }
-
-    // Add HTTPS enforcement (recommended)
-    if (options.httpsEnforced !== false) {
-      pagesOptions.https_enforced = true;
-    }
-
-    // Create or update Pages configuration
-    if (!pagesInfo) {
-      // Create new Pages site
-      const { data } = await octokit.repos.createPagesSite(pagesOptions);
-      logger.log(`✅ GitHub Pages enabled successfully!`);
-      logger.log(`   URL: ${data.html_url}`);
-      if (data.cname) {
-        logger.log(`   Custom domain: ${data.cname}`);
-      }
-    } else {
-      // Update existing Pages site
-      const updateOptions = {
-        owner,
-        repo,
-      };
-
-      // Only include fields that can be updated
-      if (customDomain && !customDomain.includes('github.io')) {
-        updateOptions.cname = customDomain;
-      }
-
-      if (options.httpsEnforced !== false) {
-        updateOptions.https_enforced = true;
-      }
-
-      // Update source if different
-      if (JSON.stringify(pagesInfo.source) !== JSON.stringify(sourceConfig)) {
-        updateOptions.source = sourceConfig;
-      }
-
-      const { data } = await octokit.repos.updateInformationAboutPagesSite(updateOptions);
-      logger.log(`✅ GitHub Pages configuration updated successfully!`);
-      logger.log(`   URL: ${data.html_url}`);
-      if (data.cname) {
-        logger.log(`   Custom domain: ${data.cname}`);
-      }
-    }
-
+    logger.log(`Successfully published GH_TOKEN as repository secret`);
   } catch (error) {
-    logger.error(`❌ Failed to update GitHub Pages: ${error.message}`);
-    // Don't throw - this is not critical for setup to continue
+    logger.error(`Failed to publish GH_TOKEN as repository secret: ${error.message}`);
   }
 }
 
-// Deduplicate posts - removes duplicate posts with same slug but different dates
-// Keeps the ORIGINAL (oldest) post and removes newer duplicates
 async function deduplicatePosts() {
-  logger.log('🔍 Checking for duplicate posts...');
+  logger.log('Checking for duplicate posts...');
 
-  // Find all post files in src/_posts
-  const postsGlob = 'src/_posts/**/*.{md,markdown,html}';
-  const postFiles = glob(postsGlob, { nodir: true });
+  const postFiles = glob('src/_posts/**/*.{md,markdown,html}', { nodir: true });
 
   if (postFiles.length === 0) {
     logger.log('No posts found');
@@ -695,8 +425,6 @@ async function deduplicatePosts() {
 
   for (const filePath of postFiles) {
     const filename = path.basename(filePath);
-
-    // Jekyll post format: YYYY-MM-DD-slug.ext
     const match = filename.match(/^(\d{4}-\d{2}-\d{2})-(.+)\.(md|markdown|html)$/);
 
     if (!match) {
@@ -704,20 +432,12 @@ async function deduplicatePosts() {
     }
 
     const [, dateStr, slug, ext] = match;
-    const date = new Date(dateStr);
 
     if (!postsBySlug[slug]) {
       postsBySlug[slug] = [];
     }
 
-    postsBySlug[slug].push({
-      filePath,
-      filename,
-      date,
-      dateStr,
-      slug,
-      ext,
-    });
+    postsBySlug[slug].push({ filePath, filename, date: new Date(dateStr), dateStr, slug, ext });
   }
 
   // Find duplicates and keep only the ORIGINAL (oldest)
@@ -732,25 +452,22 @@ async function deduplicatePosts() {
     // Sort by date ascending (oldest first)
     posts.sort((a, b) => a.date - b.date);
 
-    // Keep the oldest (original), mark the rest for removal
     const [original, ...newer] = posts;
 
     logger.log(`Found ${posts.length} posts with slug "${slug}":`);
-    logger.log(`  ✅ Keeping original: ${original.filename} (${original.dateStr})`);
+    logger.log(`  Keeping original: ${original.filename} (${original.dateStr})`);
 
     for (const post of newer) {
-      logger.log(`  ❌ Removing duplicate: ${post.filename} (${post.dateStr})`);
+      logger.log(`  Removing duplicate: ${post.filename} (${post.dateStr})`);
 
-      // Remove the duplicate post file
       try {
         jetpack.remove(post.filePath);
         removedCount++;
 
-        // Also remove the associated images folder (src/assets/images/blog/post-SLUG)
         const imageFolder = `src/assets/images/blog/post-${post.slug}`;
         if (jetpack.exists(imageFolder)) {
           jetpack.remove(imageFolder);
-          logger.log(`  🗑️  Removed image folder: ${imageFolder}`);
+          logger.log(`  Removed image folder: ${imageFolder}`);
         }
 
         duplicates.push({
@@ -765,11 +482,9 @@ async function deduplicatePosts() {
     }
   }
 
-  // Log summary
   if (removedCount > 0) {
-    logger.log(`✅ Removed ${removedCount} duplicate post(s)`);
+    logger.log(`Removed ${removedCount} duplicate post(s)`);
 
-    // Save report
     const reportDir = path.join(rootPathProject, '.temp/deduplicate');
     jetpack.dir(reportDir);
 
@@ -784,30 +499,27 @@ async function deduplicatePosts() {
 
     logger.log(`Report saved to: ${reportPath}`);
   } else {
-    logger.log('✅ No duplicate posts found');
+    logger.log('No duplicate posts found');
   }
 }
 
-// Run migrations based on installed version
+// --- Migration functions ---
+
 async function migrate() {
   const installedVersion = project.devDependencies[package.name] || '0.0.0';
 
-  // Skip if using local version
   if (installedVersion.startsWith('file:')) {
     return;
   }
 
-  // Migrate hooks to nested structure (introduced in 0.0.185)
   if (version.is(installedVersion, '<=', '1.0.0')) {
     await migrateHooksToNestedStructure();
   }
 }
 
-// Migrate old hook files to new nested structure
 async function migrateHooksToNestedStructure() {
   const hooksDir = path.join(rootPathProject, 'hooks');
 
-  // Map of old file names to new paths
   const migrations = [
     { old: 'build:post.js', new: 'build/post.js' },
     { old: 'build:pre.js', new: 'build/pre.js' },
@@ -820,23 +532,49 @@ async function migrateHooksToNestedStructure() {
     const oldPath = path.join(hooksDir, migration.old);
     const newPath = path.join(hooksDir, migration.new);
 
-    // Check if old file exists
     if (!jetpack.exists(oldPath)) {
       continue;
     }
 
-    // Check if new file already exists
     if (jetpack.exists(newPath)) {
-      logger.warn(`⚠️  Migrate ${migration.old}: ${migration.new} already exists`);
+      logger.warn(`Migrate ${migration.old}: ${migration.new} already exists`);
     }
 
-    // Move the file
     jetpack.move(oldPath, newPath, { overwrite: true });
-    logger.log(`✅ Migrated hook: ${migration.old} → ${migration.new}`);
+    logger.log(`Migrated hook: ${migration.old} -> ${migration.new}`);
     migratedCount++;
   }
 
   if (migratedCount > 0) {
-    logger.log(`✅ Migrated ${migratedCount} hook file(s) to new nested structure`);
+    logger.log(`Migrated ${migratedCount} hook file(s) to new nested structure`);
+  }
+}
+
+// --- Utility functions ---
+
+function npmInstall(pkg, ver, location) {
+  ver = ver || 'latest';
+  ver = ver === 'latest' ? ver : version.clean(ver);
+
+  const command = `npm install ${pkg}@${ver} ${location || '--save'}`;
+
+  logger.log('Installing:', command);
+
+  return execute(command, { log: true })
+    .then(() => {
+      const projectUpdated = jetpack.read(path.join(process.cwd(), 'package.json'), 'json');
+
+      logger.log('Installed:', pkg, ver);
+
+      project.dependencies = projectUpdated.dependencies;
+      project.devDependencies = projectUpdated.devDependencies;
+    });
+}
+
+function logVersionCheck(name, installedVersion, latestVersion, isUpToDate) {
+  if (installedVersion.startsWith('file:')) {
+    isUpToDate = true;
   }
+
+  logger.log(`Checking if ${name} is up to date (${logger.format.bold(installedVersion)} >= ${logger.format.bold(latestVersion)}): ${isUpToDate ? logger.format.green('Yes') : logger.format.red('No')}`);
 }

package/dist/config/_config_default.yml

@@ -85,3 +85,25 @@ exclude:
 include:
   - .well-known
   - __
+
+# Jekyll collections
+collections:
+  team:
+    title: "Team Members"
+    output: true
+  updates:
+    title: "Updates"
+    output: true
+
+# Jekyll defaults
+defaults:
+  - scope:
+      path: ""
+      type: "team"
+    values:
+      permalink: "/team/:title"
+  - scope:
+      path: ""
+      type: "updates"
+    values:
+      permalink: "/updates/:title"

package/dist/defaults/src/_config.yml

@@ -243,25 +243,3 @@ pagination:
   title: ":title - page :num"
   sort_field: "date"
   sort_reverse: true
-
-# Jekyll collections
-collections:
-  team:
-    title: "Team Members"
-    output: true
-  updates:
-    title: "Updates"
-    output: true
-
-# Jekyll defaults
-defaults:
-  - scope:
-      path: ""
-      type: "team"
-    values:
-      permalink: "/team/:title"
-  - scope:
-      path: ""
-      type: "updates"
-    values:
-      permalink: "/updates/:title"

package/dist/gulp/tasks/jekyll.js

@@ -7,6 +7,7 @@ const glob = require('glob').globSync;
 const path = require('path');
 const { execute, template } = require('node-powertools');
 const jetpack = require('fs-jetpack');
+const mergeJekyllConfigs = require('./utils/merge-jekyll-configs');
 
 // Templates
 const JSONP_TEMPLATE = `
@@ -79,6 +80,14 @@ async function jekyll(complete) {
     // Run buildpre hook
     await hook('build/pre', index);
 
+    // Merge UJM collections/defaults with project collections/defaults
+    const mergedConfigPath = mergeJekyllConfigs(
+      `./node_modules/${package.name}/dist/config/_config_default.yml`,
+      'dist/_config.yml',
+      '.temp/_config_collections.yml',
+      logger,
+    );
+
     // Build Jekyll
     const command = [
       // Enable Ruby YJIT for faster builds
@@ -95,13 +104,15 @@ async function jekyll(complete) {
         `./node_modules/${package.name}/dist/config/_config_default.yml`,
         // This is the user's project config file
         'dist/_config.yml',
+        // Merged collections/defaults (deep merge of UJM + project)
+        mergedConfigPath || '',
         // Add browsersync config IF BUILD_MODE is not true
         Manager.isBuildMode() ? '' : '.temp/_config_browsersync.yml',
         // Add development config IF BUILD_MODE is not true
         Manager.isBuildMode() ? '' : `./node_modules/${package.name}/dist/config/_config_development.yml`,
         // Add project-level dev config IF it exists and BUILD_MODE is not true
         (!Manager.isBuildMode() && jetpack.exists('dist/_config.dev.yml')) ? 'dist/_config.dev.yml' : '',
-      ].join(','),
+      ].filter(Boolean).join(','),
       '--incremental',
       (Manager.isBuildMode() || argv.profile) ? ' --profile' : '',
       // Limit posts in development for faster builds (use --all-posts to disable)

package/dist/gulp/tasks/utils/merge-jekyll-configs.js

@@ -0,0 +1,71 @@
+// Libraries
+const jetpack = require('fs-jetpack');
+const yaml = require('js-yaml');
+
+/**
+ * Merges Jekyll collections and defaults from UJM's config with the
+ * consuming project's config. Jekyll's --config does a shallow merge
+ * of top-level keys, so a project defining its own `collections` would
+ * completely override UJM's. This performs a deep merge so both coexist.
+ */
+function mergeJekyllConfigs(ujmConfigPath, projectConfigPath, outputPath, logger) {
+  // Read configs
+  const ujmContent = jetpack.read(ujmConfigPath);
+  if (!ujmContent) {
+    return null;
+  }
+
+  const ujmConfig = yaml.load(ujmContent) || {};
+  const projectContent = jetpack.read(projectConfigPath);
+  const projectConfig = projectContent ? (yaml.load(projectContent) || {}) : {};
+
+  // Extract collections and defaults from both
+  const ujmCollections = ujmConfig.collections || {};
+  const ujmDefaults = ujmConfig.defaults || [];
+  const projectCollections = projectConfig.collections || {};
+  const projectDefaults = projectConfig.defaults || [];
+
+  // Nothing to merge
+  if (!Object.keys(ujmCollections).length && !ujmDefaults.length) {
+    return null;
+  }
+
+  const merged = {};
+
+  // Merge collections (object spread: UJM base + project overrides/additions)
+  if (Object.keys(ujmCollections).length || Object.keys(projectCollections).length) {
+    merged.collections = { ...ujmCollections, ...projectCollections };
+  }
+
+  // Merge defaults (concat + dedup by scope key, project wins on conflict)
+  if (ujmDefaults.length || projectDefaults.length) {
+    const defaultsMap = new Map();
+
+    // UJM defaults first (base)
+    for (const entry of ujmDefaults) {
+      defaultsMap.set(getDefaultsKey(entry), entry);
+    }
+
+    // Project defaults override for same scope
+    for (const entry of projectDefaults) {
+      defaultsMap.set(getDefaultsKey(entry), entry);
+    }
+
+    merged.defaults = Array.from(defaultsMap.values());
+  }
+
+  // Write merged config
+  const content = `# Auto-generated merged config for collections and defaults\n# DO NOT EDIT - this file is regenerated on every build\n\n${yaml.dump(merged, { lineWidth: -1, noRefs: true })}`;
+
+  jetpack.write(outputPath, content);
+  logger.log(`Merged collections config written to ${outputPath}`);
+
+  return outputPath;
+}
+
+function getDefaultsKey(entry) {
+  const scope = entry.scope || {};
+  return `${scope.path || ''}::${scope.type || ''}`;
+}
+
+module.exports = mergeJekyllConfigs;

package/package.json

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