fix: ratio-based issue scoring — popular projects no longer penalized

Before: absolute issue count / 4 (React with 1000 issues = score 0 on this dimension)
After: issues / stars ratio (React 1000/200k = 0.005 ratio = full score)

This fixes the most critical scoring bug — popular healthy projects like React,
Angular, Vue were incorrectly penalized for having many open issues. A project
with 1000 issues and 200k stars is healthier than one with 50 issues and 30 stars.

Risk dimension also uses ratio: issueBacklogRatio > 1.0 = -3, > 0.5 = -1.5

Tests: 32 passing (added ratio-based scoring test for popular projects)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: dusan-maintains

cli/lib/scoring.js

@@ -34,10 +34,21 @@ function computeScore(info) {
   const pushRecency = decayScore(daysSincePush, 180);
 
   const openIssues = info.openIssues || 0;
-  // Stricter curve: 10 issues = 7.5, 30 issues = 2.5, 40+ = 0
-  const issueRatio = openIssues > 0
-    ? Math.max(parseFloat((10 - Math.min(openIssues / 4, 10)).toFixed(2)), 0)
-    : 10;
+  const stars = info.stars || 0;
+  // Ratio-based: issues relative to community size (stars).
+  // React (200 issues / 230k stars = 0.0009 ratio) = healthy.
+  // Small lib (200 issues / 50 stars = 4.0 ratio) = abandoned.
+  // Ratio > 0.1 starts penalizing, > 1.0 = zero score.
+  let issueRatio;
+  if (openIssues === 0) {
+    issueRatio = 10;
+  } else if (stars > 0) {
+    const ratio = openIssues / stars;
+    issueRatio = Math.max(parseFloat((10 - Math.min(ratio / 0.1 * 10, 10)).toFixed(2)), 0);
+  } else {
+    // No stars data — fall back to absolute count (lenient curve)
+    issueRatio = Math.max(parseFloat((10 - Math.min(openIssues / 10, 10)).toFixed(2)), 0);
+  }
 
   const publishRecency = decayScore(info.daysSincePublish || 9999, 365);
 
@@ -57,8 +68,10 @@ function computeScore(info) {
   if (daysSincePush > 365) riskBase -= 4;
   else if (daysSincePush > 180) riskBase -= 2;
 
-  if (openIssues > 100) riskBase -= 3;
-  else if (openIssues > 50) riskBase -= 1.5;
+  // Issue backlog risk: ratio-based (issues / max(stars, 1))
+  const issueBacklogRatio = openIssues / Math.max(stars, 1);
+  if (issueBacklogRatio > 1.0) riskBase -= 3;
+  else if (issueBacklogRatio > 0.5) riskBase -= 1.5;
 
   if (info.daysSincePublish > 730) riskBase -= 2;
   else if (info.daysSincePublish > 365) riskBase -= 1;

cli/test/scoring.test.js

@@ -183,18 +183,30 @@ describe('computeScore', () => {
       `With license (${withLicense.health_score}) should score higher than no license (${noLicense.health_score})`);
   });
 
-  it('stricter issue scoring: 20 issues should penalize significantly', () => {
+  it('ratio-based issue scoring: small project with many issues penalized', () => {
     const clean = computeScore({
-      stars: 100, forks: 10, openIssues: 0, downloads: 1000,
+      stars: 50, forks: 5, openIssues: 0, downloads: 1000,
       daysSincePush: 30, daysSincePublish: 60,
       deprecated: false, archived: false, license: 'MIT'
     });
-    const issues20 = computeScore({
-      stars: 100, forks: 10, openIssues: 20, downloads: 1000,
+    const overloaded = computeScore({
+      stars: 50, forks: 5, openIssues: 50, downloads: 1000,
       daysSincePush: 30, daysSincePublish: 60,
       deprecated: false, archived: false, license: 'MIT'
     });
-    const diff = clean.health_score - issues20.health_score;
-    assert.ok(diff > 3, `20 open issues should drop score by >3 points (actual: ${diff.toFixed(1)})`);
+    const diff = clean.health_score - overloaded.health_score;
+    assert.ok(diff > 3, `50 issues on 50-star project should penalize (actual: ${diff.toFixed(1)})`);
+  });
+
+  it('ratio-based issue scoring: popular project with many issues not penalized', () => {
+    // React-like: 200k stars, 1000 issues = ratio 0.005 = healthy
+    const result = computeScore({
+      stars: 200000, forks: 40000, openIssues: 1000, downloads: 50000000,
+      daysSincePush: 1, daysSincePublish: 7,
+      deprecated: false, archived: false, license: 'MIT'
+    });
+    assert.ok(result.health_score >= 70,
+      `Popular project with 1000 issues should still score 70+ (got ${result.health_score})`);
+    assert.equal(result.risk_level, 'healthy');
   });
 });