@oss-autopilot/core 1.0.0 → 1.0.1

package/dist/core/issue-discovery.js

@@ -20,7 +20,7 @@ import { debug, info, warn } from './logger.js';
 import { isDocOnlyIssue, applyPerRepoCap } from './issue-filtering.js';
 import { IssueVetter } from './issue-vetting.js';
 import { getTopicsForCategories } from './category-mapping.js';
-import { buildLabelQuery, buildEffectiveLabels, interleaveArrays, cachedSearchIssues, filterVetAndScore, searchInRepos, } from './search-phases.js';
+import { buildEffectiveLabels, interleaveArrays, cachedSearchIssues, filterVetAndScore, searchInRepos, searchWithChunkedLabels, } from './search-phases.js';
 const MODULE = 'issue-discovery';
 /**
  * Multi-phase issue discovery engine that searches GitHub for contributable issues.
@@ -185,14 +185,12 @@ export class IssueDiscovery {
         const maxAgeDays = config.maxIssueAgeDays || 90;
         const now = new Date();
         // Build query parts
-        const labelQuery = buildLabelQuery(labels);
         // When languages includes 'any', omit the language filter entirely
         const isAnyLanguage = languages.some((l) => l.toLowerCase() === 'any');
         const langQuery = isAnyLanguage ? '' : languages.map((l) => `language:${l}`).join(' ');
         // Phase 0 uses a broader query — established contributors don't need beginner labels
-        const establishedQuery = `is:issue is:open ${langQuery} no:assignee`.replace(/  +/g, ' ').trim();
-        // Phases 1+ use label-filtered query for discovery in unfamiliar repos
-        const baseQuery = `is:issue is:open ${labelQuery} ${langQuery} no:assignee`.replace(/  +/g, ' ').trim();
+        // Phases 1+ pass labels separately to searchInRepos/searchWithChunkedLabels
+        const baseQualifiers = `is:issue is:open ${langQuery} no:assignee`.replace(/  +/g, ' ').trim();
         // Helper to filter issues
         const includeDocIssues = config.includeDocIssues ?? true;
         const aiBlocklisted = new Set(config.aiPolicyBlocklist ?? DEFAULT_CONFIG.aiPolicyBlocklist ?? []);
@@ -235,7 +233,7 @@ export class IssueDiscovery {
             if (mergedPhase0Repos.length > 0) {
                 const remainingNeeded = maxResults - allCandidates.length;
                 if (remainingNeeded > 0) {
-                    const { candidates: mergedCandidates, allBatchesFailed, rateLimitHit, } = await searchInRepos(this.octokit, this.vetter, mergedPhase0Repos, establishedQuery, remainingNeeded, 'merged_pr', filterIssues);
+                    const { candidates: mergedCandidates, allBatchesFailed, rateLimitHit, } = await searchInRepos(this.octokit, this.vetter, mergedPhase0Repos, baseQualifiers, [], remainingNeeded, 'merged_pr', filterIssues);
                     allCandidates.push(...mergedCandidates);
                     if (allBatchesFailed) {
                         phase0Error = 'All merged-PR repo batches failed';
@@ -251,7 +249,7 @@ export class IssueDiscovery {
             if (openPhase0Repos.length > 0 && allCandidates.length < maxResults) {
                 const remainingNeeded = maxResults - allCandidates.length;
                 if (remainingNeeded > 0) {
-                    const { candidates: openCandidates, allBatchesFailed, rateLimitHit, } = await searchInRepos(this.octokit, this.vetter, openPhase0Repos, establishedQuery, remainingNeeded, 'starred', filterIssues);
+                    const { candidates: openCandidates, allBatchesFailed, rateLimitHit, } = await searchInRepos(this.octokit, this.vetter, openPhase0Repos, baseQualifiers, [], remainingNeeded, 'starred', filterIssues);
                     allCandidates.push(...openCandidates);
                     if (allBatchesFailed) {
                         const msg = 'All open-PR repo batches failed';
@@ -275,16 +273,11 @@ export class IssueDiscovery {
                 info(MODULE, `Phase 0.5: Searching issues in ${orgsToSearch.length} preferred org(s)...`);
                 const remainingNeeded = maxResults - allCandidates.length;
                 const orgRepoFilter = orgsToSearch.map((org) => `org:${org}`).join(' OR ');
-                const orgQuery = `${baseQuery} (${orgRepoFilter})`;
+                const orgOps = orgsToSearch.length - 1;
                 try {
-                    const data = await cachedSearchIssues(this.octokit, {
-                        q: orgQuery,
-                        sort: 'created',
-                        order: 'desc',
-                        per_page: remainingNeeded * 3,
-                    });
-                    if (data.items.length > 0) {
-                        const filtered = filterIssues(data.items).filter((item) => {
+                    const allItems = await searchWithChunkedLabels(this.octokit, labels, orgOps, (labelQ) => `${baseQualifiers} ${labelQ} (${orgRepoFilter})`.replace(/  +/g, ' ').trim(), remainingNeeded * 3);
+                    if (allItems.length > 0) {
+                        const filtered = filterIssues(allItems).filter((item) => {
                             const repoFullName = item.repository_url.split('/').slice(-2).join('/');
                             return !phase0RepoSet.has(repoFullName);
                         });
@@ -316,7 +309,7 @@ export class IssueDiscovery {
                 info(MODULE, `Phase 1: Searching issues in ${reposToSearch.length} starred repos...`);
                 const remainingNeeded = maxResults - allCandidates.length;
                 if (remainingNeeded > 0) {
-                    const { candidates: starredCandidates, allBatchesFailed, rateLimitHit, } = await searchInRepos(this.octokit, this.vetter, reposToSearch.slice(0, 10), baseQuery, remainingNeeded, 'starred', filterIssues);
+                    const { candidates: starredCandidates, allBatchesFailed, rateLimitHit, } = await searchInRepos(this.octokit, this.vetter, reposToSearch.slice(0, 10), baseQualifiers, labels, remainingNeeded, 'starred', filterIssues);
                     allCandidates.push(...starredCandidates);
                     if (allBatchesFailed) {
                         phase1Error = 'All starred repo batches failed';
@@ -361,18 +354,11 @@ export class IssueDiscovery {
             const budgetPerTier = Math.ceil(remainingNeeded / tierLabelGroups.length);
             const tierResults = [];
             for (const { tier, tierLabels } of tierLabelGroups) {
-                const tierQuery = `is:issue is:open ${buildLabelQuery(tierLabels)} ${langQuery} no:assignee`
-                    .replace(/  +/g, ' ')
-                    .trim();
                 try {
-                    const data = await cachedSearchIssues(this.octokit, {
-                        q: tierQuery,
-                        sort: 'created',
-                        order: 'desc',
-                        per_page: budgetPerTier * 3,
-                    });
-                    info(MODULE, `Phase 2 [${tier}]: ${data.total_count} total, processing top ${data.items.length}...`);
-                    const { candidates: tierCandidates, allVetFailed, rateLimitHit: vetRateLimitHit, } = await filterVetAndScore(this.vetter, data.items, filterIssues, [phase0RepoSet, starredRepoSet, seenRepos], budgetPerTier, minStars, `Phase 2 [${tier}]`);
+                    const allItems = await searchWithChunkedLabels(this.octokit, tierLabels, 0, // no repo/org ORs in Phase 2
+                    (labelQ) => `${baseQualifiers} ${labelQ}`.replace(/  +/g, ' ').trim(), budgetPerTier * 3);
+                    info(MODULE, `Phase 2 [${tier}]: processing ${allItems.length} items...`);
+                    const { candidates: tierCandidates, allVetFailed, rateLimitHit: vetRateLimitHit, } = await filterVetAndScore(this.vetter, allItems, filterIssues, [phase0RepoSet, starredRepoSet, seenRepos], budgetPerTier, minStars, `Phase 2 [${tier}]`);
                     tierResults.push(tierCandidates);
                     // Update seenRepos so later tiers don't return duplicate repos
                     for (const c of tierCandidates)

package/dist/core/repo-score-manager.d.ts

@@ -4,7 +4,7 @@
  * and computing aggregate statistics. Mutation functions modify
  * the passed state object in place; query functions are pure.
  */
-import { AgentState, RepoScore, RepoScoreUpdate } from './types.js';
+import { AgentState, RepoScore, RepoScoreUpdate, StoredMergedPR, StoredClosedPR } from './types.js';
 /**
  * Calculate the score based on the repo's metrics.
  * Base 5, logarithmic merge bonus (max +5), -1 per closed without merge (max -3),
@@ -70,6 +70,12 @@ export interface Stats {
     /** Number of PRs needing a response. Always 0 in v2 (sourced from fresh fetch instead). */
     needsResponse: number;
 }
+/**
+ * Reconcile repoScores merged/closed counts with the stored PR arrays.
+ * Counts PRs per repo from the arrays and bumps repoScores counters when
+ * the array count is higher (never decreases). Returns true if any updates were made.
+ */
+export declare function reconcilePRCounts(state: AgentState, mergedPRs: StoredMergedPR[], closedPRs: StoredClosedPR[]): boolean;
 /**
  * Compute aggregate statistics from the current state.
  */

package/dist/core/repo-score-manager.js

@@ -6,6 +6,7 @@
  */
 import { isBelowMinStars } from './types.js';
 import { debug, warn } from './logger.js';
+import { parseGitHubUrl } from './utils.js';
 const MODULE = 'scoring';
 /** Repo scores older than this are considered stale and excluded from low-scoring lists. */
 const SCORE_TTL_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
@@ -178,6 +179,49 @@ export function getLowScoringRepos(state, maxScore) {
         .sort((a, b) => a.score - b.score)
         .map((rs) => rs.repo);
 }
+/**
+ * Count PRs per repo from an array of stored PR records.
+ * Skips entries with unparseable URLs.
+ */
+function countByRepo(prs) {
+    const counts = new Map();
+    for (const pr of prs) {
+        const parsed = parseGitHubUrl(pr.url);
+        if (!parsed) {
+            warn(MODULE, `Skipping PR with unparseable URL during reconciliation: "${pr.url}"`);
+            continue;
+        }
+        const repo = `${parsed.owner}/${parsed.repo}`;
+        counts.set(repo, (counts.get(repo) ?? 0) + 1);
+    }
+    return counts;
+}
+/**
+ * Reconcile repoScores merged/closed counts with the stored PR arrays.
+ * Counts PRs per repo from the arrays and bumps repoScores counters when
+ * the array count is higher (never decreases). Returns true if any updates were made.
+ */
+export function reconcilePRCounts(state, mergedPRs, closedPRs) {
+    const mergedUpdated = reconcileField(state, countByRepo(mergedPRs), 'mergedPRCount');
+    const closedUpdated = reconcileField(state, countByRepo(closedPRs), 'closedWithoutMergeCount');
+    return mergedUpdated || closedUpdated;
+}
+/**
+ * Reconcile a single counter field across all repos.
+ * Returns true if any repo's counter was bumped.
+ */
+function reconcileField(state, countsByRepo, field) {
+    let updated = false;
+    for (const [repo, arrayCount] of countsByRepo) {
+        const current = state.repoScores[repo]?.[field] ?? 0;
+        if (arrayCount > current) {
+            debug(MODULE, `Reconciling ${repo} ${field}: ${current} → ${arrayCount}`);
+            updateRepoScore(state, repo, { [field]: arrayCount });
+            updated = true;
+        }
+    }
+    return updated;
+}
 /**
  * Compute aggregate statistics from the current state.
  */

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

@@ -8,6 +8,16 @@ import { Octokit } from '@octokit/rest';
 import { type SearchPriority, type IssueCandidate, type IssueScope } from './types.js';
 import { type GitHubSearchItem } from './issue-filtering.js';
 import { IssueVetter } from './issue-vetting.js';
+/** GitHub Search API enforces a max of 5 AND/OR/NOT operators per query. */
+export declare const GITHUB_MAX_BOOLEAN_OPS = 5;
+/**
+ * Chunk labels into groups that fit within the operator budget.
+ * N labels require N-1 OR operators, so maxPerChunk = budget + 1.
+ *
+ * @param labels      Full label list
+ * @param reservedOps OR operators already consumed by repo/org filters
+ */
+export declare function chunkLabels(labels: string[], reservedOps?: number): string[][];
 /** Build a GitHub Search API label filter from a list of labels. */
 export declare function buildLabelQuery(labels: string[]): string;
 /** Resolve scope tiers into a flat label list, merged with custom labels. */
@@ -30,6 +40,20 @@ export declare function cachedSearchIssues(octokit: Octokit, params: {
     total_count: number;
     items: GitHubSearchItem[];
 }>;
+/**
+ * Search across chunked labels with deduplication.
+ *
+ * Splits labels into chunks that fit within GitHub's boolean operator budget,
+ * issues one search query per chunk, deduplicates results by URL, and returns
+ * the merged item list.
+ *
+ * @param octokit      Authenticated Octokit instance
+ * @param labels       Full label list to chunk
+ * @param reservedOps  OR operators already consumed by repo/org filters in the query
+ * @param buildQuery   Callback that receives a label query string and returns the full search query
+ * @param perPage      Number of results per API call
+ */
+export declare function searchWithChunkedLabels(octokit: Octokit, labels: string[], reservedOps: number, buildQuery: (labelQuery: string) => string, perPage: number): Promise<GitHubSearchItem[]>;
 /**
  * Shared pipeline: spam-filter, repo-exclusion, vetting, and star-count filter.
  * Used by Phases 2 and 3 to convert raw search results into vetted candidates.
@@ -46,9 +70,13 @@ export declare function filterVetAndScore(vetter: IssueVetter, items: GitHubSear
  * 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).
+ * Labels are chunked separately to stay within GitHub's 5 boolean operator limit.
+ * Each batch of repos consumes (batch.length - 1) OR operators, and the remaining
+ * budget is used for label OR operators.
+ *
+ * This reduces API calls from N (one per repo) to ceil(N/BATCH_SIZE) * label_chunks.
  */
-export declare function searchInRepos(octokit: Octokit, vetter: IssueVetter, repos: string[], baseQuery: string, maxResults: number, priority: SearchPriority, filterFn: (items: GitHubSearchItem[]) => GitHubSearchItem[]): Promise<{
+export declare function searchInRepos(octokit: Octokit, vetter: IssueVetter, repos: string[], baseQualifiers: string, labels: string[], maxResults: number, priority: SearchPriority, filterFn: (items: GitHubSearchItem[]) => GitHubSearchItem[]): Promise<{
     candidates: IssueCandidate[];
     allBatchesFailed: boolean;
     rateLimitHit: boolean;

package/dist/core/search-phases.js

@@ -10,6 +10,40 @@ import { debug, warn } from './logger.js';
 import { getHttpCache, cachedTimeBased } from './http-cache.js';
 import { detectLabelFarmingRepos } from './issue-filtering.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;
+/** 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.
+ *
+ * @param labels      Full label list
+ * @param reservedOps OR operators already consumed by repo/org filters
+ */
+export function chunkLabels(labels, reservedOps = 0) {
+    const maxPerChunk = GITHUB_MAX_BOOLEAN_OPS - reservedOps + 1;
+    if (maxPerChunk < 1) {
+        if (labels.length > 0) {
+            warn(MODULE, `Label filtering disabled: ${reservedOps} repo/org ORs exceed GitHub's ${GITHUB_MAX_BOOLEAN_OPS} operator limit. ` +
+                `All ${labels.length} label(s) dropped from query.`);
+        }
+        return [[]];
+    }
+    if (labels.length <= maxPerChunk)
+        return [labels];
+    const chunks = [];
+    for (let i = 0; i < labels.length; i += maxPerChunk) {
+        chunks.push(labels.slice(i, i + maxPerChunk));
+    }
+    debug(MODULE, `Split ${labels.length} labels into ${chunks.length} chunks (${reservedOps} ops reserved, max ${maxPerChunk} per chunk)`);
+    return chunks;
+}
 // ── Pure utilities ──
 /** Build a GitHub Search API label filter from a list of labels. */
 export function buildLabelQuery(labels) {
@@ -66,6 +100,42 @@ export async function cachedSearchIssues(octokit, params) {
     });
 }
 // ── Search infrastructure ──
+/**
+ * Search across chunked labels with deduplication.
+ *
+ * Splits labels into chunks that fit within GitHub's boolean operator budget,
+ * issues one search query per chunk, deduplicates results by URL, and returns
+ * the merged item list.
+ *
+ * @param octokit      Authenticated Octokit instance
+ * @param labels       Full label list to chunk
+ * @param reservedOps  OR operators already consumed by repo/org filters in the query
+ * @param buildQuery   Callback that receives a label query string and returns the full search query
+ * @param perPage      Number of results per API call
+ */
+export async function searchWithChunkedLabels(octokit, labels, reservedOps, buildQuery, perPage) {
+    const labelChunks = chunkLabels(labels, reservedOps);
+    const seenUrls = new Set();
+    const allItems = [];
+    for (let i = 0; i < labelChunks.length; i++) {
+        if (i > 0)
+            await sleep(INTER_QUERY_DELAY_MS);
+        const query = buildQuery(buildLabelQuery(labelChunks[i]));
+        const data = await cachedSearchIssues(octokit, {
+            q: query,
+            sort: 'created',
+            order: 'desc',
+            per_page: perPage,
+        });
+        for (const item of data.items) {
+            if (!seenUrls.has(item.html_url)) {
+                seenUrls.add(item.html_url);
+                allItems.push(item);
+            }
+        }
+    }
+    return allItems;
+}
 /**
  * Shared pipeline: spam-filter, repo-exclusion, vetting, and star-count filter.
  * Used by Phases 2 and 3 to convert raw search results into vetted candidates.
@@ -108,11 +178,14 @@ export async function filterVetAndScore(vetter, items, filterIssues, excludedRep
  * 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).
+ * Labels are chunked separately to stay within GitHub's 5 boolean operator limit.
+ * Each batch of repos consumes (batch.length - 1) OR operators, and the remaining
+ * budget is used for label OR operators.
+ *
+ * This reduces API calls from N (one per repo) to ceil(N/BATCH_SIZE) * label_chunks.
  */
-export async function searchInRepos(octokit, vetter, repos, baseQuery, maxResults, priority, filterFn) {
+export async function searchInRepos(octokit, vetter, repos, baseQualifiers, labels, maxResults, priority, filterFn) {
     const candidates = [];
-    const BATCH_SIZE = 5;
     const batches = batchRepos(repos, BATCH_SIZE);
     let failedBatches = 0;
     let rateLimitFailures = 0;
@@ -120,17 +193,12 @@ export async function searchInRepos(octokit, vetter, repos, baseQuery, maxResult
         if (candidates.length >= maxResults)
             break;
         try {
-            // Build repo filter: (repo:a OR repo:b OR repo:c)
             const repoFilter = batch.map((r) => `repo:${r}`).join(' OR ');
-            const batchQuery = `${baseQuery} (${repoFilter})`;
-            const data = await cachedSearchIssues(octokit, {
-                q: batchQuery,
-                sort: 'created',
-                order: 'desc',
-                per_page: Math.min(30, (maxResults - candidates.length) * 3),
-            });
-            if (data.items.length > 0) {
-                const filtered = filterFn(data.items);
+            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 } = await vetter.vetIssuesParallel(filtered.slice(0, remainingNeeded * 2).map((i) => i.html_url), remainingNeeded, priority);
                 candidates.push(...vetted);

package/dist/core/state.d.ts

@@ -27,6 +27,11 @@ export declare class StateManager {
      *   Defaults to false (normal persistent mode).
      */
     constructor(inMemoryOnly?: boolean);
+    /**
+     * Attempt PR count reconciliation, logging a warning on failure.
+     * Called after every state load from disk.
+     */
+    private tryReconcilePRCounts;
     /**
      * Execute multiple mutations as a single batch, deferring disk I/O until the
      * batch completes. Nested `batch()` calls are flattened — only the outermost saves.
@@ -262,6 +267,11 @@ export declare class StateManager {
     getLowScoringRepos(maxScore?: number): string[];
     /** Returns aggregate contribution statistics (merge rate, PR counts, repo breakdown). */
     getStats(): Stats;
+    /**
+     * Reconcile repoScores merged/closed counts with the stored PR arrays.
+     * Bumps counters when the array has more PRs than the counter tracks.
+     */
+    private reconcilePRCounts;
 }
 /**
  * Get the singleton StateManager instance, creating it on first call.

package/dist/core/state.js

@@ -5,7 +5,8 @@
  */
 import { loadState, saveState, reloadStateIfChanged, createFreshState } from './state-persistence.js';
 import * as repoScoring from './repo-score-manager.js';
-import { debug } from './logger.js';
+import { debug, warn } from './logger.js';
+import { errorMessage } from './errors.js';
 export { acquireLock, releaseLock, atomicWriteFileSync } from './state-persistence.js';
 const MODULE = 'state';
 // Maximum number of events to retain in the event log
@@ -38,6 +39,20 @@ export class StateManager {
             const result = loadState();
             this.state = result.state;
             this.lastLoadedMtimeMs = result.mtimeMs;
+            this.tryReconcilePRCounts();
+        }
+    }
+    /**
+     * Attempt PR count reconciliation, logging a warning on failure.
+     * Called after every state load from disk.
+     */
+    tryReconcilePRCounts() {
+        try {
+            this.reconcilePRCounts();
+        }
+        catch (err) {
+            warn(MODULE, `PR count reconciliation failed (will retry on next load): ${errorMessage(err)}`);
+            debug(MODULE, `Reconciliation error details: ${err instanceof Error ? err.stack : String(err)}`);
         }
     }
     /**
@@ -130,6 +145,7 @@ export class StateManager {
             return false;
         this.state = result.state;
         this.lastLoadedMtimeMs = result.mtimeMs;
+        this.tryReconcilePRCounts();
         return true;
     }
     // === Dashboard Data Setters ===
@@ -558,6 +574,19 @@ export class StateManager {
     getStats() {
         return repoScoring.getStats(this.state);
     }
+    /**
+     * Reconcile repoScores merged/closed counts with the stored PR arrays.
+     * Bumps counters when the array has more PRs than the counter tracks.
+     */
+    reconcilePRCounts() {
+        const merged = this.state.mergedPRs ?? [];
+        const closed = this.state.closedPRs ?? [];
+        if (merged.length === 0 && closed.length === 0)
+            return;
+        const updated = repoScoring.reconcilePRCounts(this.state, merged, closed);
+        if (updated)
+            this.autoSave();
+    }
 }
 // Singleton instance
 let stateManager = null;

package/package.json

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