@oss-autopilot/core 1.3.0 → 1.5.0

package/dist/commands/search.js

@@ -35,6 +35,7 @@ export async function runSearch(options) {
             return {
                 issue: {
                     repo: c.issue.repo,
+                    repoUrl: `https://github.com/${c.issue.repo}`,
                     number: c.issue.number,
                     title: c.issue.title,
                     url: c.issue.url,

package/dist/core/github-stats.d.ts

@@ -34,6 +34,8 @@ export declare function fetchUserClosedPRCounts(octokit: Octokit, githubUsername
  */
 export declare function fetchRecentlyClosedPRs(octokit: Octokit, config: {
     githubUsername: string;
+    excludeRepos?: string[];
+    excludeOrgs?: string[];
 }, days?: number): Promise<ClosedPR[]>;
 /**
  * Fetch PRs merged in the last N days.
@@ -41,6 +43,8 @@ export declare function fetchRecentlyClosedPRs(octokit: Octokit, config: {
  */
 export declare function fetchRecentlyMergedPRs(octokit: Octokit, config: {
     githubUsername: string;
+    excludeRepos?: string[];
+    excludeOrgs?: string[];
 }, days?: number): Promise<MergedPR[]>;
 /**
  * Fetch merged PRs since a watermark date for incremental storage.

package/dist/core/github-stats.js

@@ -198,6 +198,15 @@ async function fetchRecentPRs(octokit, config, query, label, days, mapItem) {
         // Skip own repos
         if (isOwnRepo(parsed.owner, config.githubUsername))
             continue;
+        // Exclude configured repos and orgs (#792)
+        if (config.excludeRepos?.includes(repo)) {
+            debug(MODULE, `Skipping excluded repo: ${repo}`);
+            continue;
+        }
+        if (config.excludeOrgs?.some((org) => org.toLowerCase() === parsed.owner.toLowerCase())) {
+            debug(MODULE, `Skipping excluded org: ${parsed.owner}`);
+            continue;
+        }
         results.push(mapItem(item, { owner: parsed.owner, repo, number: parsed.number }));
     }
     debug(MODULE, `Found ${results.length} recently ${label} PRs`);

package/dist/core/github.d.ts

@@ -24,7 +24,7 @@ export declare function getRateLimitCallbacks(): {
  * Returns a cached instance if the token matches, otherwise creates a new one.
  *
  * The client retries on primary rate limits (up to 2 retries) and
- * secondary rate limits (1 retry).
+ * secondary rate limits (up to 3 retries).
  *
  * @param token - GitHub personal access token
  * @returns Authenticated Octokit instance with rate limit throttling

package/dist/core/github.js

@@ -31,8 +31,8 @@ export function getRateLimitCallbacks() {
         onSecondaryRateLimit: (retryAfter, options, _octokit, retryCount) => {
             const opts = options;
             const resetAt = new Date(Date.now() + retryAfter * 1000);
-            if (retryCount < 1) {
-                warn(MODULE, `Secondary rate limit hit (retry ${retryCount + 1}/1, waiting ${retryAfter}s, resets at ${formatResetTime(resetAt)}) — ${opts.method} ${opts.url}`);
+            if (retryCount < 3) {
+                warn(MODULE, `Secondary rate limit hit (retry ${retryCount + 1}/3, waiting ${retryAfter}s, resets at ${formatResetTime(resetAt)}) — ${opts.method} ${opts.url}`);
                 return true;
             }
             warn(MODULE, `Secondary rate limit exceeded, not retrying — ${opts.method} ${opts.url} (resets at ${formatResetTime(resetAt)})`);
@@ -45,7 +45,7 @@ export function getRateLimitCallbacks() {
  * Returns a cached instance if the token matches, otherwise creates a new one.
  *
  * The client retries on primary rate limits (up to 2 retries) and
- * secondary rate limits (1 retry).
+ * secondary rate limits (up to 3 retries).
  *
  * @param token - GitHub personal access token
  * @returns Authenticated Octokit instance with rate limit throttling

package/dist/core/issue-discovery.d.ts

@@ -14,11 +14,11 @@ import { type IssueCandidate } from './types.js';
  * Multi-phase issue discovery engine that searches GitHub for contributable issues.
  *
  * Search phases (in priority order):
- * 1. Repos where user has merged PRs (highest merge probability)
- * 2. Preferred organizations
- * 3. Starred repos
- * 4. General label-filtered search
- * 5. Actively maintained repos
+ * 0. Repos where user has merged PRs (highest merge probability)
+ * 0.5. Preferred organizations
+ * 1. Starred repos
+ * 2. General label-filtered search
+ * 3. Actively maintained repos
  *
  * Each candidate is vetted for claimability and scored 0-100 for viability.
  */
@@ -44,8 +44,8 @@ export declare class IssueDiscovery {
     getStarredReposWithRefresh(): Promise<string[]>;
     /**
      * Search for issues matching our criteria.
-     * Searches in priority order: merged-PR repos first (no label filter), then starred repos,
-     * then general search, then actively maintained repos.
+     * Searches in priority order: merged-PR repos first (no label filter), then preferred
+     * organizations, then starred repos, then general search, then actively maintained repos.
      * Filters out issues from low-scoring and excluded repos.
      *
      * @param options - Search configuration

package/dist/core/issue-discovery.js

@@ -13,7 +13,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { getOctokit, checkRateLimit } from './github.js';
 import { getStateManager } from './state.js';
-import { daysBetween, getDataDir } from './utils.js';
+import { daysBetween, getDataDir, sleep } from './utils.js';
 import { DEFAULT_CONFIG, SCOPE_LABELS } from './types.js';
 import { ValidationError, errorMessage, getHttpStatusCode, isRateLimitError } from './errors.js';
 import { debug, info, warn } from './logger.js';
@@ -22,15 +22,21 @@ import { IssueVetter } from './issue-vetting.js';
 import { getTopicsForCategories } from './category-mapping.js';
 import { buildEffectiveLabels, interleaveArrays, cachedSearchIssues, filterVetAndScore, searchInRepos, searchWithChunkedLabels, } from './search-phases.js';
 const MODULE = 'issue-discovery';
+/** Delay between major search phases to let GitHub's rate limit window cool down. */
+const INTER_PHASE_DELAY_MS = 2000;
+/** If remaining search quota is below this, skip heavy phases (2, 3). */
+const LOW_BUDGET_THRESHOLD = 20;
+/** If remaining search quota is below this, only run Phase 0. */
+const CRITICAL_BUDGET_THRESHOLD = 10;
 /**
  * Multi-phase issue discovery engine that searches GitHub for contributable issues.
  *
  * Search phases (in priority order):
- * 1. Repos where user has merged PRs (highest merge probability)
- * 2. Preferred organizations
- * 3. Starred repos
- * 4. General label-filtered search
- * 5. Actively maintained repos
+ * 0. Repos where user has merged PRs (highest merge probability)
+ * 0.5. Preferred organizations
+ * 1. Starred repos
+ * 2. General label-filtered search
+ * 3. Actively maintained repos
  *
  * Each candidate is vetted for claimability and scored 0-100 for viability.
  */
@@ -118,8 +124,8 @@ export class IssueDiscovery {
     }
     /**
      * Search for issues matching our criteria.
-     * Searches in priority order: merged-PR repos first (no label filter), then starred repos,
-     * then general search, then actively maintained repos.
+     * Searches in priority order: merged-PR repos first (no label filter), then preferred
+     * organizations, then starred repos, then general search, then actively maintained repos.
      * Filters out issues from low-scoring and excluded repos.
      *
      * @param options - Search configuration
@@ -151,23 +157,31 @@ export class IssueDiscovery {
         let phase0Error = null;
         let phase1Error = null;
         let rateLimitHitDuringSearch = false;
-        // Pre-flight rate limit check (#100)
+        // Pre-flight rate limit check (#100) — also determines adaptive phase budget
         this.rateLimitWarning = null;
+        let searchBudget = LOW_BUDGET_THRESHOLD - 1; // conservative: below threshold to skip heavy phases
         try {
             const rateLimit = await checkRateLimit(this.githubToken);
+            searchBudget = rateLimit.remaining;
             if (rateLimit.remaining < 5) {
                 const resetTime = new Date(rateLimit.resetAt).toLocaleTimeString('en-US', { hour12: false });
                 this.rateLimitWarning = `GitHub search API quota low (${rateLimit.remaining}/${rateLimit.limit} remaining, resets at ${resetTime}). Search may be slow.`;
                 warn(MODULE, this.rateLimitWarning);
             }
+            if (searchBudget < CRITICAL_BUDGET_THRESHOLD) {
+                info(MODULE, `Search budget critical (${searchBudget} remaining) — running only Phase 0`);
+            }
+            else if (searchBudget < LOW_BUDGET_THRESHOLD) {
+                info(MODULE, `Search budget low (${searchBudget} remaining) — skipping heavy phases (2, 3)`);
+            }
         }
         catch (error) {
             // Fail fast on auth errors — no point searching with a bad token
             if (getHttpStatusCode(error) === 401) {
                 throw error;
             }
-            // Non-fatal: proceed with search for transient/network errors
-            warn(MODULE, 'Could not check rate limit:', errorMessage(error));
+            // Non-fatal: proceed with conservative budget for transient/network errors
+            warn(MODULE, 'Could not check rate limit — using conservative budget, skipping heavy phases:', errorMessage(error));
         }
         // Get merged-PR repos (highest merge probability)
         const mergedPRRepos = this.stateManager.getReposWithMergedPRs();
@@ -263,9 +277,13 @@ export class IssueDiscovery {
             }
         }
         // Phase 0.5: Search preferred organizations (explicit user preference)
+        // Skip if budget is critical — Phase 0 results are sufficient
         let phase0_5Error = null;
         const preferredOrgs = config.preferredOrgs ?? [];
-        if (allCandidates.length < maxResults && preferredOrgs.length > 0) {
+        if (allCandidates.length < maxResults && preferredOrgs.length > 0 && searchBudget >= CRITICAL_BUDGET_THRESHOLD) {
+            // Inter-phase delay to let GitHub's rate limit window cool down
+            if (phase0Repos.length > 0)
+                await sleep(INTER_PHASE_DELAY_MS);
             // Filter out orgs already covered by Phase 0 repos
             const phase0Orgs = new Set(phase0Repos.map((r) => r.split('/')[0]?.toLowerCase()));
             const orgsToSearch = preferredOrgs.filter((org) => !phase0Orgs.has(org.toLowerCase())).slice(0, 5);
@@ -303,7 +321,9 @@ export class IssueDiscovery {
             }
         }
         // Phase 1: Search starred repos (filter out already-searched Phase 0 repos)
-        if (allCandidates.length < maxResults && starredRepos.length > 0) {
+        // Skip if budget is critical
+        if (allCandidates.length < maxResults && starredRepos.length > 0 && searchBudget >= CRITICAL_BUDGET_THRESHOLD) {
+            await sleep(INTER_PHASE_DELAY_MS);
             const reposToSearch = starredRepos.filter((r) => !phase0RepoSet.has(r));
             if (reposToSearch.length > 0) {
                 info(MODULE, `Phase 1: Searching issues in ${reposToSearch.length} starred repos...`);
@@ -322,11 +342,13 @@ export class IssueDiscovery {
             }
         }
         // Phase 2: General search (if still need more)
+        // Skip if budget is low — Phases 0, 0.5, 1 are cheaper and higher-value
         // When multiple scope tiers are active, fire one query per tier and interleave
         // results to prevent high-volume tiers (e.g., "enhancement") from drowning out
         // beginner results.
         let phase2Error = null;
-        if (allCandidates.length < maxResults) {
+        if (allCandidates.length < maxResults && searchBudget >= LOW_BUDGET_THRESHOLD) {
+            await sleep(INTER_PHASE_DELAY_MS);
             info(MODULE, 'Phase 2: General issue search...');
             const remainingNeeded = maxResults - allCandidates.length;
             const seenRepos = new Set(allCandidates.map((c) => c.issue.repo));
@@ -390,8 +412,10 @@ export class IssueDiscovery {
             allCandidates.push(...interleaved.slice(0, remainingNeeded));
         }
         // Phase 3: Actively maintained repos (#349)
+        // Skip if budget is low — this phase is API-heavy with broad queries
         let phase3Error = null;
-        if (allCandidates.length < maxResults) {
+        if (allCandidates.length < maxResults && searchBudget >= LOW_BUDGET_THRESHOLD) {
+            await sleep(INTER_PHASE_DELAY_MS);
             info(MODULE, 'Phase 3: Searching actively maintained repos...');
             const remainingNeeded = maxResults - allCandidates.length;
             const thirtyDaysAgo = new Date();
@@ -430,6 +454,15 @@ export class IssueDiscovery {
                 warn(MODULE, `Error in maintained-repo search: ${errMsg}`);
             }
         }
+        // Determine if phases were skipped due to budget constraints
+        const phasesSkippedForBudget = searchBudget < LOW_BUDGET_THRESHOLD;
+        let budgetNote = '';
+        if (searchBudget < CRITICAL_BUDGET_THRESHOLD) {
+            budgetNote = ` Most search phases were skipped due to critically low API quota (${searchBudget} remaining).`;
+        }
+        else if (phasesSkippedForBudget) {
+            budgetNote = ` Some search phases were skipped due to low API quota (${searchBudget} remaining).`;
+        }
         if (allCandidates.length === 0) {
             const phaseErrors = [
                 phase0Error ? `Phase 0 (merged-PR repos): ${phase0Error}` : null,
@@ -439,9 +472,9 @@ export class IssueDiscovery {
                 phase3Error ? `Phase 3 (maintained repos): ${phase3Error}` : null,
             ].filter(Boolean);
             const details = phaseErrors.length > 0 ? ` ${phaseErrors.join('. ')}.` : '';
-            if (rateLimitHitDuringSearch) {
+            if (rateLimitHitDuringSearch || phasesSkippedForBudget) {
                 this.rateLimitWarning =
-                    `Search returned no results due to GitHub API rate limits.${details} ` +
+                    `Search returned no results due to GitHub API rate limits.${details}${budgetNote} ` +
                         `Try again after the rate limit resets.`;
                 return [];
             }
@@ -449,10 +482,10 @@ export class IssueDiscovery {
                 'Try adjusting your search criteria (languages, labels) or check your network connection.');
         }
         // Surface rate limit warning even with partial results (#100)
-        if (rateLimitHitDuringSearch) {
+        if (rateLimitHitDuringSearch || phasesSkippedForBudget) {
             this.rateLimitWarning =
-                `Search results may be incomplete: GitHub API rate limits were hit during search. ` +
-                    `Found ${allCandidates.length} candidate${allCandidates.length === 1 ? '' : 's'} but some search phases failed. ` +
+                `Search results may be incomplete: GitHub API rate limits were hit during search.${budgetNote} ` +
+                    `Found ${allCandidates.length} candidate${allCandidates.length === 1 ? '' : 's'} but some search phases were limited. ` +
                     `Try again after the rate limit resets for complete results.`;
         }
         // Sort by priority first, then by recommendation, then by viability score

package/dist/core/issue-vetting.d.ts

@@ -15,6 +15,7 @@ export declare class IssueVetter {
     constructor(octokit: Octokit, stateManager: ReturnType<typeof getStateManager>);
     /**
      * Vet a specific issue — runs all checks and computes recommendation + viability score.
+     * Results are cached for 15 minutes to avoid redundant API calls on repeated searches.
      */
     vetIssue(issueUrl: string): Promise<IssueCandidate>;
     /**

package/dist/core/issue-vetting.js

@@ -6,15 +6,19 @@
  * - issue-eligibility.ts — PR existence, claim detection, requirements analysis
  * - repo-health.ts       — project health, contribution guidelines
  */
-import { parseGitHubUrl, DEFAULT_CONCURRENCY } from './utils.js';
+import { parseGitHubUrl } from './utils.js';
 import { ValidationError, errorMessage, isRateLimitError } from './errors.js';
-import { warn } from './logger.js';
+import { debug, warn } from './logger.js';
 import { calculateRepoQualityBonus, calculateViabilityScore } from './issue-scoring.js';
 import { repoBelongsToCategory } from './category-mapping.js';
 import { checkNoExistingPR, checkNotClaimed, checkUserMergedPRsInRepo, analyzeRequirements, } from './issue-eligibility.js';
 import { checkProjectHealth, fetchContributionGuidelines } from './repo-health.js';
+import { getHttpCache } from './http-cache.js';
 const MODULE = 'issue-vetting';
-const MAX_CONCURRENT_REQUESTS = DEFAULT_CONCURRENCY;
+/** Vetting concurrency: kept low to reduce burst pressure on GitHub's secondary rate limit. */
+const MAX_CONCURRENT_VETTING = 3;
+/** TTL for cached vetting results (15 minutes). Kept short so config changes take effect quickly. */
+const VETTING_CACHE_TTL_MS = 15 * 60 * 1000;
 export class IssueVetter {
     octokit;
     stateManager;
@@ -24,8 +28,17 @@ export class IssueVetter {
     }
     /**
      * Vet a specific issue — runs all checks and computes recommendation + viability score.
+     * Results are cached for 15 minutes to avoid redundant API calls on repeated searches.
      */
     async vetIssue(issueUrl) {
+        // Check vetting cache first — avoids ~6+ API calls per issue
+        const cache = getHttpCache();
+        const cacheKey = `vet:${issueUrl}`;
+        const cached = cache.getIfFresh(cacheKey, VETTING_CACHE_TTL_MS);
+        if (cached && typeof cached === 'object' && 'issue' in cached && 'viabilityScore' in cached) {
+            debug(MODULE, `Vetting cache hit for ${issueUrl}`);
+            return cached;
+        }
         // Parse URL
         const parsed = parseGitHubUrl(issueUrl);
         if (!parsed || parsed.type !== 'issues') {
@@ -207,7 +220,7 @@ export class IssueVetter {
         else if (starredRepos.includes(repoFullName)) {
             searchPriority = 'starred';
         }
-        return {
+        const result = {
             issue: trackedIssue,
             vettingResult,
             projectHealth,
@@ -217,6 +230,9 @@ export class IssueVetter {
             viabilityScore,
             searchPriority,
         };
+        // Cache the vetting result to avoid redundant API calls on repeated searches
+        cache.set(cacheKey, '', result);
+        return result;
     }
     /**
      * Vet multiple issues in parallel with concurrency limit
@@ -251,7 +267,7 @@ export class IssueVetter {
                 .finally(() => pending.delete(url));
             pending.set(url, task);
             // Limit concurrency — wait for at least one to complete before launching more
-            if (pending.size >= MAX_CONCURRENT_REQUESTS) {
+            if (pending.size >= MAX_CONCURRENT_VETTING) {
                 await Promise.race(pending.values());
             }
         }

package/dist/core/pr-monitor.js

@@ -124,6 +124,15 @@ export class PRMonitor {
             }
             if (isOwnRepo(parsed.owner, config.githubUsername))
                 return false;
+            // Exclude configured repos and orgs (#792)
+            if (config.excludeRepos.includes(`${parsed.owner}/${parsed.repo}`)) {
+                debug('pr-monitor', `Skipping excluded repo: ${parsed.owner}/${parsed.repo}`);
+                return false;
+            }
+            if (config.excludeOrgs?.some((org) => org.toLowerCase() === parsed.owner.toLowerCase())) {
+                debug('pr-monitor', `Skipping excluded org: ${parsed.owner}`);
+                return false;
+            }
             return true;
         });
         debug('pr-monitor', `Filtered to ${filteredItems.length} PRs after excluding own repos`);

package/dist/core/search-phases.js

@@ -9,16 +9,14 @@ import { errorMessage, isRateLimitError } from './errors.js';
 import { debug, warn } from './logger.js';
 import { getHttpCache, cachedTimeBased } from './http-cache.js';
 import { detectLabelFarmingRepos } from './issue-filtering.js';
+import { sleep } from './utils.js';
 const MODULE = 'search-phases';
 /** GitHub Search API enforces a max of 5 AND/OR/NOT operators per query. */
 export const GITHUB_MAX_BOOLEAN_OPS = 5;
-/** Small delay between search API calls to avoid secondary rate limits. */
-const INTER_QUERY_DELAY_MS = 500;
+/** Delay between search API calls to avoid GitHub's secondary rate limit (~30 req/min). */
+const INTER_QUERY_DELAY_MS = 1500;
 /** Batch size for repo queries. 3 repos = 2 OR operators, leaving room for labels. */
 const BATCH_SIZE = 3;
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
 /**
  * Chunk labels into groups that fit within the operator budget.
  * N labels require N-1 OR operators, so maxPerChunk = budget + 1.
@@ -189,9 +187,13 @@ export async function searchInRepos(octokit, vetter, repos, baseQualifiers, labe
     const batches = batchRepos(repos, BATCH_SIZE);
     let failedBatches = 0;
     let rateLimitFailures = 0;
-    for (const batch of batches) {
+    for (let batchIdx = 0; batchIdx < batches.length; batchIdx++) {
+        const batch = batches[batchIdx];
         if (candidates.length >= maxResults)
             break;
+        // Delay between batches to avoid secondary rate limits
+        if (batchIdx > 0)
+            await sleep(INTER_QUERY_DELAY_MS);
         try {
             const repoFilter = batch.map((r) => `repo:${r}`).join(' OR ');
             const repoOps = batch.length - 1;
@@ -200,8 +202,10 @@ export async function searchInRepos(octokit, vetter, repos, baseQualifiers, labe
             if (allItems.length > 0) {
                 const filtered = filterFn(allItems);
                 const remainingNeeded = maxResults - candidates.length;
-                const { candidates: vetted } = await vetter.vetIssuesParallel(filtered.slice(0, remainingNeeded * 2).map((i) => i.html_url), remainingNeeded, priority);
+                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 (error) {

package/dist/core/utils.d.ts

@@ -3,6 +3,8 @@
  */
 /** Default concurrency limit for parallel GitHub API requests. */
 export declare const DEFAULT_CONCURRENCY = 5;
+/** Async sleep — exported for mockability in tests. */
+export declare function sleep(ms: number): Promise<void>;
 /**
  * Returns the oss-autopilot data directory path, creating it if it does not exist.
  *

package/dist/core/utils.js

@@ -1,14 +1,18 @@
 /**
  * Shared utility functions
  */
-/** Default concurrency limit for parallel GitHub API requests. */
-export const DEFAULT_CONCURRENCY = 5;
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
 import { execFileSync, execFile } from 'child_process';
 import { ConfigurationError } from './errors.js';
 import { debug } from './logger.js';
+/** Default concurrency limit for parallel GitHub API requests. */
+export const DEFAULT_CONCURRENCY = 5;
+/** Async sleep — exported for mockability in tests. */
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 const MODULE = 'utils';
 // Cached GitHub token (fetched once per session)
 let cachedGitHubToken = null;

package/dist/formatters/json.d.ts

@@ -171,6 +171,7 @@ export interface SearchOutput {
     candidates: Array<{
         issue: {
             repo: string;
+            repoUrl: string;
             number: number;
             title: string;
             url: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oss-autopilot/core",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "CLI and core library for managing open source contributions",
   "type": "module",
   "bin": {
@@ -54,13 +54,13 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@types/node": "^25.4.0",
-    "@vitest/coverage-v8": "^4.0.18",
-    "esbuild": "^0.27.3",
+    "@types/node": "^25.5.0",
+    "@vitest/coverage-v8": "^4.1.0",
+    "esbuild": "^0.27.4",
     "tsx": "^4.21.0",
     "typedoc": "^0.28.17",
     "typescript": "^5.9.3",
-    "vitest": "^4.0.16"
+    "vitest": "^4.1.0"
   },
   "scripts": {
     "build": "tsc",