chore: script to update the repo stars in real time

nextjs/data/repository_stats.json

@@ -1,60 +1,60 @@
 {
   "hiero-consensus-node": {
-    "stars": 376
+    "stars": 383
   },
   "hiero-local-node": {
-    "stars": 272
+    "stars": 266
   },
   "hiero-mirror-node": {
-    "stars": 175
+    "stars": 178
   },
   "hiero-improvement-proposals": {
-    "stars": 175
+    "stars": 176
   },
   "hiero-sdk-js": {
-    "stars": 306
+    "stars": 317
   },
   "hiero-sdk-java": {
-    "stars": 249
+    "stars": 250
   },
   "hiero-json-rpc-relay": {
     "stars": 87
   },
   "hiero-sdk-go": {
-    "stars": 123
+    "stars": 122
   },
   "hiero-sdk-rust": {
-    "stars": 56
+    "stars": 58
   },
   "hiero-mirror-node-explorer": {
     "stars": 46
   },
   "hiero-cli": {
-    "stars": 36
+    "stars": 41
   },
   "solo": {
-    "stars": 35
+    "stars": 38
   },
   "hiero-block-node": {
-    "stars": 33
+    "stars": 35
   },
   "hiero-sdk-tck": {
     "stars": 22
   },
   "hiero-sdk-cpp": {
-    "stars": 36
+    "stars": 39
   },
   "governance": {
     "stars": 13
   },
   "hiero-sdk-python": {
-    "stars": 47
+    "stars": 54
   },
   "hiero-sdk-swift": {
     "stars": 33
   },
   "sdk-collaboration-hub": {
-    "stars": 5
+    "stars": 7
   },
   "tsc": {
     "stars": 5

nextjs/scripts/sync-repo-stats.mjs

@@ -7,27 +7,130 @@ import { fileURLToPath } from "node:url";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-const sourceFile = path.join(__dirname, "..", "..", "data", "repository_stats.json");
 const targetFile = path.join(__dirname, "..", "data", "repository_stats.json");
+const fallbackFile = path.join(__dirname, "..", "..", "data", "repository_stats.json");
 
-function syncRepoStats() {
-  if (!fs.existsSync(sourceFile)) {
-    console.warn("[sync-repo-stats] Source file not found, skipping sync:", sourceFile);
-    return;
+const repos = [
+  "hiero-consensus-node", "hiero-local-node", "hiero-mirror-node",
+  "hiero-improvement-proposals", "hiero-sdk-js", "hiero-sdk-java",
+  "hiero-json-rpc-relay", "hiero-sdk-go", "hiero-sdk-rust",
+  "hiero-mirror-node-explorer", "hiero-cli", "solo", "hiero-block-node",
+  "hiero-sdk-tck", "hiero-sdk-cpp", "governance", "hiero-sdk-python",
+  "hiero-sdk-swift", "sdk-collaboration-hub", "tsc",
+];
+
+async function fetchFromGitHub() {
+  const stats = new Map();
+  const cachedStats = loadFallback(false);
+  const headers = {
+    "User-Agent": "hiero-website-build",
+    "Accept": "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28",
+  };
+  if (process.env.GITHUB_TOKEN) {
+    headers["Authorization"] = `Bearer ${process.env.GITHUB_TOKEN}`;
+  }
+
+  console.log("[sync-repo-stats] Fetching repository statistics from GitHub...");
+
+  let successCount = 0;
+
+  for (const repo of repos) {
+    const response = await fetch(`https://api.github.com/repos/hiero-ledger/${repo}`, { headers });
+    if (response.ok) {
+      const data = await response.json();
+      stats.set(repo, { stars: data.stargazers_count });
+      successCount += 1;
+      console.log(`  ✓ ${repo}: ${data.stargazers_count} stars`);
+    } else {
+      const cachedStars = cachedStats?.[repo]?.stars;
+      if (typeof cachedStars === "number") {
+        stats.set(repo, { stars: cachedStars });
+        console.warn(`  ⚠ ${repo}: API ${response.status}, using cached value ${cachedStars}`);
+      } else {
+        stats.set(repo, { stars: 0 });
+        console.warn(`  ✗ ${repo}: API responded with ${response.status}`);
+      }
+    }
+
+    // If access is blocked/rate-limited and nothing has succeeded, stop early.
+    if ((response.status === 401 || response.status === 403) && successCount === 0) {
+      const resetAt = response.headers.get("x-ratelimit-reset");
+      if (resetAt) {
+        const resetTime = new Date(Number(resetAt) * 1000).toISOString();
+        console.warn(`[sync-repo-stats] GitHub access currently limited; rate limit resets at ${resetTime}.`);
+      }
+      break;
+    }
+
+    // Small delay to stay well within GitHub's rate limits.
+    await new Promise((resolve) => setTimeout(resolve, 50));
   }
 
-  const sourceJson = fs.readFileSync(sourceFile, "utf8");
+  // Ensure all repos exist in output, preferring cache over zeroes when available.
+  for (const repo of repos) {
+    if (stats.has(repo)) continue;
+    const cachedStars = cachedStats?.[repo]?.stars;
+    stats.set(repo, { stars: typeof cachedStars === "number" ? cachedStars : 0 });
+  }
 
-  // Validate JSON before writing, so bad source data does not break the app silently.
-  JSON.parse(sourceJson);
+  return Object.fromEntries(stats);
+}
 
-  fs.writeFileSync(targetFile, sourceJson);
-  console.log("[sync-repo-stats] Synced repository_stats.json to nextjs/data");
+function totalStars(stats) {
+  return Object.values(stats).reduce((sum, repo) => sum + (repo?.stars ?? 0), 0);
 }
 
-try {
-  syncRepoStats();
-} catch (error) {
-  console.error("[sync-repo-stats] Failed:", error);
-  process.exit(1);
+function loadFallback(log = true) {
+  let bestStats = null;
+  let bestSource = null;
+
+  for (const file of [targetFile, fallbackFile]) {
+    if (fs.existsSync(file)) {
+      try {
+        const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (!bestStats || totalStars(parsed) > totalStars(bestStats)) {
+          bestStats = parsed;
+          bestSource = file;
+        }
+      } catch {
+        // Ignore malformed cache files and keep searching.
+      }
+    }
+  }
+
+  if (bestStats) {
+    if (log) {
+      console.warn(`[sync-repo-stats] Using cached data from ${bestSource}`);
+    }
+    return bestStats;
+  }
+
+  if (log) {
+    console.warn("[sync-repo-stats] No cached data available — writing empty stats.");
+  }
+  return Object.fromEntries(repos.map((r) => [r, { stars: 0 }]));
+}
+
+async function run() {
+  let stats;
+  try {
+    stats = await fetchFromGitHub();
+  } catch (error) {
+    console.warn(`[sync-repo-stats] GitHub fetch failed (${error.message}), falling back to cached data.`);
+    stats = loadFallback();
+  }
+
+  const dataDir = path.dirname(targetFile);
+  if (!fs.existsSync(dataDir)) fs.mkdirSync(dataDir, { recursive: true });
+
+  fs.writeFileSync(targetFile, JSON.stringify(stats, null, 2));
+
+  const totalStars = Object.values(stats).reduce((sum, r) => sum + r.stars, 0);
+  console.log(`[sync-repo-stats] Done. Total stars: ${totalStars.toLocaleString()}`);
 }
+
+run().catch((error) => {
+  console.error("[sync-repo-stats] Unexpected error:", error);
+  process.exit(1);
+});