@oss-autopilot/core 1.11.0 → 1.12.1

package/dist/core/issue-vetting.js

@@ -1,306 +0,0 @@
-/**
- * Issue Vetting — orchestrates individual issue checks and computes
- * recommendation + viability score.
- *
- * Delegates to focused modules (#621):
- * - issue-eligibility.ts — PR existence, claim detection, requirements analysis
- * - repo-health.ts       — project health, contribution guidelines
- */
-import { parseGitHubUrl } from './utils.js';
-import { ValidationError, errorMessage, isRateLimitError } from './errors.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';
-/** 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;
-    constructor(octokit, stateManager) {
-        this.octokit = octokit;
-        this.stateManager = stateManager;
-    }
-    /**
-     * 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') {
-            throw new ValidationError(`Invalid issue URL: ${issueUrl}`);
-        }
-        const { owner, repo, number } = parsed;
-        const repoFullName = `${owner}/${repo}`;
-        // Fetch issue data
-        const { data: ghIssue } = await this.octokit.issues.get({
-            owner,
-            repo,
-            issue_number: number,
-        });
-        // Check local state first to skip the merged-PR Search API call when
-        // the repo already has authoritative data (saves 1 Search call per issue).
-        const repoScoreRecord = this.stateManager.getRepoScore(repoFullName);
-        const skipMergedPRCheck = repoScoreRecord != null && repoScoreRecord.mergedPRCount > 0;
-        // Run all vetting checks in parallel — delegates to standalone functions
-        const [existingPRCheck, claimCheck, projectHealth, contributionGuidelines, userMergedPRCount] = await Promise.all([
-            checkNoExistingPR(this.octokit, owner, repo, number),
-            checkNotClaimed(this.octokit, owner, repo, number, ghIssue.comments),
-            checkProjectHealth(this.octokit, owner, repo),
-            fetchContributionGuidelines(this.octokit, owner, repo),
-            skipMergedPRCheck ? Promise.resolve(0) : checkUserMergedPRsInRepo(this.octokit, owner, repo),
-        ]);
-        const noExistingPR = existingPRCheck.passed;
-        const notClaimed = claimCheck.passed;
-        // Analyze issue quality
-        const clearRequirements = analyzeRequirements(ghIssue.body || '');
-        // When the health check itself failed (API error), use a neutral default:
-        // don't penalize the repo as inactive, but don't credit it as active either.
-        const projectActive = projectHealth.checkFailed ? true : projectHealth.isActive;
-        const vettingResult = {
-            passedAllChecks: noExistingPR && notClaimed && projectActive && clearRequirements,
-            checks: {
-                noExistingPR,
-                notClaimed,
-                projectActive,
-                clearRequirements,
-                contributionGuidelinesFound: !!contributionGuidelines,
-            },
-            contributionGuidelines,
-            notes: [],
-        };
-        // Build notes
-        if (!noExistingPR)
-            vettingResult.notes.push('Existing PR found for this issue');
-        if (!notClaimed)
-            vettingResult.notes.push('Issue appears to be claimed by someone');
-        if (existingPRCheck.inconclusive) {
-            vettingResult.notes.push(`Could not verify absence of existing PRs: ${existingPRCheck.reason || 'API error'}`);
-        }
-        if (claimCheck.inconclusive) {
-            vettingResult.notes.push(`Could not verify claim status: ${claimCheck.reason || 'API error'}`);
-        }
-        if (projectHealth.checkFailed) {
-            vettingResult.notes.push(`Could not verify project activity: ${projectHealth.failureReason || 'API error'}`);
-        }
-        else if (!projectHealth.isActive) {
-            vettingResult.notes.push('Project may be inactive');
-        }
-        if (!clearRequirements)
-            vettingResult.notes.push('Issue requirements are unclear');
-        if (!contributionGuidelines)
-            vettingResult.notes.push('No CONTRIBUTING.md found');
-        // Create tracked issue
-        const trackedIssue = {
-            id: ghIssue.id,
-            url: issueUrl,
-            repo: repoFullName,
-            number,
-            title: ghIssue.title,
-            status: 'candidate',
-            labels: ghIssue.labels.map((l) => (typeof l === 'string' ? l : l.name || '')),
-            createdAt: ghIssue.created_at,
-            updatedAt: ghIssue.updated_at,
-            vetted: true,
-            vettingResult,
-        };
-        // Determine recommendation
-        const reasonsToSkip = [];
-        const reasonsToApprove = [];
-        if (!noExistingPR)
-            reasonsToSkip.push('Has existing PR');
-        if (!notClaimed)
-            reasonsToSkip.push('Already claimed');
-        if (!projectHealth.isActive && !projectHealth.checkFailed)
-            reasonsToSkip.push('Inactive project');
-        if (!clearRequirements)
-            reasonsToSkip.push('Unclear requirements');
-        if (noExistingPR)
-            reasonsToApprove.push('No existing PR');
-        if (notClaimed)
-            reasonsToApprove.push('Not claimed');
-        if (projectHealth.isActive && !projectHealth.checkFailed)
-            reasonsToApprove.push('Active project');
-        if (clearRequirements)
-            reasonsToApprove.push('Clear requirements');
-        if (contributionGuidelines)
-            reasonsToApprove.push('Has contribution guidelines');
-        // Determine effective merged PR count: prefer local state (authoritative if present),
-        // fall back to live GitHub API count to detect contributions made before using oss-autopilot (#373)
-        const config = this.stateManager.getState().config;
-        const effectiveMergedCount = repoScoreRecord && repoScoreRecord.mergedPRCount > 0 ? repoScoreRecord.mergedPRCount : userMergedPRCount;
-        if (effectiveMergedCount > 0) {
-            reasonsToApprove.push(`Trusted project (${effectiveMergedCount} PR${effectiveMergedCount > 1 ? 's' : ''} merged)`);
-        }
-        else if (config.trustedProjects.includes(repoFullName)) {
-            reasonsToApprove.push('Trusted project (previous PR merged)');
-        }
-        // Check for closed/rejected PR history in this repo
-        // Use effectiveMergedCount to avoid contradictory signals when API data
-        // shows merges that local state doesn't know about (#373)
-        if (repoScoreRecord) {
-            if (repoScoreRecord.closedWithoutMergeCount > 0 && effectiveMergedCount === 0) {
-                reasonsToSkip.push('User has rejected PR(s) in this repo with no successful merges');
-            }
-            else if (repoScoreRecord.closedWithoutMergeCount > 0 && effectiveMergedCount > 0) {
-                vettingResult.notes.push(`Mixed history: ${effectiveMergedCount} merged, ${repoScoreRecord.closedWithoutMergeCount} closed without merge`);
-            }
-        }
-        // Check for org-level affinity (user has merged PRs in another repo under same org)
-        const orgName = repoFullName.split('/')[0];
-        let orgHasMergedPRs = false;
-        if (orgName && repoFullName.includes('/')) {
-            orgHasMergedPRs = Object.values(this.stateManager.getState().repoScores).some((rs) => rs.repo && rs.mergedPRCount > 0 && rs.repo.startsWith(orgName + '/') && rs.repo !== repoFullName);
-        }
-        if (orgHasMergedPRs) {
-            reasonsToApprove.push(`Org affinity (merged PRs in other ${orgName} repos)`);
-        }
-        // Check for category preference match
-        const projectCategories = config.projectCategories ?? [];
-        const matchesCategory = repoBelongsToCategory(repoFullName, projectCategories);
-        if (matchesCategory) {
-            reasonsToApprove.push('Matches preferred project category');
-        }
-        let recommendation;
-        if (vettingResult.passedAllChecks) {
-            recommendation = 'approve';
-        }
-        else if (reasonsToSkip.length > 2) {
-            recommendation = 'skip';
-        }
-        else {
-            recommendation = 'needs_review';
-        }
-        // Downgrade to needs_review if any check was inconclusive —
-        // "approve" should only be given when all checks actually passed, not when they were skipped.
-        const hasInconclusiveChecks = projectHealth.checkFailed || existingPRCheck.inconclusive || claimCheck.inconclusive;
-        if (recommendation === 'approve' && hasInconclusiveChecks) {
-            recommendation = 'needs_review';
-            vettingResult.notes.push('Recommendation downgraded: one or more checks were inconclusive');
-        }
-        // Calculate repo quality bonus from star/fork counts (#98)
-        const repoQualityBonus = calculateRepoQualityBonus(projectHealth.stargazersCount ?? 0, projectHealth.forksCount ?? 0);
-        if (projectHealth.checkFailed && repoQualityBonus === 0) {
-            vettingResult.notes.push('Repo quality bonus unavailable: could not fetch star/fork counts due to API error');
-        }
-        const repoScore = this.getRepoScore(repoFullName);
-        const viabilityScore = calculateViabilityScore({
-            repoScore,
-            hasExistingPR: !noExistingPR,
-            isClaimed: !notClaimed,
-            clearRequirements,
-            hasContributionGuidelines: !!contributionGuidelines,
-            issueUpdatedAt: ghIssue.updated_at,
-            closedWithoutMergeCount: repoScoreRecord?.closedWithoutMergeCount ?? 0,
-            mergedPRCount: effectiveMergedCount,
-            orgHasMergedPRs,
-            repoQualityBonus,
-            matchesPreferredCategory: matchesCategory,
-        });
-        const starredRepos = this.stateManager.getStarredRepos();
-        const preferredOrgs = config.preferredOrgs ?? [];
-        let searchPriority = 'normal';
-        if (effectiveMergedCount > 0) {
-            searchPriority = 'merged_pr';
-        }
-        else if (preferredOrgs.some((o) => o.toLowerCase() === orgName?.toLowerCase())) {
-            searchPriority = 'preferred_org';
-        }
-        else if (starredRepos.includes(repoFullName)) {
-            searchPriority = 'starred';
-        }
-        const result = {
-            issue: trackedIssue,
-            vettingResult,
-            projectHealth,
-            recommendation,
-            reasonsToSkip,
-            reasonsToApprove,
-            viabilityScore,
-            searchPriority,
-        };
-        // Persist repo metadata (stars, language) so the dashboard can display it (#839)
-        if (!projectHealth.checkFailed) {
-            try {
-                this.stateManager.updateRepoScore(repoFullName, {
-                    stargazersCount: projectHealth.stargazersCount,
-                    language: projectHealth.language,
-                });
-            }
-            catch (error) {
-                warn(MODULE, `Failed to persist repo metadata for ${repoFullName}: ${errorMessage(error)}`);
-            }
-        }
-        // 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
-     */
-    async vetIssuesParallel(urls, maxResults, priority) {
-        const candidates = [];
-        const pending = new Map();
-        let failedVettingCount = 0;
-        let rateLimitFailures = 0;
-        let attemptedCount = 0;
-        for (const url of urls) {
-            if (candidates.length >= maxResults)
-                break;
-            attemptedCount++;
-            const task = this.vetIssue(url)
-                .then((candidate) => {
-                if (candidates.length < maxResults) {
-                    // Override the priority if provided
-                    if (priority) {
-                        candidate.searchPriority = priority;
-                    }
-                    candidates.push(candidate);
-                }
-            })
-                .catch((error) => {
-                failedVettingCount++;
-                if (isRateLimitError(error)) {
-                    rateLimitFailures++;
-                }
-                warn(MODULE, `Error vetting issue ${url}:`, errorMessage(error));
-            })
-                .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_VETTING) {
-                await Promise.race(pending.values());
-            }
-        }
-        // Wait for remaining
-        await Promise.allSettled(pending.values());
-        const allFailed = failedVettingCount === attemptedCount && attemptedCount > 0;
-        if (allFailed) {
-            warn(MODULE, `All ${attemptedCount} issue(s) failed vetting. ` +
-                `This may indicate a systemic issue (rate limit, auth, network).`);
-        }
-        return { candidates: candidates.slice(0, maxResults), allFailed, rateLimitHit: rateLimitFailures > 0 };
-    }
-    /**
-     * Get the repo score from state, or return null if not evaluated
-     */
-    getRepoScore(repoFullName) {
-        const state = this.stateManager.getState();
-        const repoScore = state.repoScores?.[repoFullName];
-        return repoScore?.score ?? null;
-    }
-}

package/dist/core/repo-health.d.ts

@@ -1,24 +0,0 @@
-/**
- * Repo Health — project health checks and contribution guidelines fetching.
- *
- * Extracted from issue-vetting.ts (#621) to isolate repo-level checks
- * from issue-level eligibility logic.
- */
-import { Octokit } from '@octokit/rest';
-import { type ContributionGuidelines, type ProjectHealth } from './types.js';
-/**
- * Check the health of a GitHub project: recent commits, CI status, star/fork counts.
- * Results are cached for HEALTH_CACHE_TTL_MS (4 hours).
- */
-export declare function checkProjectHealth(octokit: Octokit, owner: string, repo: string): Promise<ProjectHealth>;
-/**
- * Fetch and parse CONTRIBUTING.md (or variants) from a GitHub repo.
- * Probes multiple paths in parallel: CONTRIBUTING.md, .github/CONTRIBUTING.md,
- * docs/CONTRIBUTING.md, contributing.md. Results are cached for CACHE_TTL_MS.
- */
-export declare function fetchContributionGuidelines(octokit: Octokit, owner: string, repo: string): Promise<ContributionGuidelines | undefined>;
-/**
- * Parse the raw content of a CONTRIBUTING.md file to extract structured guidelines:
- * branch naming, commit format, test framework, linter, formatter, CLA requirement.
- */
-export declare function parseContributionGuidelines(content: string): ContributionGuidelines;

package/dist/core/repo-health.js

@@ -1,194 +0,0 @@
-/**
- * Repo Health — project health checks and contribution guidelines fetching.
- *
- * Extracted from issue-vetting.ts (#621) to isolate repo-level checks
- * from issue-level eligibility logic.
- */
-import { daysBetween } from './utils.js';
-import { errorMessage } from './errors.js';
-import { warn } from './logger.js';
-import { getHttpCache, cachedRequest, cachedTimeBased } from './http-cache.js';
-const MODULE = 'repo-health';
-// ── Cache for contribution guidelines ──
-const guidelinesCache = new Map();
-/** TTL for cached contribution guidelines (1 hour). */
-const CACHE_TTL_MS = 60 * 60 * 1000;
-/** TTL for cached project health results (4 hours). Health data (stars, commits, CI) changes slowly. */
-const HEALTH_CACHE_TTL_MS = 4 * 60 * 60 * 1000;
-/** Max entries in the guidelines cache before pruning. */
-const CACHE_MAX_SIZE = 100;
-/** Remove expired and excess entries from the guidelines cache. */
-function pruneCache() {
-    const now = Date.now();
-    // First, remove expired entries (older than CACHE_TTL_MS)
-    for (const [key, value] of guidelinesCache.entries()) {
-        if (now - value.fetchedAt > CACHE_TTL_MS) {
-            guidelinesCache.delete(key);
-        }
-    }
-    // Then, if still over size limit, remove oldest entries
-    if (guidelinesCache.size > CACHE_MAX_SIZE) {
-        const entries = Array.from(guidelinesCache.entries()).sort((a, b) => a[1].fetchedAt - b[1].fetchedAt);
-        const toRemove = entries.slice(0, guidelinesCache.size - CACHE_MAX_SIZE);
-        for (const [key] of toRemove) {
-            guidelinesCache.delete(key);
-        }
-    }
-}
-// ── Project health ──
-/**
- * Check the health of a GitHub project: recent commits, CI status, star/fork counts.
- * Results are cached for HEALTH_CACHE_TTL_MS (4 hours).
- */
-export async function checkProjectHealth(octokit, owner, repo) {
-    const cache = getHttpCache();
-    const healthCacheKey = `health:${owner}/${repo}`;
-    try {
-        return await cachedTimeBased(cache, healthCacheKey, HEALTH_CACHE_TTL_MS, async () => {
-            // Get repo info (with ETag caching — repo metadata changes infrequently)
-            const url = `/repos/${owner}/${repo}`;
-            const repoData = await cachedRequest(cache, url, (headers) => octokit.repos.get({ owner, repo, headers }));
-            // Get recent commits
-            const { data: commits } = await octokit.repos.listCommits({
-                owner,
-                repo,
-                per_page: 1,
-            });
-            const lastCommit = commits[0];
-            const lastCommitAt = lastCommit?.commit?.author?.date || repoData.pushed_at;
-            const daysSinceLastCommit = daysBetween(new Date(lastCommitAt));
-            // Check CI status (simplified - just check if workflows exist)
-            let ciStatus = 'unknown';
-            try {
-                const { data: workflows } = await octokit.actions.listRepoWorkflows({
-                    owner,
-                    repo,
-                    per_page: 1,
-                });
-                if (workflows.total_count > 0) {
-                    ciStatus = 'passing'; // Assume passing if workflows exist
-                }
-            }
-            catch (error) {
-                const errMsg = errorMessage(error);
-                warn(MODULE, `Failed to check CI status for ${owner}/${repo}: ${errMsg}. Defaulting to unknown.`);
-            }
-            return {
-                repo: `${owner}/${repo}`,
-                lastCommitAt,
-                daysSinceLastCommit,
-                openIssuesCount: repoData.open_issues_count,
-                avgIssueResponseDays: 0, // Would need more API calls to calculate
-                ciStatus,
-                isActive: daysSinceLastCommit < 30,
-                stargazersCount: repoData.stargazers_count,
-                forksCount: repoData.forks_count,
-                language: repoData.language,
-            };
-        });
-    }
-    catch (error) {
-        const errMsg = errorMessage(error);
-        warn(MODULE, `Error checking project health for ${owner}/${repo}: ${errMsg}`);
-        return {
-            repo: `${owner}/${repo}`,
-            lastCommitAt: '',
-            daysSinceLastCommit: 999,
-            openIssuesCount: 0,
-            avgIssueResponseDays: 0,
-            ciStatus: 'unknown',
-            isActive: false,
-            checkFailed: true,
-            failureReason: errMsg,
-        };
-    }
-}
-// ── Contribution guidelines ──
-/**
- * Fetch and parse CONTRIBUTING.md (or variants) from a GitHub repo.
- * Probes multiple paths in parallel: CONTRIBUTING.md, .github/CONTRIBUTING.md,
- * docs/CONTRIBUTING.md, contributing.md. Results are cached for CACHE_TTL_MS.
- */
-export async function fetchContributionGuidelines(octokit, owner, repo) {
-    const cacheKey = `${owner}/${repo}`;
-    // Check cache first
-    const cached = guidelinesCache.get(cacheKey);
-    if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) {
-        return cached.guidelines;
-    }
-    const filesToCheck = ['CONTRIBUTING.md', '.github/CONTRIBUTING.md', 'docs/CONTRIBUTING.md', 'contributing.md'];
-    // Probe all paths in parallel — take the first success in priority order
-    const results = await Promise.allSettled(filesToCheck.map((file) => octokit.repos.getContent({ owner, repo, path: file }).then(({ data }) => {
-        if ('content' in data) {
-            return Buffer.from(data.content, 'base64').toString('utf-8');
-        }
-        return null;
-    })));
-    for (let i = 0; i < results.length; i++) {
-        const result = results[i];
-        if (result.status === 'fulfilled' && result.value) {
-            const guidelines = parseContributionGuidelines(result.value);
-            guidelinesCache.set(cacheKey, { guidelines, fetchedAt: Date.now() });
-            pruneCache();
-            return guidelines;
-        }
-        if (result.status === 'rejected') {
-            const msg = result.reason instanceof Error ? result.reason.message : String(result.reason);
-            if (!msg.includes('404') && !msg.includes('Not Found')) {
-                warn(MODULE, `Unexpected error fetching ${filesToCheck[i]} from ${owner}/${repo}: ${msg}`);
-            }
-        }
-    }
-    // Cache the negative result too and prune if needed
-    guidelinesCache.set(cacheKey, { guidelines: undefined, fetchedAt: Date.now() });
-    pruneCache();
-    return undefined;
-}
-/**
- * Parse the raw content of a CONTRIBUTING.md file to extract structured guidelines:
- * branch naming, commit format, test framework, linter, formatter, CLA requirement.
- */
-export function parseContributionGuidelines(content) {
-    const guidelines = {
-        rawContent: content,
-    };
-    const lowerContent = content.toLowerCase();
-    // Detect branch naming conventions
-    if (lowerContent.includes('branch')) {
-        const branchMatch = content.match(/branch[^\n]*(?:named?|format|convention)[^\n]*[`"]([^`"]+)[`"]/i);
-        if (branchMatch) {
-            guidelines.branchNamingConvention = branchMatch[1];
-        }
-    }
-    // Detect commit message format
-    if (lowerContent.includes('conventional commit')) {
-        guidelines.commitMessageFormat = 'conventional commits';
-    }
-    else if (lowerContent.includes('commit message')) {
-        const commitMatch = content.match(/commit message[^\n]*[`"]([^`"]+)[`"]/i);
-        if (commitMatch) {
-            guidelines.commitMessageFormat = commitMatch[1];
-        }
-    }
-    // Detect test framework
-    if (lowerContent.includes('jest'))
-        guidelines.testFramework = 'Jest';
-    else if (lowerContent.includes('rspec'))
-        guidelines.testFramework = 'RSpec';
-    else if (lowerContent.includes('pytest'))
-        guidelines.testFramework = 'pytest';
-    else if (lowerContent.includes('mocha'))
-        guidelines.testFramework = 'Mocha';
-    // Detect linter
-    if (lowerContent.includes('eslint'))
-        guidelines.linter = 'ESLint';
-    else if (lowerContent.includes('rubocop'))
-        guidelines.linter = 'RuboCop';
-    else if (lowerContent.includes('prettier'))
-        guidelines.formatter = 'Prettier';
-    // Detect CLA requirement
-    if (lowerContent.includes('cla') || lowerContent.includes('contributor license agreement')) {
-        guidelines.claRequired = true;
-    }
-    return guidelines;
-}

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

@@ -1,62 +0,0 @@
-/**
- * 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
- */
-export declare class SearchBudgetTracker {
-    /** Timestamps of recent Search API calls within the sliding window. */
-    private callTimestamps;
-    /** Last known remaining quota from GitHub's rate limit endpoint. */
-    private knownRemaining;
-    /** Epoch ms when the rate limit window resets (from GitHub API). */
-    private resetAt;
-    /** Total calls recorded since init (for diagnostics). */
-    private totalCalls;
-    /**
-     * Initialize with pre-flight rate limit data from GitHub.
-     */
-    init(remaining: number, resetAt: string): void;
-    /**
-     * Record that a Search API call was just made.
-     */
-    recordCall(): void;
-    /**
-     * Remove timestamps older than the sliding window.
-     */
-    private pruneOldTimestamps;
-    /**
-     * Get the number of calls made in the current sliding window.
-     */
-    getCallsInWindow(): number;
-    /**
-     * Get the effective budget, accounting for both the sliding window limit
-     * and the pre-flight remaining quota from GitHub.
-     */
-    private getEffectiveBudget;
-    /**
-     * Check if we can afford N more Search API calls without exceeding the budget.
-     */
-    canAfford(n: number): boolean;
-    /**
-     * 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.
-     */
-    waitForBudget(): Promise<void>;
-    /**
-     * Get total calls recorded since init (for diagnostics).
-     */
-    getTotalCalls(): number;
-}
-/**
- * Get (or create) the shared SearchBudgetTracker singleton.
- */
-export declare function getSearchBudgetTracker(): SearchBudgetTracker;