feat: add community activity score badges and filters

.github/workflows/compute-activity-scores.yml

@@ -0,0 +1,31 @@
+name: Compute Community Activity Scores
+on:
+  schedule:
+    - cron: '0 0 * * *'  # Daily at midnight
+  workflow_dispatch:       # Manual trigger
+jobs:
+  compute-scores:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  # v4.2.2
+      - name: Setup Node.js
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020  # v4.2.0
+        with:
+          node-version: '18'
+      - name: Run activity score computation
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: node agent/scripts/compute-activity-scores.js
+      - name: Commit updated scores
+        uses: peter-evans/create-pull-request@271a8d0340265f705b14b6d32b2b3e36ac28eb95  # v7.0.8
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          commit-message: "chore: update community activity scores"
+          title: "chore: update community activity scores"
+          body: "Automated daily update of community activity scores."
+          branch: "auto/update-community-activity-scores"
+          delete-branch: true
+          add-paths: data/community_activity.json

README.md

@@ -486,6 +486,27 @@ The Edge Function proxies GitHub API calls so your token never hits the client.
 | `GET /api/github?repo=owner/repo&gfi=1` | Good First Issue count only (faster, cached separately) |
 | `GET /api/github?repo=owner/repo&gfi=1&issues=1` | Full list of up to 30 open Good First Issues |
 
+---
+## 🏆 Community Activity Score
+
+Each organization is scored daily (0–100) based on GitHub activity signals fetched by `.github/workflows/compute-activity-scores.yml`:
+
+| Signal | Weight | Description |
+|--------|--------|-------------|
+| Issue resolution time | 30% | Average days to close issues |
+| Commit frequency | 20% | Commits in last 90 days |
+| PR merge rate | 15% | % of PRs merged in 90 days |
+| Repository freshness | 20% | Days since last push |
+| Stars score | 15% | Scaled stargazers count |
+
+**Tiers:**
+- 🟢 **Very Active** — score 75–100
+- 🔵 **Active** — score 50–74
+- 🟡 **Moderate** — score 25–49
+- 🔴 **Low Activity** — score 0–24
+
+Scores are stored in `data/community_activity.json` and updated daily. Organizations with no GitHub data are excluded from scoring.
+
 All responses are cached in-memory for **1 hour** on the Edge runtime.
 # 🚀 Official Open Source Program Project
 

agent/scripts/compute-activity-scores.js

@@ -0,0 +1,159 @@
+// @ts-check
+/* eslint-env node */
+// Computes community activity scores for all GSoC orgs
+// Run via GitHub Actions daily
+
+const fs = require('node:fs');
+const path = require('node:path');
+const GITHUB_TOKEN = process.env.GITHUB_TOKEN;
+const OUTPUT_FILE = path.join(__dirname, '../../data/community_activity.json');
+
+if (!GITHUB_TOKEN) {
+  console.error('❌ GITHUB_TOKEN is required');
+  process.exit(1);
+}
+
+const headers = {
+  'Authorization': `token ${GITHUB_TOKEN}`,
+  'Accept': 'application/vnd.github.v3+json',
+  'User-Agent': 'gsoc-org-finder'
+};
+
+// Load orgs from org.js
+const orgDataRaw = fs.readFileSync(
+  path.join(__dirname, '../../src/js/org.js'), 'utf8'
+);
+
+// Extract github field from each org
+const githubRepos = [];
+const orgMatches = orgDataRaw.matchAll(/name:\s*"([^"]+)"[^}]+github:\s*"([^"]+)"/g);
+for (const m of orgMatches) {
+  const name = m[1];
+  const repo = m[2];
+  if (repo && repo.includes('/')) {
+    githubRepos.push({ name, repo });
+  } else {
+    console.warn(`Skipping bare owner (no repo path): ${name} → "${repo}"`);
+  }
+}
+
+async function fetchJSON(url) {
+  const res = await fetch(url, { headers });
+  if (!res.ok) return null;
+  return res.json();
+}
+
+function computeScore({ issueResponseDays, commitFrequency, prMergeRate, ideasFreshnessDays, starsGrowth }) {
+  const issueScore = Math.max(0, 100 - (issueResponseDays * 5));      
+  const commitScore = Math.min(100, commitFrequency * 10);             
+  const prScore = Math.min(100, prMergeRate * 100);                    
+  const ideasScore = Math.max(0, 100 - (ideasFreshnessDays * 0.5));  
+  const growthScore = Math.min(100, starsGrowth * 2);                  
+
+  return Math.round(
+    issueScore * 0.3 +
+    commitScore * 0.2 +
+    prScore * 0.15 +
+    ideasScore * 0.2 +
+    growthScore * 0.15
+  );
+}
+
+function getTier(score) {
+  if (score >= 80) return { tier: 'very-active', label: '🟢 Very Active' };
+  if (score >= 60) return { tier: 'active', label: '🔵 Active' };
+  if (score >= 40) return { tier: 'moderate', label: '🟡 Moderate' };
+  return { tier: 'low', label: '🔴 Low Activity' };
+}
+
+async function analyzeOrg({ name, repo }) {
+  try {
+    const since = new Date(Date.now() - 90 * 86400000).toISOString();
+
+    const commits = await fetchJSON(
+      `https://api.github.com/repos/${repo}/commits?since=${since}&per_page=100`
+    );
+    const commitFrequency = Array.isArray(commits) ? commits.length / 90 : 0;
+
+    const issues = await fetchJSON(
+      `https://api.github.com/repos/${repo}/issues?state=closed&since=${since}&per_page=100`
+    );
+    let issueResponseDays = null; 
+    if (Array.isArray(issues) && issues.length > 0) {
+      const responseTimes = issues
+        .filter(i => i.created_at && i.closed_at && !i.pull_request)
+        .map(i => (+new Date(i.closed_at) - +new Date(i.created_at)) / 86400000);
+      if (responseTimes.length > 0) {
+        issueResponseDays = responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length;
+      }
+    }
+
+    // Fetch PRs
+    const prs = await fetchJSON(
+      `https://api.github.com/repos/${repo}/pulls?state=closed&per_page=100`
+    );
+    let prMergeRate = null;
+    if (Array.isArray(prs) && prs.length > 0) {
+      const recentPrs = prs.filter(p => p.closed_at && new Date(p.closed_at) >= new Date(since));
+      if (recentPrs.length > 0) {
+        const merged = recentPrs.filter(p => p.merged_at).length;
+        prMergeRate = merged / recentPrs.length;
+      }
+    }
+
+    const repoData = await fetchJSON(`https://api.github.com/repos/${repo}`);
+    const starsGrowth = repoData ? Math.min(50, repoData.stargazers_count / 1000) : 0;
+
+    const ideasFreshnessDays = repoData?.pushed_at
+      ? (Date.now() - new Date(repoData.pushed_at)) / 86400000
+      : 60;
+
+    if (issueResponseDays === null || prMergeRate === null) return null;
+
+    const score = computeScore({
+      issueResponseDays: issueResponseDays,
+      commitFrequency,
+      prMergeRate: prMergeRate,
+      ideasFreshnessDays,
+      starsGrowth
+    });
+    const { tier, label } = getTier(score);
+
+    return {
+      score,
+      tier,
+      label,
+      signals: {
+        issueResponseDays: issueResponseDays === null ? null : Math.round(issueResponseDays),
+        commitFrequency: Math.round(commitFrequency * 10) / 10,
+        prMergeRate: prMergeRate === null ? null : Math.round(prMergeRate * 100),
+        ideasFreshnessDays: Math.round(ideasFreshnessDays),
+        starsGrowth: Math.round(starsGrowth * 10) / 10
+      },
+      lastUpdated: new Date().toISOString()
+    };
+  } catch (e) {
+    console.error(`Error analyzing ${name}:`, e.message);
+    return null;
+  }
+}
+
+async function main() {
+  console.log(`Analyzing ${githubRepos.length} orgs...`);
+  const results = {};
+
+  for (const org of githubRepos) {
+    console.log(`Processing: ${org.name}`);
+    const data = await analyzeOrg(org);
+    if (data) results[org.name] = data;
+    await new Promise(r => setTimeout(r, 500));
+  }
+
+  fs.writeFileSync(OUTPUT_FILE, JSON.stringify(results, null, 2));
+  console.log(`✅ Done! Wrote ${Object.keys(results).length} orgs to community_activity.json`);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});