cryptoserve 0.3.2 → 0.3.3

package/lib/census/aggregator.mjs

@@ -6,7 +6,7 @@
  * Includes project-level transparency stats when available.
  */
 
-import { TIERS, getCatalogSize } from './package-catalog.mjs';
+import { TIERS, CATEGORIES, getCatalogSize } from './package-catalog.mjs';
 
 // NIST Post-Quantum Cryptography deadlines
 const NIST_2030 = new Date('2030-01-01T00:00:00Z');
@@ -78,6 +78,50 @@ function buildEcosystemBreakdown(pkgs, period) {
   };
 }
 
+/**
+ * Build per-category breakdown across all packages.
+ * Groups packages by category and computes weak/modern/pqc totals + weak percentage.
+ */
+function buildCategoryBreakdown(allPkgs) {
+  const categoryMap = {};
+  for (const cat of CATEGORIES) {
+    categoryMap[cat] = { category: cat, weak: 0, modern: 0, pqc: 0, total: 0, weakPercentage: 0, topPackages: [] };
+  }
+
+  for (const pkg of allPkgs) {
+    const cat = pkg.category || 'general';
+    const entry = categoryMap[cat];
+    if (!entry) continue;
+
+    const dl = pkg.downloads || 0;
+    if (pkg.tier === TIERS.WEAK) entry.weak += dl;
+    else if (pkg.tier === TIERS.PQC) entry.pqc += dl;
+    else entry.modern += dl;
+
+    entry.total += dl;
+    entry.topPackages.push(pkg);
+  }
+
+  // Compute weak percentage and sort top packages
+  const result = [];
+  for (const cat of CATEGORIES) {
+    const entry = categoryMap[cat];
+    entry.weakPercentage = entry.total > 0
+      ? Math.round((entry.weak / entry.total) * 1000) / 10
+      : 0;
+    entry.topPackages = entry.topPackages
+      .sort((a, b) => b.downloads - a.downloads)
+      .slice(0, 10);
+    if (entry.total > 0) {
+      result.push(entry);
+    }
+  }
+
+  // Sort by total downloads descending
+  result.sort((a, b) => b.total - a.total);
+  return result;
+}
+
 /**
  * Aggregate all census data into headline metrics.
  *
@@ -178,6 +222,9 @@ export function aggregate(data) {
     return d?.packages?.length > 0;
   });
 
+  // Category breakdown
+  const categoryBreakdown = buildCategoryBreakdown(allPkgs);
+
   return {
     // Headline numbers
     totalDownloads,
@@ -189,6 +236,9 @@ export function aggregate(data) {
     pqcPercentage,
     weakToPqcRatio,
 
+    // Category breakdown
+    categoryBreakdown,
+
     // Per-ecosystem
     npm,
     pypi,

package/lib/census/collectors/cocoapods-downloads.mjs

@@ -46,17 +46,17 @@ export async function collectCocoapodsDownloads(packages, options = {}) {
 
       if (!res.ok) {
         if (verbose) process.stderr.write(`  cocoapods ${pkg.name}: ${res.status}\n`);
-        results.push({ name: pkg.name, downloads: 0, tier: pkg.tier });
+        results.push({ name: pkg.name, downloads: 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
       } else {
         // Trunk API confirms pod exists but has no download stats.
         // Use conservative estimate: CocoaPods ecosystem is smaller,
         // most crypto pods get 1K-50K installs/month based on GitHub activity.
         // We set 0 and rely on scanner data if available.
-        results.push({ name: pkg.name, downloads: 0, tier: pkg.tier });
+        results.push({ name: pkg.name, downloads: 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
       }
     } catch (err) {
       if (verbose) process.stderr.write(`  cocoapods ${pkg.name} error: ${err.message}\n`);
-      results.push({ name: pkg.name, downloads: 0, tier: pkg.tier });
+      results.push({ name: pkg.name, downloads: 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
     }
 
     if (i < packages.length - 1) {

package/lib/census/collectors/crates-downloads.mjs

@@ -45,17 +45,17 @@ export async function collectCratesDownloads(packages, options = {}) {
 
       if (!res.ok) {
         if (verbose) process.stderr.write(`  crates ${pkg.name}: ${res.status}\n`);
-        results.push({ name: pkg.name, downloads: 0, tier: pkg.tier });
+        results.push({ name: pkg.name, downloads: 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
       } else {
         const data = await res.json();
         // recent_downloads = last 90 days, divide by 3 for monthly estimate
         const recentDownloads = data?.crate?.recent_downloads || 0;
         const monthlyEstimate = Math.round(recentDownloads / 3);
-        results.push({ name: pkg.name, downloads: monthlyEstimate, tier: pkg.tier });
+        results.push({ name: pkg.name, downloads: monthlyEstimate, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
       }
     } catch (err) {
       if (verbose) process.stderr.write(`  crates ${pkg.name} error: ${err.message}\n`);
-      results.push({ name: pkg.name, downloads: 0, tier: pkg.tier });
+      results.push({ name: pkg.name, downloads: 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
     }
 
     if (i < packages.length - 1) {

package/lib/census/collectors/github-enrichment.mjs

@@ -0,0 +1,160 @@
+/**
+ * Enrich top packages with GitHub repository metadata.
+ *
+ * Fetches stars, forks, last push date, and archived status from the GitHub API
+ * for the top packages by download count. Uses unauthenticated requests
+ * (60 req/hr limit), so we limit to 30 packages with 1s delays.
+ */
+
+const REQUEST_DELAY_MS = 1000;
+const MAX_ENRICHMENTS = 30;
+
+/**
+ * Static mapping of package name to GitHub owner/repo.
+ * Many registries don't expose repo URLs in download APIs,
+ * so we maintain this mapping for top packages.
+ */
+const KNOWN_REPOS = {
+  // npm
+  'crypto-js': 'brix/crypto-js',
+  '@noble/hashes': 'paulmillr/noble-hashes',
+  '@noble/curves': 'paulmillr/noble-curves',
+  '@noble/ciphers': 'paulmillr/noble-ciphers',
+  '@noble/post-quantum': 'paulmillr/noble-post-quantum',
+  'node-forge': 'digitalbazaar/forge',
+  'jose': 'panva/jose',
+  'elliptic': 'indutny/elliptic',
+  'hash.js': 'indutny/hash.js',
+  'tweetnacl': 'nicola/tweetnacl-js',
+  'bcryptjs': 'nicola/bcrypt.js',
+  'jsonwebtoken': 'auth0/node-jsonwebtoken',
+  'sodium-native': 'nicola/sodium-native',
+  'md5': 'pvorb/node-md5',
+  'scrypt-js': 'nicola/scrypt-js',
+
+  // PyPI
+  'cryptography': 'pyca/cryptography',
+  'pycryptodome': 'Legrandin/pycryptodome',
+  'bcrypt': 'pyca/bcrypt',
+  'pynacl': 'pyca/pynacl',
+  'argon2-cffi': 'hynek/argon2-cffi',
+  'PyJWT': 'jpadilla/pyjwt',
+  'liboqs-python': 'open-quantum-safe/liboqs-python',
+
+  // Rust crates
+  'ring': 'briansmith/ring',
+  'rustls': 'rustls/rustls',
+  'ed25519-dalek': 'dalek-cryptography/curve25519-dalek',
+  'sha2': 'RustCrypto/hashes',
+  'aes-gcm': 'RustCrypto/AEADs',
+  'chacha20poly1305': 'RustCrypto/AEADs',
+  'argon2': 'RustCrypto/password-hashes',
+
+  // Go
+  'github.com/cloudflare/circl': 'cloudflare/circl',
+  'golang-jwt/jwt/v5': 'golang-jwt/jwt',
+
+  // Maven
+  'org.bouncycastle:bcprov-jdk18on': 'bcgit/bc-java',
+  'com.google.crypto.tink:tink': 'google/tink',
+  'io.jsonwebtoken:jjwt-api': 'jwtk/jjwt',
+
+  // PHP
+  'phpseclib/phpseclib': 'phpseclib/phpseclib',
+  'defuse/php-encryption': 'defuse/php-encryption',
+  'firebase/php-jwt': 'firebase/php-jwt',
+
+  // Ruby
+  'rbnacl': 'crypto-rb/rbnacl',
+  'jwt': 'jwt/ruby-jwt',
+
+  // Dart
+  'pointycastle': 'nicola/pc-dart',
+
+  // Swift
+  'CryptoSwift': 'nicola/CryptoSwift',
+};
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Enrich packages with GitHub metadata.
+ *
+ * @param {Array} allPackages - All package entries (with name + downloads)
+ * @param {Object} [options]
+ * @param {Function} [options.fetchFn] - Fetch implementation
+ * @param {boolean} [options.verbose] - Log progress
+ * @returns {Promise<Map<string, {stars: number, forks: number, lastPush: string, archived: boolean}>>}
+ */
+export async function collectGithubEnrichment(allPackages, options = {}) {
+  const fetchFn = options.fetchFn || globalThis.fetch;
+  const verbose = options.verbose || false;
+
+  // Sort by downloads descending and pick top packages that have known repos
+  const sorted = [...allPackages]
+    .sort((a, b) => b.downloads - a.downloads);
+
+  const toEnrich = [];
+  const seen = new Set();
+  for (const pkg of sorted) {
+    const repo = KNOWN_REPOS[pkg.name];
+    if (!repo || seen.has(repo)) continue;
+    seen.add(repo);
+    toEnrich.push({ name: pkg.name, repo });
+    if (toEnrich.length >= MAX_ENRICHMENTS) break;
+  }
+
+  if (verbose) {
+    process.stderr.write(`  github enrichment: ${toEnrich.length} packages to enrich\n`);
+  }
+
+  const results = new Map();
+
+  for (const { name, repo } of toEnrich) {
+    try {
+      const res = await fetchFn(`https://api.github.com/repos/${repo}`, {
+        headers: { 'Accept': 'application/vnd.github+json' },
+      });
+
+      if (!res.ok) {
+        if (verbose) process.stderr.write(`  github ${repo}: HTTP ${res.status}\n`);
+        // Check rate limit
+        const remaining = res.headers?.get?.('x-ratelimit-remaining');
+        if (remaining === '0') {
+          if (verbose) process.stderr.write('  github rate limit hit, stopping\n');
+          break;
+        }
+        await sleep(REQUEST_DELAY_MS);
+        continue;
+      }
+
+      const data = await res.json();
+      results.set(name, {
+        stars: data.stargazers_count || 0,
+        forks: data.forks_count || 0,
+        lastPush: data.pushed_at || null,
+        archived: data.archived || false,
+      });
+
+      if (verbose) {
+        process.stderr.write(`  github ${repo}: ${data.stargazers_count} stars\n`);
+      }
+
+      await sleep(REQUEST_DELAY_MS);
+    } catch (err) {
+      if (verbose) process.stderr.write(`  github ${repo} error: ${err.message}\n`);
+      await sleep(REQUEST_DELAY_MS);
+    }
+  }
+
+  if (verbose) {
+    process.stderr.write(`  github enrichment: ${results.size} packages enriched\n`);
+  }
+
+  return {
+    enrichments: Object.fromEntries(results),
+    collectedAt: new Date().toISOString(),
+  };
+}

package/lib/census/collectors/go-downloads.mjs

@@ -73,7 +73,7 @@ export async function collectGoDownloads(packages, options = {}) {
     // Stdlib packages: use hardcoded estimates
     if (pkg.name.startsWith('crypto/')) {
       const estimate = STDLIB_ESTIMATES[pkg.name] || 10_000;
-      results.push({ name: pkg.name, downloads: estimate, tier: pkg.tier });
+      results.push({ name: pkg.name, downloads: estimate, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
       continue;
     }
 
@@ -84,7 +84,7 @@ export async function collectGoDownloads(packages, options = {}) {
 
       if (!res.ok) {
         if (verbose) process.stderr.write(`  go ${pkg.name}: proxy ${res.status}\n`);
-        results.push({ name: pkg.name, downloads: 0, tier: pkg.tier });
+        results.push({ name: pkg.name, downloads: 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
         continue;
       }
 
@@ -115,10 +115,10 @@ export async function collectGoDownloads(packages, options = {}) {
           : Math.max(downloads, 500_000);
       }
 
-      results.push({ name: pkg.name, downloads, tier: pkg.tier });
+      results.push({ name: pkg.name, downloads, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
     } catch (err) {
       if (verbose) process.stderr.write(`  go ${pkg.name} error: ${err.message}\n`);
-      results.push({ name: pkg.name, downloads: 0, tier: pkg.tier });
+      results.push({ name: pkg.name, downloads: 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
     }
 
     if (i < packages.length - 1) await sleep(REQUEST_DELAY_MS);

package/lib/census/collectors/hex-downloads.mjs

@@ -42,18 +42,18 @@ export async function collectHexDownloads(packages, options = {}) {
 
       if (!res.ok) {
         if (verbose) process.stderr.write(`  hex ${pkg.name}: ${res.status}\n`);
-        results.push({ name: pkg.name, downloads: 0, tier: pkg.tier });
+        results.push({ name: pkg.name, downloads: 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
       } else {
         const data = await res.json();
         // Hex provides downloads.recent (last 90 days) and downloads.all
         const recentDownloads = data?.downloads?.recent || 0;
         // Estimate monthly from 90-day window
         const monthlyEstimate = Math.round(recentDownloads / 3);
-        results.push({ name: pkg.name, downloads: monthlyEstimate, tier: pkg.tier });
+        results.push({ name: pkg.name, downloads: monthlyEstimate, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
       }
     } catch (err) {
       if (verbose) process.stderr.write(`  hex ${pkg.name} error: ${err.message}\n`);
-      results.push({ name: pkg.name, downloads: 0, tier: pkg.tier });
+      results.push({ name: pkg.name, downloads: 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
     }
 
     if (i < packages.length - 1) {

package/lib/census/collectors/maven-downloads.mjs

@@ -57,7 +57,7 @@ export async function collectMavenDownloads(packages, options = {}) {
 
       if (!res.ok) {
         if (verbose) process.stderr.write(`  maven ${pkg.name}: ${res.status}\n`);
-        results.push({ name: pkg.name, downloads: 0, tier: pkg.tier });
+        results.push({ name: pkg.name, downloads: 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
       } else {
         const data = await res.json();
         const doc = data?.response?.docs?.[0];
@@ -72,11 +72,15 @@ export async function collectMavenDownloads(packages, options = {}) {
           name: pkg.name,
           downloads: estimatedDownloads,
           tier: pkg.tier,
+          category: pkg.category,
+          replacedBy: pkg.replacedBy,
+          algorithms: pkg.algorithms,
+          note: pkg.note,
         });
       }
     } catch (err) {
       if (verbose) process.stderr.write(`  maven ${pkg.name} error: ${err.message}\n`);
-      results.push({ name: pkg.name, downloads: 0, tier: pkg.tier });
+      results.push({ name: pkg.name, downloads: 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
     }
 
     if (i < packages.length - 1) {

package/lib/census/collectors/npm-downloads.mjs

@@ -28,13 +28,13 @@ async function fetchSingle(pkg, fetchFn, period, verbose) {
         period.start = data.start;
         period.end = data.end;
       }
-      return { name: pkg.name, downloads: data.downloads || 0, tier: pkg.tier };
+      return { name: pkg.name, downloads: data.downloads || 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note };
     }
     if (verbose) process.stderr.write(`  npm ${pkg.name}: HTTP ${res.status}\n`);
   } catch (err) {
     if (verbose) process.stderr.write(`  npm ${pkg.name} error: ${err.message}\n`);
   }
-  return { name: pkg.name, downloads: 0, tier: pkg.tier };
+  return { name: pkg.name, downloads: 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note };
 }
 
 /**
@@ -90,7 +90,7 @@ export async function collectNpmDownloads(packages, options = {}) {
           period.start = data.start;
           period.end = data.end;
         }
-        results.push({ name: batch[0].name, downloads: data.downloads || 0, tier: batch[0].tier });
+        results.push({ name: batch[0].name, downloads: data.downloads || 0, tier: batch[0].tier, category: batch[0].category, replacedBy: batch[0].replacedBy, algorithms: batch[0].algorithms, note: batch[0].note });
       } else {
         for (const pkg of batch) {
           const entry = data[pkg.name];
@@ -99,16 +99,16 @@ export async function collectNpmDownloads(packages, options = {}) {
               period.start = entry.start;
               period.end = entry.end;
             }
-            results.push({ name: pkg.name, downloads: entry.downloads || 0, tier: pkg.tier });
+            results.push({ name: pkg.name, downloads: entry.downloads || 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
           } else {
-            results.push({ name: pkg.name, downloads: 0, tier: pkg.tier });
+            results.push({ name: pkg.name, downloads: 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
           }
         }
       }
     } catch (err) {
       if (verbose) process.stderr.write(`  npm batch ${i + 1} error: ${err.message}\n`);
       for (const pkg of batch) {
-        results.push({ name: pkg.name, downloads: 0, tier: pkg.tier });
+        results.push({ name: pkg.name, downloads: 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
       }
     }
 

package/lib/census/collectors/nuget-downloads.mjs

@@ -45,18 +45,18 @@ export async function collectNugetDownloads(packages, options = {}) {
 
       if (!res.ok) {
         if (verbose) process.stderr.write(`  nuget ${pkg.name}: ${res.status}\n`);
-        results.push({ name: pkg.name, downloads: 0, tier: pkg.tier });
+        results.push({ name: pkg.name, downloads: 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
       } else {
         const data = await res.json();
         const entry = data?.data?.[0];
         // NuGet returns total downloads, estimate monthly as total / 36 (3 years average)
         const totalDownloads = entry?.totalDownloads || 0;
         const monthlyEstimate = Math.round(totalDownloads / 36);
-        results.push({ name: pkg.name, downloads: monthlyEstimate, tier: pkg.tier });
+        results.push({ name: pkg.name, downloads: monthlyEstimate, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
       }
     } catch (err) {
       if (verbose) process.stderr.write(`  nuget ${pkg.name} error: ${err.message}\n`);
-      results.push({ name: pkg.name, downloads: 0, tier: pkg.tier });
+      results.push({ name: pkg.name, downloads: 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
     }
 
     if (i < packages.length - 1) {

package/lib/census/collectors/packagist-downloads.mjs

@@ -41,15 +41,15 @@ export async function collectPackagistDownloads(packages, options = {}) {
 
       if (!res.ok) {
         if (verbose) process.stderr.write(`  packagist ${pkg.name}: ${res.status}\n`);
-        results.push({ name: pkg.name, downloads: 0, tier: pkg.tier });
+        results.push({ name: pkg.name, downloads: 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
       } else {
         const data = await res.json();
         const monthlyDownloads = data?.package?.downloads?.monthly || 0;
-        results.push({ name: pkg.name, downloads: monthlyDownloads, tier: pkg.tier });
+        results.push({ name: pkg.name, downloads: monthlyDownloads, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
       }
     } catch (err) {
       if (verbose) process.stderr.write(`  packagist ${pkg.name} error: ${err.message}\n`);
-      results.push({ name: pkg.name, downloads: 0, tier: pkg.tier });
+      results.push({ name: pkg.name, downloads: 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
     }
 
     if (i < packages.length - 1) {

package/lib/census/collectors/pub-downloads.mjs

@@ -40,16 +40,16 @@ export async function collectPubDownloads(packages, options = {}) {
 
       if (!res.ok) {
         if (verbose) process.stderr.write(`  pub ${pkg.name}: ${res.status}\n`);
-        results.push({ name: pkg.name, downloads: 0, tier: pkg.tier });
+        results.push({ name: pkg.name, downloads: 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
       } else {
         const data = await res.json();
         // pub.dev score endpoint has downloadCount30Days
         const downloads = data?.downloadCount30Days || 0;
-        results.push({ name: pkg.name, downloads: downloads, tier: pkg.tier });
+        results.push({ name: pkg.name, downloads: downloads, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
       }
     } catch (err) {
       if (verbose) process.stderr.write(`  pub ${pkg.name} error: ${err.message}\n`);
-      results.push({ name: pkg.name, downloads: 0, tier: pkg.tier });
+      results.push({ name: pkg.name, downloads: 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
     }
 
     if (i < packages.length - 1) {

package/lib/census/collectors/pypi-downloads.mjs

@@ -41,16 +41,16 @@ export async function collectPypiDownloads(packages, options = {}) {
       const res = await fetchFn(url);
       if (!res.ok) {
         if (verbose) process.stderr.write(`  pypi ${pkg.name}: ${res.status}\n`);
-        results.push({ name: pkg.name, downloads: 0, tier: pkg.tier });
+        results.push({ name: pkg.name, downloads: 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
       } else {
         const data = await res.json();
         // Response: { data: { last_month: N, last_week: N, last_day: N }, ... }
         const downloads = data?.data?.last_month || 0;
-        results.push({ name: pkg.name, downloads, tier: pkg.tier });
+        results.push({ name: pkg.name, downloads, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
       }
     } catch (err) {
       if (verbose) process.stderr.write(`  pypi ${pkg.name} error: ${err.message}\n`);
-      results.push({ name: pkg.name, downloads: 0, tier: pkg.tier });
+      results.push({ name: pkg.name, downloads: 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
     }
 
     // Delay between requests

package/lib/census/collectors/rubygems-downloads.mjs

@@ -41,17 +41,17 @@ export async function collectRubygemsDownloads(packages, options = {}) {
 
       if (!res.ok) {
         if (verbose) process.stderr.write(`  rubygems ${pkg.name}: ${res.status}\n`);
-        results.push({ name: pkg.name, downloads: 0, tier: pkg.tier });
+        results.push({ name: pkg.name, downloads: 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
       } else {
         const data = await res.json();
         // RubyGems only provides total downloads; estimate monthly
         const totalDownloads = data?.downloads || 0;
         const monthlyEstimate = Math.round(totalDownloads / 120);
-        results.push({ name: pkg.name, downloads: monthlyEstimate, tier: pkg.tier });
+        results.push({ name: pkg.name, downloads: monthlyEstimate, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
       }
     } catch (err) {
       if (verbose) process.stderr.write(`  rubygems ${pkg.name} error: ${err.message}\n`);
-      results.push({ name: pkg.name, downloads: 0, tier: pkg.tier });
+      results.push({ name: pkg.name, downloads: 0, tier: pkg.tier, category: pkg.category, replacedBy: pkg.replacedBy, algorithms: pkg.algorithms, note: pkg.note });
     }
 
     if (i < packages.length - 1) {