@oss-scout/core 1.1.0 → 1.2.1

package/dist/core/issue-discovery.js

@@ -28,6 +28,29 @@ const MODULE = "issue-discovery";
 const LOW_BUDGET_THRESHOLD = 20;
 /** If remaining search quota is below this, only run Phase 0. */
 const CRITICAL_BUDGET_THRESHOLD = 10;
+/**
+ * Page size for Phase 0 (repos the user has contributed to). Larger than the
+ * default 5 so the backlog of open issues in known repos is reachable, not
+ * just the 5 newest-created. One `listForRepo` call regardless of page size,
+ * so this widens the candidate pool at no extra REST cost.
+ */
+const PHASE0_PER_PAGE = 30;
+/**
+ * Max issue age (by last activity) for Phase 0 contributed repos. Relaxed well
+ * past the default `maxIssueAgeDays` (90) because in a repo the user already
+ * knows, an older-but-still-open issue is still worth evaluating — the vetter
+ * screens staleness, existing PRs, and claims downstream.
+ */
+const CONTRIBUTED_REPO_MAX_AGE_DAYS = 365;
+/**
+ * Cap on Phase 0's share of `maxResults`. Phase 0 (contributed repos) fetches
+ * deeply (`PHASE0_PER_PAGE`) and can otherwise fill the entire result budget,
+ * which makes the `allCandidates.length < maxResults` gate false for every
+ * later phase so starred (Phase 1) and broad (Phases 2/3) never run. Reserving
+ * half the budget for the other strategies keeps each search round varied
+ * instead of returning only contributed-repo results.
+ */
+const PHASE0_MAX_SHARE = 0.5;
 /** Build a reusable filter function from config. */
 function buildIssueFilter(config) {
     return (items) => {
@@ -63,8 +86,8 @@ function buildIssueFilter(config) {
 }
 /** Phase 0: Search repos where user has merged PRs (highest merge probability). */
 async function runPhase0(octokit, vetter, repos, maxResults, filterIssues) {
-    info(MODULE, `Phase 0: Searching issues in ${repos.length} merged-PR repos (no label filter)...`);
-    const { candidates, allReposFailed, rateLimitHit } = await fetchIssuesFromKnownRepos(octokit, vetter, repos, [], maxResults, "merged_pr", filterIssues);
+    info(MODULE, `Phase 0: Searching issues in ${repos.length} merged-PR repos (no label filter, ${PHASE0_PER_PAGE}/repo)...`);
+    const { candidates, allReposFailed, rateLimitHit } = await fetchIssuesFromKnownRepos(octokit, vetter, repos, [], maxResults, "merged_pr", filterIssues, PHASE0_PER_PAGE);
     info(MODULE, `Found ${candidates.length} candidates from merged-PR repos`);
     return {
         candidates,
@@ -374,15 +397,24 @@ export class IssueDiscovery {
         if (aiBlocklisted.size > 0) {
             debug(MODULE, `[AI_POLICY_FILTER] Filtering issues from ${aiBlocklisted.size} blocklisted repo(s): ${[...aiBlocklisted].join(", ")}`);
         }
-        const filterIssues = buildIssueFilter({
+        const baseFilterConfig = {
             excludedRepos: new Set(config.excludeRepos.map((r) => r.toLowerCase())),
             excludeOrgs: new Set((config.excludeOrgs ?? []).map((o) => o.toLowerCase())),
             aiBlocklisted,
             lowScoringRepos,
             skippedUrls: options.skippedUrls ?? new Set(),
-            maxAgeDays: config.maxIssueAgeDays || 90,
             now: new Date(),
             includeDocIssues: config.includeDocIssues ?? true,
+        };
+        const filterIssues = buildIssueFilter({
+            ...baseFilterConfig,
+            maxAgeDays: config.maxIssueAgeDays || 90,
+        });
+        // Phase 0 (contributed repos) gets a relaxed age window so the existing
+        // backlog surfaces, not just issues active in the last 90 days.
+        const filterIssuesPhase0 = buildIssueFilter({
+            ...baseFilterConfig,
+            maxAgeDays: CONTRIBUTED_REPO_MAX_AGE_DAYS,
         });
         // Phase 0: Repos the user has engaged with — merged PRs first (strongest
         // signal), then open PRs (active engagement even without a merge yet).
@@ -398,10 +430,21 @@ export class IssueDiscovery {
                 break;
         }
         const phase0RepoSet = new Set(phase0Repos);
+        // Only cap Phase 0 when a later phase can actually consume the reserved
+        // budget — otherwise (no starred repos, broad/maintained disabled) the
+        // reservation would just shrink the result set with nothing to fill it.
+        const otherStrategiesCanRun = (starredRepos.length > 0 && enabledStrategies.has("starred")) ||
+            enabledStrategies.has("broad") ||
+            enabledStrategies.has("maintained");
         if (phase0Repos.length > 0 && enabledStrategies.has("merged")) {
-            const remaining = maxResults - allCandidates.length;
+            // Cap Phase 0's share so it can't consume the whole budget and starve
+            // the starred/broad phases (which gate on allCandidates < maxResults).
+            const phase0Cap = otherStrategiesCanRun
+                ? Math.max(1, Math.ceil(maxResults * PHASE0_MAX_SHARE))
+                : maxResults;
+            const remaining = Math.min(maxResults - allCandidates.length, phase0Cap);
             if (remaining > 0) {
-                const result = await runPhase0(this.octokit, this.vetter, phase0Repos, remaining, filterIssues);
+                const result = await runPhase0(this.octokit, this.vetter, phase0Repos, remaining, filterIssuesPhase0);
                 recordPhaseResult("0", result);
             }
             strategiesUsed.push("merged");

package/dist/core/search-phases.d.ts

@@ -43,7 +43,7 @@ export declare function fetchIssuesFromMaintainedRepos(octokit: Octokit, repos:
  * calls `GET /repos/{owner}/{repo}/issues` which counts against the much
  * larger Core API rate limit and avoids consuming the scarce Search quota.
  */
-export declare function fetchIssuesFromKnownRepos(octokit: Octokit, vetter: IssueVetter, repos: string[], labels: string[], maxResults: number, priority: SearchPriority, filterFn: (items: GitHubSearchItem[]) => GitHubSearchItem[]): Promise<{
+export declare function fetchIssuesFromKnownRepos(octokit: Octokit, vetter: IssueVetter, repos: string[], labels: string[], maxResults: number, priority: SearchPriority, filterFn: (items: GitHubSearchItem[]) => GitHubSearchItem[], perPage?: number): Promise<{
     candidates: IssueCandidate[];
     allReposFailed: boolean;
     rateLimitHit: boolean;

package/dist/core/search-phases.js

@@ -186,7 +186,7 @@ export async function fetchIssuesFromMaintainedRepos(octokit, repos, minStars, m
  * calls `GET /repos/{owner}/{repo}/issues` which counts against the much
  * larger Core API rate limit and avoids consuming the scarce Search quota.
  */
-export async function fetchIssuesFromKnownRepos(octokit, vetter, repos, labels, maxResults, priority, filterFn) {
+export async function fetchIssuesFromKnownRepos(octokit, vetter, repos, labels, maxResults, priority, filterFn, perPage = 5) {
     const candidates = [];
     let failedRepos = 0;
     let rateLimitFailures = 0;
@@ -213,7 +213,7 @@ export async function fetchIssuesFromKnownRepos(octokit, vetter, repos, labels,
                     state: "open",
                     sort: "created",
                     direction: "desc",
-                    per_page: 5,
+                    per_page: perPage,
                     ...(label !== undefined ? { labels: label } : {}),
                 });
                 for (const issue of response.data) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oss-scout/core",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "Personalized GitHub issue finder with multi-strategy search, deep vetting, and viability scoring — CLI, library, MCP server, and Claude Code plugin",
   "type": "module",
   "bin": {