@oss-autopilot/core 1.6.3 → 1.7.1

package/dist/core/search-budget.js

@@ -0,0 +1,129 @@
+/**
+ * Search Budget Tracker — centralized rate limit management for GitHub Search API.
+ *
+ * The GitHub Search API enforces a strict 30 requests/minute limit for
+ * authenticated users. This module tracks actual consumption via a sliding
+ * window and provides adaptive delays to stay within budget.
+ *
+ * Usage:
+ * - Initialize once per search run with pre-flight rate limit data
+ * - Call recordCall() after every Search API call
+ * - Call waitForBudget() before making a Search API call to pace requests
+ * - Call canAfford(n) to check if n more calls fit in the remaining budget
+ */
+import { debug } from './logger.js';
+import { sleep } from './utils.js';
+const MODULE = 'search-budget';
+/** GitHub Search API rate limit: 30 requests per 60-second rolling window. */
+const SEARCH_RATE_LIMIT = 30;
+const SEARCH_WINDOW_MS = 60 * 1000;
+/** Safety margin: reserve a few calls for retries and cross-process usage. */
+const SAFETY_MARGIN = 4;
+/** Effective budget per window after safety margin. */
+const EFFECTIVE_BUDGET = SEARCH_RATE_LIMIT - SAFETY_MARGIN;
+export class SearchBudgetTracker {
+    /** Timestamps of recent Search API calls within the sliding window. */
+    callTimestamps = [];
+    /** Last known remaining quota from GitHub's rate limit endpoint. */
+    knownRemaining = SEARCH_RATE_LIMIT;
+    /** Epoch ms when the rate limit window resets (from GitHub API). */
+    resetAt = 0;
+    /** Total calls recorded since init (for diagnostics). */
+    totalCalls = 0;
+    /**
+     * Initialize with pre-flight rate limit data from GitHub.
+     */
+    init(remaining, resetAt) {
+        this.knownRemaining = remaining;
+        this.resetAt = new Date(resetAt).getTime();
+        this.callTimestamps = [];
+        this.totalCalls = 0;
+        debug(MODULE, `Initialized: ${remaining} remaining, resets at ${new Date(this.resetAt).toLocaleTimeString()}`);
+    }
+    /**
+     * Record that a Search API call was just made.
+     */
+    recordCall() {
+        this.callTimestamps.push(Date.now());
+        this.totalCalls++;
+        this.pruneOldTimestamps();
+    }
+    /**
+     * Remove timestamps older than the sliding window.
+     */
+    pruneOldTimestamps() {
+        const cutoff = Date.now() - SEARCH_WINDOW_MS;
+        while (this.callTimestamps.length > 0 && this.callTimestamps[0] < cutoff) {
+            this.callTimestamps.shift();
+        }
+    }
+    /**
+     * Get the number of calls made in the current sliding window.
+     */
+    getCallsInWindow() {
+        this.pruneOldTimestamps();
+        return this.callTimestamps.length;
+    }
+    /**
+     * Get the effective budget, accounting for both the sliding window limit
+     * and the pre-flight remaining quota from GitHub.
+     */
+    getEffectiveBudget() {
+        // Use the stricter of: local window limit vs. pre-flight remaining minus calls made
+        const localBudget = EFFECTIVE_BUDGET - this.callTimestamps.length;
+        const externalBudget = this.knownRemaining - this.totalCalls;
+        return Math.max(0, Math.min(localBudget, externalBudget));
+    }
+    /**
+     * Check if we can afford N more Search API calls without exceeding the budget.
+     */
+    canAfford(n) {
+        this.pruneOldTimestamps();
+        return this.getEffectiveBudget() >= n;
+    }
+    /**
+     * Wait if necessary to stay within the Search API rate limit.
+     * If the sliding window is at capacity, sleeps until the oldest
+     * call ages out of the window.
+     */
+    async waitForBudget() {
+        // Loop to handle edge cases where a single sleep isn't enough
+        // (e.g., concurrent callers, clock skew, or external budget depletion)
+        while (true) {
+            this.pruneOldTimestamps();
+            if (this.getEffectiveBudget() > 0) {
+                return; // Budget available, no wait needed
+            }
+            // Wait until the oldest call in the window ages out
+            const oldestInWindow = this.callTimestamps[0];
+            if (!oldestInWindow) {
+                return; // No calls in window — budget exhausted by external consumption, can't wait it out
+            }
+            const waitUntil = oldestInWindow + SEARCH_WINDOW_MS;
+            const waitMs = waitUntil - Date.now();
+            if (waitMs > 0) {
+                debug(MODULE, `Budget full (${this.callTimestamps.length}/${EFFECTIVE_BUDGET} in window), waiting ${waitMs}ms`);
+                await sleep(waitMs + 100); // +100ms safety buffer
+            }
+        }
+    }
+    /**
+     * Get total calls recorded since init (for diagnostics).
+     */
+    getTotalCalls() {
+        return this.totalCalls;
+    }
+}
+// ---------------------------------------------------------------------------
+// Singleton
+// ---------------------------------------------------------------------------
+let _tracker = null;
+/**
+ * Get (or create) the shared SearchBudgetTracker singleton.
+ */
+export function getSearchBudgetTracker() {
+    if (!_tracker) {
+        _tracker = new SearchBudgetTracker();
+    }
+    return _tracker;
+}

package/dist/core/search-phases.js

@@ -10,11 +10,14 @@ import { debug, warn } from './logger.js';
 import { getHttpCache, cachedTimeBased } from './http-cache.js';
 import { detectLabelFarmingRepos } from './issue-filtering.js';
 import { sleep } from './utils.js';
+import { getSearchBudgetTracker } from './search-budget.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;
-/** Delay between search API calls to avoid GitHub's secondary rate limit (~30 req/min). */
-const INTER_QUERY_DELAY_MS = 1500;
+/** Delay between search API calls to avoid GitHub's secondary rate limit (~30 req/min).
+ * Set to 2000ms as a safety floor (max 30/min at the limit). The SearchBudgetTracker
+ * adds additional adaptive delays when needed. */
+const INTER_QUERY_DELAY_MS = 2000;
 /** Batch size for repo queries. 3 repos = 2 OR operators, leaving room for labels. */
 const BATCH_SIZE = 3;
 /**
@@ -93,8 +96,16 @@ const SEARCH_CACHE_TTL_MS = 15 * 60 * 1000;
 export 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 { data } = await octokit.search.issuesAndPullRequests(params);
-        return data;
+        const tracker = getSearchBudgetTracker();
+        await tracker.waitForBudget();
+        try {
+            const { data } = await octokit.search.issuesAndPullRequests(params);
+            return data;
+        }
+        finally {
+            // Always record the call — failed requests still consume GitHub rate limit points
+            tracker.recordCall();
+        }
     });
 }
 // ── Search infrastructure ──

package/dist/core/types.d.ts

@@ -159,6 +159,8 @@ export interface ProjectHealth {
     stargazersCount?: number;
     /** GitHub fork count, used for repo quality scoring (#98). */
     forksCount?: number;
+    /** Primary programming language as reported by GitHub. */
+    language?: string | null;
     /** True if the health check itself failed (e.g., API error). */
     checkFailed?: boolean;
     failureReason?: string;

package/dist/formatters/json.d.ts

@@ -255,6 +255,7 @@ export interface ParsedIssueItem {
     title: string;
     tier: string;
     url: string;
+    score?: number;
 }
 /** Output of the parse-issue-list command (#82) */
 export interface ParseIssueListOutput {
@@ -291,6 +292,9 @@ export interface VetListOutput {
         hasPR: number;
         errors: number;
     };
+    pruneResult?: {
+        removedCount: number;
+    };
 }
 /** Output of the vet command */
 export interface VetOutput {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oss-autopilot/core",
-  "version": "1.6.3",
+  "version": "1.7.1",
   "description": "CLI and core library for managing open source contributions",
   "type": "module",
   "bin": {