@oss-scout/mcp 0.3.0 → 0.4.0

package/dist/mcp-server.bundle.cjs

@@ -35817,8 +35817,11 @@ var ScoutPreferencesSchema = external_exports3.object({
   maxIssueAgeDays: external_exports3.number().default(90),
   includeDocIssues: external_exports3.boolean().default(true),
   minRepoScoreThreshold: external_exports3.number().default(4),
+  interPhaseDelayMs: external_exports3.number().min(0).max(12e4).default(3e4),
   persistence: PersistenceModeSchema.default("local"),
-  defaultStrategy: external_exports3.array(SearchStrategySchema).optional()
+  defaultStrategy: external_exports3.array(SearchStrategySchema).optional(),
+  broadPhaseDelayMs: external_exports3.number().min(0).max(3e5).default(9e4),
+  skipBroadWhenSufficientResults: external_exports3.number().int().min(0).max(100).default(15)
 });
 var ScoutStateSchema = external_exports3.object({
   version: external_exports3.literal(1),
@@ -36833,7 +36836,6 @@ var IssueVetter = class {
 var MODULE8 = "search-phases";
 var GITHUB_MAX_BOOLEAN_OPS = 5;
 var INTER_QUERY_DELAY_MS = 2e3;
-var BATCH_SIZE = 3;
 function chunkLabels(labels, reservedOps = 0) {
   const maxPerChunk = GITHUB_MAX_BOOLEAN_OPS - reservedOps + 1;
   if (maxPerChunk < 1) {
@@ -36879,26 +36881,138 @@ function interleaveArrays(arrays) {
   }
   return result;
 }
-function batchRepos(repos, batchSize) {
-  const batches = [];
-  for (let i = 0; i < repos.length; i += batchSize) {
-    batches.push(repos.slice(i, i + batchSize));
-  }
-  return batches;
-}
 var SEARCH_CACHE_TTL_MS = 15 * 60 * 1e3;
 async function cachedSearchIssues(octokit, params) {
   const cacheKey = `search:${params.q}:${params.sort}:${params.order}:${params.per_page}`;
-  return cachedTimeBased(getHttpCache(), cacheKey, SEARCH_CACHE_TTL_MS, async () => {
-    const tracker = getSearchBudgetTracker();
-    await tracker.waitForBudget();
+  const cache = getHttpCache();
+  const cached2 = cache.getIfFresh(cacheKey, SEARCH_CACHE_TTL_MS);
+  if (cached2) {
+    debug(MODULE8, `Search cache hit for query`);
+    return cached2;
+  }
+  const tracker = getSearchBudgetTracker();
+  await tracker.waitForBudget();
+  let data;
+  try {
+    const response = await octokit.search.issuesAndPullRequests(params);
+    data = response.data;
+  } finally {
+    tracker.recordCall();
+  }
+  if (data.items.length > 0) {
+    cache.set(cacheKey, "", data);
+  } else {
+    debug(MODULE8, `Skipping cache for empty search result (possible rate limit artifact)`);
+  }
+  return data;
+}
+async function fetchIssuesFromMaintainedRepos(octokit, repos, minStars, maxResults) {
+  const items = [];
+  for (const repoFullName of repos) {
+    if (items.length >= maxResults * 3)
+      break;
+    const [owner, repo] = repoFullName.split("/");
+    if (!owner || !repo)
+      continue;
     try {
-      const { data } = await octokit.search.issuesAndPullRequests(params);
-      return data;
-    } finally {
-      tracker.recordCall();
+      const { data: repoData } = await octokit.repos.get({ owner, repo });
+      if (!repoData.pushed_at)
+        continue;
+      const pushedAt = new Date(repoData.pushed_at);
+      const thirtyDaysAgo = /* @__PURE__ */ new Date();
+      thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+      if (pushedAt < thirtyDaysAgo)
+        continue;
+      if ((repoData.stargazers_count ?? 0) < minStars)
+        continue;
+      if (repoData.archived)
+        continue;
+      const { data: issues } = await octokit.issues.listForRepo({
+        owner,
+        repo,
+        state: "open",
+        sort: "created",
+        direction: "desc",
+        per_page: 5
+      });
+      const realIssues = issues.filter((i) => !i.pull_request && !i.assignee);
+      for (const issue2 of realIssues) {
+        items.push({
+          html_url: issue2.html_url,
+          repository_url: `https://api.github.com/repos/${repoFullName}`,
+          updated_at: issue2.updated_at ?? "",
+          title: issue2.title,
+          labels: issue2.labels
+        });
+      }
+      await sleep(INTER_QUERY_DELAY_MS);
+    } catch (error48) {
+      if (getHttpStatusCode(error48) === 401)
+        throw error48;
+      if (isRateLimitError(error48)) {
+        warn(MODULE8, `Rate limit hit fetching issues from ${repoFullName}:`, errorMessage(error48));
+        break;
+      }
+      warn(MODULE8, `Error fetching issues from ${repoFullName}:`, errorMessage(error48));
     }
-  });
+  }
+  return items;
+}
+async function fetchIssuesFromKnownRepos(octokit, vetter, repos, labels, maxResults, priority, filterFn) {
+  const candidates = [];
+  let failedRepos = 0;
+  let rateLimitFailures = 0;
+  for (let i = 0; i < repos.length; i++) {
+    if (candidates.length >= maxResults)
+      break;
+    if (i > 0)
+      await sleep(INTER_QUERY_DELAY_MS);
+    const repoFullName = repos[i];
+    const [owner, repo] = repoFullName.split("/");
+    try {
+      const response = await octokit.issues.listForRepo({
+        owner,
+        repo,
+        state: "open",
+        sort: "created",
+        direction: "desc",
+        per_page: 5,
+        ...labels.length > 0 ? { labels: labels.join(",") } : {}
+      });
+      const issuesOnly = response.data.filter((item) => !("pull_request" in item) && !item.assignee);
+      const mapped = issuesOnly.map((issue2) => ({
+        html_url: issue2.html_url,
+        repository_url: `https://api.github.com/repos/${repoFullName}`,
+        updated_at: issue2.updated_at ?? "",
+        title: issue2.title,
+        labels: issue2.labels
+      }));
+      if (mapped.length > 0) {
+        const filtered = filterFn(mapped);
+        if (filtered.length > 0) {
+          const remainingNeeded = maxResults - candidates.length;
+          const { candidates: vetted, rateLimitHit: vetRateLimitHit } = await vetter.vetIssuesParallel(filtered.slice(0, remainingNeeded * 2).map((item) => item.html_url), remainingNeeded, priority);
+          candidates.push(...vetted);
+          if (vetRateLimitHit)
+            rateLimitFailures++;
+        }
+      }
+    } catch (error48) {
+      if (getHttpStatusCode(error48) === 401)
+        throw error48;
+      failedRepos++;
+      if (isRateLimitError(error48)) {
+        rateLimitFailures++;
+      }
+      warn(MODULE8, `Error fetching issues from ${repoFullName}:`, errorMessage(error48));
+    }
+  }
+  const allReposFailed = failedRepos === repos.length && repos.length > 0;
+  const rateLimitHit = rateLimitFailures > 0;
+  if (allReposFailed) {
+    warn(MODULE8, `All ${repos.length} repo(s) failed for ${priority} phase. This may indicate a systemic issue (rate limit, auth, network).`);
+  }
+  return { candidates, allReposFailed, rateLimitHit };
 }
 async function searchWithChunkedLabels(octokit, labels, reservedOps, buildQuery, perPage) {
   const labelChunks = chunkLabels(labels, reservedOps);
@@ -36954,50 +37068,9 @@ async function filterVetAndScore(vetter, items, filterIssues, excludedRepoSets,
   }
   return { candidates: starFiltered, allVetFailed, rateLimitHit };
 }
-async function searchInRepos(octokit, vetter, repos, baseQualifiers, labels, maxResults, priority, filterFn) {
-  const candidates = [];
-  const batches = batchRepos(repos, BATCH_SIZE);
-  let failedBatches = 0;
-  let rateLimitFailures = 0;
-  for (let batchIdx = 0; batchIdx < batches.length; batchIdx++) {
-    const batch = batches[batchIdx];
-    if (candidates.length >= maxResults)
-      break;
-    if (batchIdx > 0)
-      await sleep(INTER_QUERY_DELAY_MS);
-    try {
-      const repoFilter = batch.map((r) => `repo:${r}`).join(" OR ");
-      const repoOps = batch.length - 1;
-      const perPage = Math.min(30, (maxResults - candidates.length) * 3);
-      const allItems = await searchWithChunkedLabels(octokit, labels, repoOps, (labelQ) => `${baseQualifiers} ${labelQ} (${repoFilter})`.replace(/  +/g, " ").trim(), perPage);
-      if (allItems.length > 0) {
-        const filtered = filterFn(allItems);
-        const remainingNeeded = maxResults - candidates.length;
-        const { candidates: vetted, rateLimitHit: vetRateLimitHit } = await vetter.vetIssuesParallel(filtered.slice(0, remainingNeeded * 2).map((i) => i.html_url), remainingNeeded, priority);
-        candidates.push(...vetted);
-        if (vetRateLimitHit)
-          rateLimitFailures++;
-      }
-    } catch (error48) {
-      failedBatches++;
-      if (isRateLimitError(error48)) {
-        rateLimitFailures++;
-      }
-      const batchReposStr = batch.join(", ");
-      warn(MODULE8, `Error searching issues in batch [${batchReposStr}]:`, errorMessage(error48));
-    }
-  }
-  const allBatchesFailed = failedBatches === batches.length && batches.length > 0;
-  const rateLimitHit = rateLimitFailures > 0;
-  if (allBatchesFailed) {
-    warn(MODULE8, `All ${batches.length} batch(es) failed for ${priority} phase. This may indicate a systemic issue (rate limit, auth, network).`);
-  }
-  return { candidates, allBatchesFailed, rateLimitHit };
-}
 
 // ../core/dist/core/issue-discovery.js
 var MODULE9 = "issue-discovery";
-var INTER_PHASE_DELAY_MS = 2e3;
 var LOW_BUDGET_THRESHOLD = 20;
 var CRITICAL_BUDGET_THRESHOLD = 10;
 function buildIssueFilter(config2) {
@@ -37029,24 +37102,25 @@ function buildIssueFilter(config2) {
     });
   };
 }
-async function runPhase0(octokit, vetter, repos, baseQualifiers, maxResults, filterIssues) {
+async function runPhase0(octokit, vetter, repos, maxResults, filterIssues) {
   info(MODULE9, `Phase 0: Searching issues in ${repos.length} merged-PR repos (no label filter)...`);
-  const { candidates, allBatchesFailed, rateLimitHit } = await searchInRepos(octokit, vetter, repos, baseQualifiers, [], maxResults, "merged_pr", filterIssues);
+  const { candidates, allReposFailed, rateLimitHit } = await fetchIssuesFromKnownRepos(octokit, vetter, repos, [], maxResults, "merged_pr", filterIssues);
   info(MODULE9, `Found ${candidates.length} candidates from merged-PR repos`);
   return {
     candidates,
-    error: allBatchesFailed ? "All merged-PR repo batches failed" : null,
+    error: allReposFailed ? "All merged-PR repo fetches failed" : null,
     rateLimitHit
   };
 }
-async function runPhase1(octokit, vetter, repos, baseQualifiers, labels, maxResults, filterIssues) {
+async function runPhase1(octokit, vetter, repos, labels, maxResults, filterIssues) {
   info(MODULE9, `Phase 1: Searching issues in ${repos.length} starred repos...`);
   const phase1Labels = labels.slice(0, 3);
-  const { candidates, allBatchesFailed, rateLimitHit } = await searchInRepos(octokit, vetter, repos.slice(0, 10), baseQualifiers, phase1Labels, maxResults, "starred", filterIssues);
+  const reposToSearch = repos.slice(0, 10);
+  const { candidates, allReposFailed, rateLimitHit } = await fetchIssuesFromKnownRepos(octokit, vetter, reposToSearch, phase1Labels, maxResults, "starred", filterIssues);
   info(MODULE9, `Found ${candidates.length} candidates from starred repos`);
   return {
     candidates,
-    error: allBatchesFailed ? "All starred repo batches failed" : null,
+    error: allReposFailed ? "All starred repo fetches failed" : null,
     rateLimitHit
   };
 }
@@ -37112,8 +37186,32 @@ async function runPhase2(octokit, vetter, scopes, labels, configLabels, baseQual
     rateLimitHit
   };
 }
-async function runPhase3(octokit, vetter, langQuery, minStars, projectCategories, maxResults, phase0RepoSet, starredRepoSet, existingCandidates, filterIssues) {
+async function runPhase3(octokit, vetter, langQuery, minStars, projectCategories, maxResults, phase0RepoSet, starredRepoSet, starredRepos, existingCandidates, filterIssues) {
   info(MODULE9, "Phase 3: Searching actively maintained repos...");
+  const seenRepos = new Set(existingCandidates.map((c) => c.issue.repo));
+  const eligibleStarred = starredRepos.filter((r) => !phase0RepoSet.has(r) && !seenRepos.has(r));
+  if (eligibleStarred.length > 0) {
+    info(MODULE9, `Phase 3: Checking ${eligibleStarred.length} starred repos via REST API...`);
+    const restItems = await fetchIssuesFromMaintainedRepos(octokit, eligibleStarred.slice(0, 15), minStars, maxResults);
+    if (restItems.length > 0) {
+      try {
+        const { candidates, allVetFailed, rateLimitHit: vetRateLimitHit } = await filterVetAndScore(vetter, restItems, filterIssues, [phase0RepoSet, seenRepos], maxResults, minStars, "Phase 3 (REST)");
+        if (candidates.length > 0) {
+          info(MODULE9, `Found ${candidates.length} candidates from maintained-repo REST search`);
+          return {
+            candidates,
+            error: allVetFailed ? "all vetting failed" : null,
+            rateLimitHit: vetRateLimitHit
+          };
+        }
+      } catch (error48) {
+        if (getHttpStatusCode(error48) === 401)
+          throw error48;
+        warn(MODULE9, `Phase 3 REST vetting failed, falling back to Search API:`, errorMessage(error48));
+      }
+    }
+  }
+  info(MODULE9, "Phase 3: Falling back to Search API...");
   const thirtyDaysAgo = /* @__PURE__ */ new Date();
   thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
   const pushedSince = thirtyDaysAgo.toISOString().split("T")[0];
@@ -37128,7 +37226,6 @@ async function runPhase3(octokit, vetter, langQuery, minStars, projectCategories
       per_page: maxResults * 3
     });
     info(MODULE9, `Found ${data.total_count} issues in maintained-repo search, processing top ${data.items.length}...`);
-    const seenRepos = new Set(existingCandidates.map((c) => c.issue.repo));
     const { candidates, allVetFailed, rateLimitHit: vetRateLimitHit } = await filterVetAndScore(vetter, data.items, filterIssues, [phase0RepoSet, starredRepoSet, seenRepos], maxResults, minStars, "Phase 3");
     info(MODULE9, `Found ${candidates.length} candidates from maintained-repo search`);
     return {
@@ -37204,6 +37301,7 @@ var IssueDiscovery = class {
     const labels = options.labels || (scopes ? buildEffectiveLabels(scopes, config2.labels) : config2.labels);
     const maxResults = options.maxResults || 10;
     const minStars = config2.minStars ?? 50;
+    const interPhaseDelay = config2.interPhaseDelayMs ?? 3e4;
     const ALL_STRATEGIES = CONCRETE_STRATEGIES;
     const rawStrategies = options.strategies ?? config2.defaultStrategy ?? ["all"];
     const enabledStrategies = new Set(rawStrategies.includes("all") ? ALL_STRATEGIES : rawStrategies);
@@ -37264,7 +37362,7 @@ var IssueDiscovery = class {
     if (phase0Repos.length > 0 && enabledStrategies.has("merged")) {
       const remaining = maxResults - allCandidates.length;
       if (remaining > 0) {
-        const result = await runPhase0(this.octokit, this.vetter, phase0Repos, baseQualifiers, remaining, filterIssues);
+        const result = await runPhase0(this.octokit, this.vetter, phase0Repos, remaining, filterIssues);
         allCandidates.push(...result.candidates);
         phaseErrors["0"] = result.error;
         if (result.rateLimitHit)
@@ -37273,12 +37371,15 @@ var IssueDiscovery = class {
       strategiesUsed.push("merged");
     }
     if (allCandidates.length < maxResults && starredRepos.length > 0 && searchBudget >= CRITICAL_BUDGET_THRESHOLD && enabledStrategies.has("starred")) {
-      await sleep(INTER_PHASE_DELAY_MS);
+      if (interPhaseDelay > 0) {
+        info(MODULE9, `Waiting ${(interPhaseDelay / 1e3).toFixed(0)}s between phases for rate limit management...`);
+        await sleep(interPhaseDelay);
+      }
       const reposToSearch = starredRepos.filter((r) => !phase0RepoSet.has(r));
       if (reposToSearch.length > 0) {
         const remaining = maxResults - allCandidates.length;
         if (remaining > 0) {
-          const result = await runPhase1(this.octokit, this.vetter, reposToSearch, baseQualifiers, labels, remaining, filterIssues);
+          const result = await runPhase1(this.octokit, this.vetter, reposToSearch, labels, remaining, filterIssues);
           allCandidates.push(...result.candidates);
           phaseErrors["1"] = result.error;
           if (result.rateLimitHit)
@@ -37287,20 +37388,38 @@ var IssueDiscovery = class {
       }
       strategiesUsed.push("starred");
     }
+    const broadDelay = config2.broadPhaseDelayMs ?? 9e4;
+    const skipThreshold = config2.skipBroadWhenSufficientResults ?? 15;
     if (allCandidates.length < maxResults && searchBudget >= LOW_BUDGET_THRESHOLD && enabledStrategies.has("broad")) {
-      await sleep(INTER_PHASE_DELAY_MS);
-      const remaining = maxResults - allCandidates.length;
-      const result = await runPhase2(this.octokit, this.vetter, scopes, labels, config2.labels, baseQualifiers, remaining, minStars, phase0RepoSet, starredRepoSet, allCandidates, filterIssues);
-      allCandidates.push(...result.candidates);
-      phaseErrors["2"] = result.error;
-      if (result.rateLimitHit)
-        rateLimitHitDuringSearch = true;
+      if (skipThreshold > 0 && allCandidates.length >= skipThreshold) {
+        info(MODULE9, `Skipping broad search: already found ${allCandidates.length} candidates (threshold: ${skipThreshold})`);
+      } else {
+        if (interPhaseDelay > 0) {
+          info(MODULE9, `Waiting ${(interPhaseDelay / 1e3).toFixed(0)}s between phases for rate limit management...`);
+          await sleep(interPhaseDelay);
+        }
+        if (allCandidates.length > 0 && broadDelay > 0) {
+          info(MODULE9, `Waiting ${(broadDelay / 1e3).toFixed(0)}s for rate limit cooldown before broad search...`);
+          await sleep(broadDelay);
+        } else if (allCandidates.length === 0) {
+          info(MODULE9, `Skipping broad phase delay: no results from previous phases, proceeding immediately`);
+        }
+        const remaining = maxResults - allCandidates.length;
+        const result = await runPhase2(this.octokit, this.vetter, scopes, labels, config2.labels, baseQualifiers, remaining, minStars, phase0RepoSet, starredRepoSet, allCandidates, filterIssues);
+        allCandidates.push(...result.candidates);
+        phaseErrors["2"] = result.error;
+        if (result.rateLimitHit)
+          rateLimitHitDuringSearch = true;
+      }
       strategiesUsed.push("broad");
     }
     if (allCandidates.length < maxResults && searchBudget >= LOW_BUDGET_THRESHOLD && enabledStrategies.has("maintained")) {
-      await sleep(INTER_PHASE_DELAY_MS);
+      if (interPhaseDelay > 0) {
+        info(MODULE9, `Waiting ${(interPhaseDelay / 1e3).toFixed(0)}s between phases for rate limit management...`);
+        await sleep(interPhaseDelay);
+      }
       const remaining = maxResults - allCandidates.length;
-      const result = await runPhase3(this.octokit, this.vetter, langQuery, minStars, config2.projectCategories ?? [], remaining, phase0RepoSet, starredRepoSet, allCandidates, filterIssues);
+      const result = await runPhase3(this.octokit, this.vetter, langQuery, minStars, config2.projectCategories ?? [], remaining, phase0RepoSet, starredRepoSet, starredRepos, allCandidates, filterIssues);
       allCandidates.push(...result.candidates);
       phaseErrors["3"] = result.error;
       if (result.rateLimitHit)
@@ -38313,7 +38432,10 @@ function registerTools(server, scout) {
   const NUMBER_KEYS = /* @__PURE__ */ new Set([
     "minStars",
     "maxIssueAgeDays",
-    "minRepoScoreThreshold"
+    "minRepoScoreThreshold",
+    "interPhaseDelayMs",
+    "broadPhaseDelayMs",
+    "skipBroadWhenSufficientResults"
   ]);
   const BOOLEAN_KEYS = /* @__PURE__ */ new Set(["includeDocIssues"]);
   server.tool(

package/dist/tools.js

@@ -181,6 +181,9 @@ export function registerTools(server, scout) {
         "minStars",
         "maxIssueAgeDays",
         "minRepoScoreThreshold",
+        "interPhaseDelayMs",
+        "broadPhaseDelayMs",
+        "skipBroadWhenSufficientResults",
     ]);
     const BOOLEAN_KEYS = new Set(["includeDocIssues"]);
     server.tool("config-set", "Update an oss-scout configuration preference", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oss-scout/mcp",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "MCP server for oss-scout — exposes issue discovery and vetting as MCP tools",
   "type": "module",
   "bin": {
@@ -18,7 +18,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1",
     "zod": "^4.3.6",
-    "@oss-scout/core": "^0.3.0"
+    "@oss-scout/core": "^0.4.0"
   },
   "devDependencies": {
     "@types/node": "^25.5.0",