update-list.js

const https = require('https');
const fs = require('fs');

function fetchPackageData(packageName) {
  return new Promise((resolve, reject) => {
    const url = `https://registry.npmjs.org/${packageName}`;
    https.get(url, (res) => {
      if (res.statusCode === 404) {
        reject(new Error('Package not found'));
        return;
      }
      let data = '';
      res.on('data', (chunk) => { data += chunk; });
      res.on('end', () => {
        try {
          resolve(JSON.parse(data));
        } catch (e) {
          reject(e);
        }
      });
    }).on('error', reject);
  });
}

function parseVersion(versionStr) {
  // Filter out pre-release versions (canary, alpha, beta, rc, next, etc.)
  if (/-/.test(versionStr)) {
    return null;
  }
  
  const match = versionStr.match(/^(\d+)\.(\d+)\.(\d+)$/);
  if (!match) return null;
  
  return {
    major: parseInt(match[1]),
    minor: parseInt(match[2]),
    patch: parseInt(match[3]),
    full: versionStr
  };
}

function compareVersions(a, b) {
  if (a.major !== b.major) return b.major - a.major;
  if (a.minor !== b.minor) return b.minor - a.minor;
  return b.patch - a.patch;
}

function getLatestPatchForMinorVersions(versions) {
  const parsed = versions
    .map(v => parseVersion(v))
    .filter(v => v !== null)
    .sort(compareVersions);
  
  if (parsed.length === 0) return [];
  
  const minorMap = new Map();
  for (const version of parsed) {
    const key = `${version.major}.${version.minor}`;
    if (!minorMap.has(key)) {
      minorMap.set(key, []);
    }
    minorMap.get(key).push(version);
  }
  
  const result = [];
  for (const [key, minorVersions] of minorMap) {
    minorVersions.sort((a, b) => b.patch - a.patch);
    result.push(minorVersions[0].full);
  }
  
  return result.sort((a, b) => {
    const av = parseVersion(a);
    const bv = parseVersion(b);
    return compareVersions(av, bv);
  });
}

function updatePackageVersions(existingVersions, allAvailableVersions) {
  const existing = existingVersions
    .map(v => parseVersion(v))
    .filter(v => v !== null)
    .sort(compareVersions);
  
  const available = allAvailableVersions
    .map(v => parseVersion(v))
    .filter(v => v !== null)
    .sort(compareVersions);
  
  if (existing.length === 0 || available.length === 0) {
    return existingVersions;
  }
  
  const currentMajor = existing[0].major;
  const latestAvailableMajor = available[0].major;
  
  const result = [];
  
  if (latestAvailableMajor > currentMajor) {
    console.log(`    NEW MAJOR VERSION: ${currentMajor} -> ${latestAvailableMajor}`);
    
    const newMajorVersions = available.filter(v => v.major === latestAvailableMajor);
    const latestPatches = getLatestPatchForMinorVersions(newMajorVersions.map(v => v.full));
    result.push(...latestPatches);
  } else {
    const currentMajorVersions = available.filter(v => v.major === currentMajor);
    
    const existingMinors = new Map();
    for (const version of existing.filter(v => v.major === currentMajor)) {
      const key = `${version.major}.${version.minor}`;
      existingMinors.set(key, version);
    }
    
    const availableMinors = new Map();
    for (const version of currentMajorVersions) {
      const key = `${version.major}.${version.minor}`;
      if (!availableMinors.has(key)) {
        availableMinors.set(key, []);
      }
      availableMinors.get(key).push(version);
    }
    
    for (const [minorKey, versions] of availableMinors) {
      versions.sort((a, b) => b.patch - a.patch);
      const latestPatch = versions[0];
      
      const existingVersion = existingMinors.get(minorKey);
      
      if (existingVersion) {
        if (latestPatch.patch > existingVersion.patch) {
          console.log(`    UPDATED PATCH: ${existingVersion.full} -> ${latestPatch.full}`);
          result.push(latestPatch.full);
        } else {
          result.push(existingVersion.full);
        }
      } else {
        console.log(`    NEW MINOR VERSION: ${latestPatch.full}`);
        result.push(latestPatch.full);
      }
    }
    
    result.sort((a, b) => {
      const av = parseVersion(a);
      const bv = parseVersion(b);
      return compareVersions(av, bv);
    });
  }
  
  return result;
}

async function main() {
  console.log('Verdaccio Package List Updater');
  console.log('===============================\n');
  
  console.log('Step 1: Reading current package list...');
  const currentPackages = JSON.parse(fs.readFileSync('top-npm-packages.json', 'utf8'));
  
  const packageMap = new Map();
  for (const pkg of currentPackages) {
    if (!packageMap.has(pkg.name)) {
      packageMap.set(pkg.name, []);
    }
    packageMap.get(pkg.name).push(pkg.version);
  }
  
  console.log(`  Current: ${currentPackages.length} versions across ${packageMap.size} packages\n`);
  
  console.log('Step 2: Checking for updates...\n');
  
  const updatedPackages = [];
  let checkedCount = 0;
  let updatedCount = 0;
  let unchangedCount = 0;
  let errorCount = 0;
  
  for (const [packageName, existingVersions] of packageMap) {
    checkedCount++;
    console.log(`[${checkedCount}/${packageMap.size}] Checking ${packageName}...`);
    
    try {
      const data = await fetchPackageData(packageName);
      const allVersions = Object.keys(data.versions);
      
      const updatedVersions = updatePackageVersions(existingVersions, allVersions);
      
      if (JSON.stringify(updatedVersions.sort()) !== JSON.stringify(existingVersions.sort())) {
        updatedCount++;
      } else {
        unchangedCount++;
        console.log('    No changes');
      }
      
      for (const version of updatedVersions) {
        updatedPackages.push({
          name: packageName,
          version: version
        });
      }
      
    } catch (error) {
      console.error(`    ERROR: ${error.message}`);
      errorCount++;
      
      for (const version of existingVersions) {
        updatedPackages.push({
          name: packageName,
          version: version
        });
      }
    }
    
    await new Promise(resolve => setTimeout(resolve, 100));
  }
  
  console.log('\n===============================');
  console.log('Update Summary:');
  console.log(`  Checked: ${checkedCount} packages`);
  console.log(`  Updated: ${updatedCount} packages`);
  console.log(`  Unchanged: ${unchangedCount} packages`);
  console.log(`  Errors: ${errorCount} packages`);
  console.log('===============================\n');
  
  console.log('Step 3: Creating backup...');
  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').split('T')[0];
  const backupName = `top-npm-packages.json.backup-${timestamp}`;
  fs.copyFileSync('top-npm-packages.json', backupName);
  console.log(`  Backup created: ${backupName}`);
  
  console.log('\nStep 4: Writing updated package list...');
  const oldSize = currentPackages.length;
  const newSize = updatedPackages.length;
  
  fs.writeFileSync('top-npm-packages.json', JSON.stringify(updatedPackages, null, 2));
  
  const fileSize = (fs.statSync('top-npm-packages.json').size / 1024).toFixed(1);
  
  console.log(`  Versions: ${oldSize} -> ${newSize} (${newSize > oldSize ? '+' : ''}${newSize - oldSize})`);
  console.log(`  File size: ${fileSize} KB`);
  console.log('\nDone!');
}

main().catch(error => {
  console.error('FATAL ERROR:', error.message);
  process.exit(1);
});