@oss-autopilot/core 0.41.0

package/dist/core/http-cache.js

@@ -0,0 +1,269 @@
+/**
+ * HTTP caching with ETags for GitHub API responses.
+ *
+ * Stores ETags and response bodies for cacheable GET endpoints in
+ * `~/.oss-autopilot/cache/`. On subsequent requests, sends `If-None-Match`
+ * headers — 304 responses don't count against GitHub rate limits.
+ *
+ * Also provides in-flight request deduplication so that concurrent calls
+ * for the same endpoint (e.g., star counts for two PRs in the same repo)
+ * share a single HTTP round-trip.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import { getCacheDir } from './utils.js';
+import { debug } from './logger.js';
+const MODULE = 'http-cache';
+/**
+ * Maximum age (in ms) before a cache entry is considered stale and eligible for
+ * eviction during cleanup. Defaults to 24 hours. Entries older than this are
+ * still *usable* for conditional requests (the ETag may still be valid), but
+ * `evictStale()` will remove them.
+ */
+const DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+/**
+ * File-based HTTP cache backed by `~/.oss-autopilot/cache/`.
+ *
+ * Each cache entry is stored as a separate JSON file keyed by the SHA-256
+ * hash of the request URL. This avoids filesystem issues with URL-based
+ * filenames and keeps lookup O(1).
+ */
+export class HttpCache {
+    cacheDir;
+    /** In-flight request deduplication map: URL -> Promise<response>. */
+    inflightRequests = new Map();
+    constructor(cacheDir) {
+        this.cacheDir = cacheDir ?? getCacheDir();
+    }
+    /** Derive a filesystem-safe cache key from a URL. */
+    keyFor(url) {
+        return crypto.createHash('sha256').update(url).digest('hex');
+    }
+    /** Full path to the cache file for a given URL. */
+    pathFor(url) {
+        return path.join(this.cacheDir, `${this.keyFor(url)}.json`);
+    }
+    /**
+     * Look up a cached response. Returns `null` if no cache entry exists.
+     */
+    get(url) {
+        const filePath = this.pathFor(url);
+        try {
+            const raw = fs.readFileSync(filePath, 'utf-8');
+            const entry = JSON.parse(raw);
+            // Sanity-check: the file should contain the URL we asked for
+            if (entry.url !== url) {
+                debug(MODULE, `Cache collision detected for ${url}, ignoring`);
+                return null;
+            }
+            return entry;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Store a response with its ETag.
+     */
+    set(url, etag, body) {
+        const entry = {
+            etag,
+            url,
+            body,
+            cachedAt: new Date().toISOString(),
+        };
+        try {
+            fs.writeFileSync(this.pathFor(url), JSON.stringify(entry), { encoding: 'utf-8', mode: 0o600 });
+            debug(MODULE, `Cached response for ${url}`);
+        }
+        catch (err) {
+            // Non-fatal: cache write failure should not break the request
+            debug(MODULE, `Failed to write cache for ${url}`, err);
+        }
+    }
+    /**
+     * Check whether a URL has an in-flight request.
+     */
+    hasInflight(url) {
+        return this.inflightRequests.has(url);
+    }
+    /**
+     * Get the in-flight promise for a URL (for deduplication).
+     */
+    getInflight(url) {
+        return this.inflightRequests.get(url);
+    }
+    /**
+     * Register an in-flight request for deduplication.
+     * Returns a cleanup function to call when the request completes.
+     */
+    setInflight(url, promise) {
+        this.inflightRequests.set(url, promise);
+        return () => {
+            this.inflightRequests.delete(url);
+        };
+    }
+    /**
+     * Remove stale entries older than `maxAgeMs` from the cache directory.
+     * Intended to be called periodically (e.g., once per daily run).
+     */
+    evictStale(maxAgeMs = DEFAULT_MAX_AGE_MS) {
+        let evicted = 0;
+        try {
+            const files = fs.readdirSync(this.cacheDir);
+            const now = Date.now();
+            for (const file of files) {
+                if (!file.endsWith('.json'))
+                    continue;
+                const filePath = path.join(this.cacheDir, file);
+                try {
+                    const raw = fs.readFileSync(filePath, 'utf-8');
+                    const entry = JSON.parse(raw);
+                    const age = now - new Date(entry.cachedAt).getTime();
+                    if (age > maxAgeMs) {
+                        fs.unlinkSync(filePath);
+                        evicted++;
+                    }
+                }
+                catch {
+                    // Corrupt entry — remove it
+                    try {
+                        fs.unlinkSync(filePath);
+                        evicted++;
+                    }
+                    catch {
+                        // Ignore
+                    }
+                }
+            }
+        }
+        catch {
+            // Cache dir might not exist yet — that's fine
+        }
+        if (evicted > 0) {
+            debug(MODULE, `Evicted ${evicted} stale cache entries`);
+        }
+        return evicted;
+    }
+    /**
+     * Remove all entries from the cache.
+     */
+    clear() {
+        try {
+            const files = fs.readdirSync(this.cacheDir);
+            for (const file of files) {
+                if (!file.endsWith('.json'))
+                    continue;
+                fs.unlinkSync(path.join(this.cacheDir, file));
+            }
+            debug(MODULE, 'Cache cleared');
+        }
+        catch {
+            // Cache dir might not exist yet — that's fine
+        }
+    }
+    /**
+     * Return the number of entries currently in the cache.
+     */
+    size() {
+        try {
+            return fs.readdirSync(this.cacheDir).filter((f) => f.endsWith('.json')).length;
+        }
+        catch {
+            return 0;
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Singleton
+// ---------------------------------------------------------------------------
+let _httpCache = null;
+/**
+ * Get (or create) the shared HttpCache singleton.
+ * The singleton is lazily initialized on first access.
+ */
+export function getHttpCache() {
+    if (!_httpCache) {
+        _httpCache = new HttpCache();
+    }
+    return _httpCache;
+}
+/** Reset the singleton (for tests). */
+export function resetHttpCache() {
+    _httpCache = null;
+}
+// ---------------------------------------------------------------------------
+// Octokit integration helpers
+// ---------------------------------------------------------------------------
+/**
+ * Wraps an Octokit `repos.get`-style call with ETag caching and request
+ * deduplication.
+ *
+ * Usage:
+ * ```ts
+ * const data = await cachedRequest(cache, octokit, '/repos/owner/repo', () =>
+ *   octokit.repos.get({ owner, repo: name }),
+ * );
+ * ```
+ *
+ * 1. If an identical request is already in-flight, returns the existing promise
+ *    (request deduplication).
+ * 2. If a cached ETag exists, sends `If-None-Match`. On 304, returns the
+ *    cached body without consuming a rate-limit point.
+ * 3. On a fresh 200, caches the ETag + body for next time.
+ */
+export async function cachedRequest(cache, url, fetcher) {
+    // --- Deduplication ---
+    const existing = cache.getInflight(url);
+    if (existing) {
+        debug(MODULE, `Dedup hit for ${url}`);
+        return (await existing);
+    }
+    const doFetch = async () => {
+        const extraHeaders = {};
+        const cached = cache.get(url);
+        if (cached) {
+            extraHeaders['if-none-match'] = cached.etag;
+        }
+        try {
+            const response = await fetcher(extraHeaders);
+            // Store ETag if present (headers may be absent in test mocks)
+            const etag = response.headers?.['etag'];
+            if (etag) {
+                cache.set(url, etag, response.data);
+            }
+            return response.data;
+        }
+        catch (err) {
+            // Check for 304 Not Modified — re-read cache to avoid stale closure snapshot
+            if (isNotModifiedError(err)) {
+                const freshCached = cache.get(url);
+                if (freshCached) {
+                    debug(MODULE, `304 cache hit for ${url}`);
+                    return freshCached.body;
+                }
+            }
+            throw err;
+        }
+    };
+    const promise = doFetch();
+    const cleanup = cache.setInflight(url, promise);
+    try {
+        const result = await promise;
+        return result;
+    }
+    finally {
+        cleanup();
+    }
+}
+/**
+ * Detect whether an error is a 304 Not Modified response.
+ * Octokit throws a RequestError with status 304 for conditional requests.
+ */
+function isNotModifiedError(err) {
+    if (err && typeof err === 'object' && 'status' in err) {
+        return err.status === 304;
+    }
+    return false;
+}

package/dist/core/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Core module exports
+ * Re-exports all core functionality for convenient imports
+ */
+export { StateManager, getStateManager, resetStateManager } from './state.js';
+export { PRMonitor, type PRCheckFailure, type FetchPRsResult, computeDisplayLabel, classifyCICheck, classifyFailingChecks, } from './pr-monitor.js';
+export { IssueDiscovery, type IssueCandidate, type SearchPriority, isDocOnlyIssue, applyPerRepoCap, DOC_ONLY_LABELS, } from './issue-discovery.js';
+export { IssueConversationMonitor } from './issue-conversation.js';
+export { isBotAuthor, isAcknowledgmentComment } from './comment-utils.js';
+export { getOctokit, checkRateLimit, type RateLimitInfo } from './github.js';
+export { parseGitHubUrl, daysBetween, splitRepo, getDataDir, getStatePath, getBackupDir, getCacheDir, getDashboardPath, formatRelativeTime, byDateDescending, getGitHubToken, getGitHubTokenAsync, requireGitHubToken, resetGitHubTokenCache, } from './utils.js';
+export { enableDebug, isDebugEnabled, debug, warn, timed } from './logger.js';
+export { HttpCache, getHttpCache, resetHttpCache, cachedRequest, type CacheEntry } from './http-cache.js';
+export { CRITICAL_STATUSES, computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatActionHint, formatBriefSummary, formatSummary, printDigest, } from './daily-logic.js';
+export * from './types.js';

package/dist/core/index.js

@@ -0,0 +1,15 @@
+/**
+ * Core module exports
+ * Re-exports all core functionality for convenient imports
+ */
+export { StateManager, getStateManager, resetStateManager } from './state.js';
+export { PRMonitor, computeDisplayLabel, classifyCICheck, classifyFailingChecks, } from './pr-monitor.js';
+export { IssueDiscovery, isDocOnlyIssue, applyPerRepoCap, DOC_ONLY_LABELS, } from './issue-discovery.js';
+export { IssueConversationMonitor } from './issue-conversation.js';
+export { isBotAuthor, isAcknowledgmentComment } from './comment-utils.js';
+export { getOctokit, checkRateLimit } from './github.js';
+export { parseGitHubUrl, daysBetween, splitRepo, getDataDir, getStatePath, getBackupDir, getCacheDir, getDashboardPath, formatRelativeTime, byDateDescending, getGitHubToken, getGitHubTokenAsync, requireGitHubToken, resetGitHubTokenCache, } from './utils.js';
+export { enableDebug, isDebugEnabled, debug, warn, timed } from './logger.js';
+export { HttpCache, getHttpCache, resetHttpCache, cachedRequest } from './http-cache.js';
+export { CRITICAL_STATUSES, computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatActionHint, formatBriefSummary, formatSummary, printDigest, } from './daily-logic.js';
+export * from './types.js';

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

@@ -0,0 +1,29 @@
+/**
+ * Issue Conversation Monitor — tracks issues the user has commented on
+ * and detects maintainer responses that need attention.
+ *
+ * Follows the same pattern as PRMonitor: stateless fetch from GitHub,
+ * bounded concurrency via worker pool, bot/acknowledgment filtering.
+ */
+import type { CommentedIssue } from './types.js';
+export declare class IssueConversationMonitor {
+    private octokit;
+    private stateManager;
+    constructor(githubToken: string);
+    /**
+     * Fetch issues the user has commented on and determine conversation state.
+     * Filters out: user-authored issues, user-owned repos, excluded repos/orgs,
+     * AI policy blocklisted repos, already-tracked issues, and pull requests.
+     */
+    fetchCommentedIssues(maxDays?: number): Promise<{
+        issues: CommentedIssue[];
+        failures: Array<{
+            issueUrl: string;
+            error: string;
+        }>;
+    }>;
+    /**
+     * Analyze a single issue's comment thread to determine conversation status.
+     */
+    private analyzeIssueConversation;
+}

package/dist/core/issue-conversation.js

@@ -0,0 +1,231 @@
+/**
+ * Issue Conversation Monitor — tracks issues the user has commented on
+ * and detects maintainer responses that need attention.
+ *
+ * Follows the same pattern as PRMonitor: stateless fetch from GitHub,
+ * bounded concurrency via worker pool, bot/acknowledgment filtering.
+ */
+import { getOctokit } from './github.js';
+import { isBotAuthor, isAcknowledgmentComment } from './comment-utils.js';
+import { paginateAll } from './pagination.js';
+import { getStateManager } from './state.js';
+import { daysBetween, splitRepo, extractOwnerRepo } from './utils.js';
+import { runWorkerPool } from './concurrency.js';
+import { ConfigurationError } from './errors.js';
+import { debug, warn } from './logger.js';
+const MODULE = 'issue-conversation';
+const MAX_CONCURRENT_REQUESTS = 5;
+/** Associations that indicate someone with repo-level permissions. */
+const MAINTAINER_ASSOCIATIONS = new Set(['OWNER', 'MEMBER', 'COLLABORATOR']);
+export class IssueConversationMonitor {
+    octokit;
+    stateManager;
+    constructor(githubToken) {
+        this.octokit = getOctokit(githubToken);
+        this.stateManager = getStateManager();
+    }
+    /**
+     * Fetch issues the user has commented on and determine conversation state.
+     * Filters out: user-authored issues, user-owned repos, excluded repos/orgs,
+     * AI policy blocklisted repos, already-tracked issues, and pull requests.
+     */
+    async fetchCommentedIssues(maxDays = 30) {
+        const config = this.stateManager.getState().config;
+        if (!config.githubUsername) {
+            throw new ConfigurationError('No GitHub username configured. Run setup first.');
+        }
+        const username = config.githubUsername;
+        const cutoffDate = new Date();
+        cutoffDate.setDate(cutoffDate.getDate() - maxDays);
+        const since = cutoffDate.toISOString().split('T')[0];
+        debug(MODULE, `Fetching commented issues for @${username} (last ${maxDays} days)...`);
+        // Search for open issues the user has commented on, updated within window
+        // Single page (100) is sufficient for most users; log if truncated.
+        const { data } = await this.octokit.search.issuesAndPullRequests({
+            q: `commenter:${username} type:issue state:open updated:>=${since}`,
+            sort: 'updated',
+            order: 'desc',
+            per_page: 100,
+        });
+        if (data.total_count > 100) {
+            warn(MODULE, `Search returned ${data.total_count} results but only first 100 were fetched. Some commented issues may be missing.`);
+        }
+        // Build sets for filtering
+        const trackedIssues = this.stateManager.getState().activeIssues || [];
+        const trackedIssueKeys = new Set(trackedIssues
+            .filter((i) => i.status === 'claimed' || i.status === 'in_progress' || i.status === 'pr_submitted')
+            .map((i) => `${i.repo}#${i.number}`));
+        const blocklist = new Set((config.aiPolicyBlocklist || []).map((r) => r.toLowerCase()));
+        // Filter out PRs, user-authored issues, excluded repos, blocklisted repos, and already-tracked issues.
+        // Also parse repo info for each candidate to avoid re-parsing in analyzeIssueConversation.
+        const candidates = [];
+        for (const item of data.items) {
+            // Defensive: skip pull requests in case type:issue qualifier is unreliable
+            if (item.pull_request)
+                continue;
+            const parsed = extractOwnerRepo(item.html_url);
+            if (!parsed) {
+                warn(MODULE, `Skipping issue with unparseable URL: ${item.html_url}`);
+                continue;
+            }
+            const { owner, repo } = parsed;
+            const repoFullName = `${owner}/${repo}`;
+            // Skip issues in user-owned repos (we only care about contributing to others' projects)
+            if (owner.toLowerCase() === username.toLowerCase())
+                continue;
+            // Skip user-authored issues
+            if (item.user?.login?.toLowerCase() === username.toLowerCase())
+                continue;
+            // Skip excluded repos and orgs
+            if (config.excludeRepos.includes(repoFullName))
+                continue;
+            if (config.excludeOrgs?.some((org) => owner.toLowerCase() === org.toLowerCase()))
+                continue;
+            // Skip blocklisted repos
+            if (blocklist.has(repoFullName.toLowerCase()))
+                continue;
+            // Skip issues already in the tracked pipeline
+            if (trackedIssueKeys.has(`${repoFullName}#${item.number}`))
+                continue;
+            candidates.push({ item, repoFullName });
+        }
+        debug(MODULE, `Found ${candidates.length} commented issues to check`);
+        // Fetch comments for each issue using worker pool.
+        const results = [];
+        const failures = [];
+        await runWorkerPool(candidates, async ({ item, repoFullName }) => {
+            try {
+                const issue = await this.analyzeIssueConversation(item, repoFullName, username);
+                if (issue) {
+                    results.push(issue);
+                }
+                else {
+                    failures.push({
+                        issueUrl: item.html_url,
+                        error: 'No user comment found despite commenter: search match (possible pagination or eventual consistency)',
+                    });
+                }
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                failures.push({ issueUrl: item.html_url, error: msg });
+                warn(MODULE, `Error analyzing issue ${item.html_url}: ${msg}`);
+            }
+        }, MAX_CONCURRENT_REQUESTS);
+        if (failures.length > 0) {
+            warn(MODULE, `${failures.length}/${candidates.length} issue analysis call(s) failed`);
+        }
+        if (failures.length === candidates.length && candidates.length > 0) {
+            warn(MODULE, `All ${candidates.length} issue analysis call(s) failed. Possible systemic issue (rate limit, auth, network).`);
+        }
+        // Sort: new_response first, then waiting, then acknowledged
+        const statusOrder = {
+            new_response: 0,
+            waiting: 1,
+            acknowledged: 2,
+        };
+        results.sort((a, b) => statusOrder[a.status] - statusOrder[b.status]);
+        debug(MODULE, `Analyzed ${results.length} issue conversations (${results.filter((i) => i.status === 'new_response').length} with new responses)`);
+        return { issues: results, failures };
+    }
+    /**
+     * Analyze a single issue's comment thread to determine conversation status.
+     */
+    async analyzeIssueConversation(item, repoFullName, username) {
+        const { owner, repo } = splitRepo(repoFullName);
+        const allComments = await paginateAll((page) => this.octokit.issues.listComments({
+            owner,
+            repo,
+            issue_number: item.number,
+            per_page: 100,
+            page,
+        }));
+        const timeline = [];
+        for (const comment of allComments) {
+            if (!comment.user?.login)
+                continue; // Skip comments from deleted accounts
+            const author = comment.user.login;
+            timeline.push({
+                author,
+                body: comment.body || '',
+                createdAt: comment.created_at,
+                isUser: author.toLowerCase() === username.toLowerCase(),
+                authorAssociation: String(comment.author_association ?? ''),
+            });
+        }
+        timeline.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+        // Find the user's last comment
+        let userLastComment;
+        for (const entry of timeline) {
+            if (entry.isUser)
+                userLastComment = entry;
+        }
+        // If user never commented (shouldn't happen with commenter: search, but be safe)
+        if (!userLastComment) {
+            warn(MODULE, `No user comment found for ${item.html_url} despite commenter: search match`);
+            return null;
+        }
+        const userLastCommentTime = new Date(userLastComment.createdAt);
+        // Only surface comments directed at the user (#343):
+        //   1. From a maintainer (OWNER/MEMBER/COLLABORATOR) — inherently authoritative
+        //   2. @mentions the user — explicitly addressed
+        // This filters out community "+1" and "me too" noise.
+        const userMention = `@${username.toLowerCase()}`;
+        function isDirectedAtUser(entry) {
+            return MAINTAINER_ASSOCIATIONS.has(entry.authorAssociation) || entry.body.toLowerCase().includes(userMention);
+        }
+        // Find the last substantive, directed response after the user's last comment
+        let lastResponse;
+        for (const entry of timeline) {
+            if (entry.isUser)
+                continue;
+            if (isBotAuthor(entry.author))
+                continue;
+            const entryTime = new Date(entry.createdAt);
+            if (entryTime > userLastCommentTime) {
+                if (isAcknowledgmentComment(entry.body))
+                    continue;
+                if (!isDirectedAtUser(entry))
+                    continue;
+                lastResponse = {
+                    author: entry.author,
+                    body: entry.body.slice(0, 200) + (entry.body.length > 200 ? '...' : ''),
+                    createdAt: entry.createdAt,
+                    authorAssociation: entry.authorAssociation,
+                };
+            }
+        }
+        const labels = (item.labels || []).map((l) => l.name || '').filter(Boolean);
+        const base = {
+            repo: repoFullName,
+            number: item.number,
+            title: item.title,
+            url: item.html_url,
+            userLastCommentedAt: userLastComment.createdAt,
+            labels,
+            daysSinceUserComment: daysBetween(userLastCommentTime, new Date()),
+        };
+        if (lastResponse) {
+            return {
+                ...base,
+                status: 'new_response',
+                lastResponseAuthor: lastResponse.author,
+                lastResponseBody: lastResponse.body,
+                lastResponseAt: lastResponse.createdAt,
+                isFromMaintainer: MAINTAINER_ASSOCIATIONS.has(lastResponse.authorAssociation),
+            };
+        }
+        // No directed response found. Determine whether the user or a relevant
+        // commenter (maintainer / @mention) spoke last. Irrelevant community
+        // comments are excluded from this check too (#343).
+        const lastRelevantComment = [...timeline].reverse().find((e) => {
+            if (isBotAuthor(e.author))
+                return false;
+            if (e.isUser)
+                return true;
+            return isDirectedAtUser(e);
+        });
+        const status = lastRelevantComment?.isUser ? 'acknowledged' : 'waiting';
+        return { ...base, status };
+    }
+}

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

@@ -0,0 +1,85 @@
+/**
+ * Issue Discovery — orchestrates multi-phase issue search across GitHub.
+ *
+ * Delegates filtering, scoring, and vetting to focused modules (#356):
+ * - issue-filtering.ts — spam detection, doc-only filtering, per-repo caps
+ * - issue-scoring.ts  — viability scores, repo quality bonuses
+ * - issue-vetting.ts  — individual issue checks (PRs, claims, health, guidelines)
+ */
+import { type IssueCandidate } from './types.js';
+import { type ViabilityScoreParams } from './issue-scoring.js';
+export { isDocOnlyIssue, applyPerRepoCap, isLabelFarming, hasTemplatedTitle, detectLabelFarmingRepos, DOC_ONLY_LABELS, BEGINNER_LABELS, type GitHubSearchItem, } from './issue-filtering.js';
+export { calculateRepoQualityBonus, calculateViabilityScore, type ViabilityScoreParams } from './issue-scoring.js';
+export { type CheckResult } from './issue-vetting.js';
+export type { SearchPriority, IssueCandidate } from './types.js';
+export declare class IssueDiscovery {
+    private octokit;
+    private stateManager;
+    private githubToken;
+    private vetter;
+    /** Set after searchIssues() runs if rate limits affected the search (low pre-flight quota or mid-search rate limit hits). */
+    rateLimitWarning: string | null;
+    constructor(githubToken: string);
+    /**
+     * Fetch the authenticated user's starred repositories from GitHub.
+     * Updates the state manager with the list and timestamp.
+     */
+    fetchStarredRepos(): Promise<string[]>;
+    /**
+     * Get starred repos, fetching from GitHub if cache is stale
+     */
+    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 (#349).
+     * Filters out issues from low-scoring and excluded repos.
+     */
+    searchIssues(options?: {
+        languages?: string[];
+        labels?: string[];
+        maxResults?: number;
+    }): Promise<IssueCandidate[]>;
+    /**
+     * Search for issues within specific repos using batched queries.
+     *
+     * To avoid GitHub's secondary rate limit (30 requests/minute), we batch
+     * multiple repos into a single search query using OR syntax:
+     *   repo:owner1/repo1 OR repo:owner2/repo2 OR repo:owner3/repo3
+     *
+     * This reduces API calls from N (one per repo) to ceil(N/BATCH_SIZE).
+     */
+    private searchInRepos;
+    /**
+     * Split repos into batches of the specified size.
+     */
+    private batchRepos;
+    /**
+     * Check if an error is a GitHub rate limit error (429 or rate-limit 403).
+     * Static proxy kept for backward compatibility with tests.
+     */
+    static isRateLimitError(error: unknown): boolean;
+    /**
+     * Vet a specific issue (delegates to IssueVetter).
+     */
+    vetIssue(issueUrl: string): Promise<IssueCandidate>;
+    /**
+     * Analyze issue requirements for clarity (delegates to IssueVetter).
+     * Kept on class for backward compatibility.
+     */
+    analyzeRequirements(body: string): boolean;
+    /**
+     * Calculate viability score for an issue (delegates to issue-scoring module).
+     * Kept on class for backward compatibility with tests that call instance.calculateViabilityScore().
+     */
+    calculateViabilityScore(params: ViabilityScoreParams): number;
+    /**
+     * Save search results to ~/.oss-autopilot/found-issues.md
+     * Results are sorted by viability score (highest first)
+     */
+    saveSearchResults(candidates: IssueCandidate[]): string;
+    /**
+     * Format issue candidate for display
+     */
+    formatCandidate(candidate: IssueCandidate): string;
+}