@oss-scout/core 0.3.0 → 0.5.0

package/dist/core/search-phases.js

@@ -5,9 +5,9 @@
  * caching, spam-filtering, and batched repo search logic.
  */
 import { SCOPE_LABELS, } from "./types.js";
-import { errorMessage, isRateLimitError } from "./errors.js";
+import { errorMessage, getHttpStatusCode, isRateLimitError } from "./errors.js";
 import { debug, warn } from "./logger.js";
-import { getHttpCache, cachedTimeBased } from "./http-cache.js";
+import { getHttpCache } from "./http-cache.js";
 import { detectLabelFarmingRepos, } from "./issue-filtering.js";
 import { extractRepoFromUrl, sleep } from "./utils.js";
 import { getSearchBudgetTracker } from "./search-budget.js";
@@ -95,20 +95,166 @@ 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 tracker = getSearchBudgetTracker();
-        await tracker.waitForBudget();
+    const cache = getHttpCache();
+    // Check cache first
+    const cached = cache.getIfFresh(cacheKey, SEARCH_CACHE_TTL_MS);
+    if (cached) {
+        debug(MODULE, `Search cache hit for query`);
+        return cached;
+    }
+    // Fetch from API
+    const tracker = getSearchBudgetTracker();
+    await tracker.waitForBudget();
+    let data;
+    try {
+        const response = await octokit.search.issuesAndPullRequests(params);
+        data = response.data;
+    }
+    finally {
+        tracker.recordCall();
+    }
+    // Only cache non-empty results to prevent poisoning from rate-limited responses
+    if (data.items.length > 0) {
+        cache.set(cacheKey, "", data);
+    }
+    else {
+        debug(MODULE, `Skipping cache for empty search result (possible rate limit artifact)`);
+    }
+    return data;
+}
+// ── REST-based search functions ──
+/**
+ * Fetch issues from maintained repos using REST API (no Search API quota).
+ *
+ * Checks each repo for recent push activity and star threshold,
+ * then fetches open issues via `GET /repos/{owner}/{repo}/issues`.
+ * Falls back to the caller to use Search API if this doesn't yield enough.
+ */
+export async function fetchIssuesFromMaintainedRepos(octokit, repos, minStars, maxResults) {
+    const items = [];
+    for (const repoFullName of repos) {
+        if (items.length >= maxResults * 3)
+            break;
+        const [owner, repo] = repoFullName.split("/");
+        if (!owner || !repo)
+            continue;
         try {
-            const { data } = await octokit.search.issuesAndPullRequests(params);
-            return data;
+            const { data: repoData } = await octokit.repos.get({ owner, repo });
+            if (!repoData.pushed_at)
+                continue;
+            const pushedAt = new Date(repoData.pushed_at);
+            const thirtyDaysAgo = new Date();
+            thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+            if (pushedAt < thirtyDaysAgo)
+                continue;
+            if ((repoData.stargazers_count ?? 0) < minStars)
+                continue;
+            if (repoData.archived)
+                continue;
+            const { data: issues } = await octokit.issues.listForRepo({
+                owner,
+                repo,
+                state: "open",
+                sort: "created",
+                direction: "desc",
+                per_page: 5,
+            });
+            // Filter out pull requests and assigned issues (REST endpoint returns both)
+            const realIssues = issues.filter((i) => !i.pull_request && !i.assignee);
+            for (const issue of realIssues) {
+                items.push({
+                    html_url: issue.html_url,
+                    repository_url: `https://api.github.com/repos/${repoFullName}`,
+                    updated_at: issue.updated_at ?? "",
+                    title: issue.title,
+                    labels: issue.labels,
+                });
+            }
+            await sleep(INTER_QUERY_DELAY_MS);
         }
-        finally {
-            // Always record the call — failed requests still consume GitHub rate limit points
-            tracker.recordCall();
+        catch (error) {
+            if (getHttpStatusCode(error) === 401)
+                throw error;
+            if (isRateLimitError(error)) {
+                warn(MODULE, `Rate limit hit fetching issues from ${repoFullName}:`, errorMessage(error));
+                break;
+            }
+            warn(MODULE, `Error fetching issues from ${repoFullName}:`, errorMessage(error));
         }
-    });
+    }
+    return items;
 }
 // ── Search infrastructure ──
+/**
+ * Fetch open issues from known repos using REST API (no Search API quota).
+ * Used by Phase 0 (merged-PR repos) and Phase 1 (starred repos).
+ *
+ * Instead of the Search API (`octokit.search.issuesAndPullRequests`), this
+ * calls `GET /repos/{owner}/{repo}/issues` which counts against the much
+ * larger Core API rate limit and avoids consuming the scarce Search quota.
+ */
+export async function fetchIssuesFromKnownRepos(octokit, vetter, repos, labels, maxResults, priority, filterFn) {
+    const candidates = [];
+    let failedRepos = 0;
+    let rateLimitFailures = 0;
+    for (let i = 0; i < repos.length; i++) {
+        if (candidates.length >= maxResults)
+            break;
+        // Delay between repos to avoid REST secondary rate limits
+        if (i > 0)
+            await sleep(INTER_QUERY_DELAY_MS);
+        const repoFullName = repos[i];
+        const [owner, repo] = repoFullName.split("/");
+        try {
+            const response = await octokit.issues.listForRepo({
+                owner,
+                repo,
+                state: "open",
+                sort: "created",
+                direction: "desc",
+                per_page: 5,
+                ...(labels.length > 0 ? { labels: labels.join(",") } : {}),
+            });
+            // Filter out pull requests (REST issues endpoint returns both) and assigned issues
+            const issuesOnly = response.data.filter((item) => !("pull_request" in item) && !item.assignee);
+            const mapped = issuesOnly.map((issue) => ({
+                html_url: issue.html_url,
+                repository_url: `https://api.github.com/repos/${repoFullName}`,
+                updated_at: issue.updated_at ?? "",
+                title: issue.title,
+                labels: issue.labels,
+            }));
+            if (mapped.length > 0) {
+                const filtered = filterFn(mapped);
+                if (filtered.length > 0) {
+                    const remainingNeeded = maxResults - candidates.length;
+                    const { candidates: vetted, rateLimitHit: vetRateLimitHit } = await vetter.vetIssuesParallel(filtered
+                        .slice(0, remainingNeeded * 2)
+                        .map((item) => item.html_url), remainingNeeded, priority);
+                    candidates.push(...vetted);
+                    if (vetRateLimitHit)
+                        rateLimitFailures++;
+                }
+            }
+        }
+        catch (error) {
+            if (getHttpStatusCode(error) === 401)
+                throw error;
+            failedRepos++;
+            if (isRateLimitError(error)) {
+                rateLimitFailures++;
+            }
+            warn(MODULE, `Error fetching issues from ${repoFullName}:`, errorMessage(error));
+        }
+    }
+    const allReposFailed = failedRepos === repos.length && repos.length > 0;
+    const rateLimitHit = rateLimitFailures > 0;
+    if (allReposFailed) {
+        warn(MODULE, `All ${repos.length} repo(s) failed for ${priority} phase. ` +
+            `This may indicate a systemic issue (rate limit, auth, network).`);
+    }
+    return { candidates, allReposFailed, rateLimitHit };
+}
 /**
  * Search across chunked labels with deduplication.
  *

package/dist/core/types.d.ts

@@ -122,3 +122,10 @@ export interface ClosedPRRecord {
     closedAt: string;
     repo: string;
 }
+/** Record of an open PR for state contribution. */
+export interface OpenPRRecord {
+    url: string;
+    title: string;
+    openedAt: string;
+    repo: string;
+}

package/dist/index.d.ts

@@ -15,8 +15,8 @@
  * @packageDocumentation
  */
 export { createScout, OssScout } from "./scout.js";
-export type { ScoutConfig, SearchOptions, SearchResult, IssueCandidate, MergedPRRecord, ClosedPRRecord, RepoScoreUpdate, ProjectHealth, SearchPriority, CheckResult, VetListOptions, VetListResult, VetListEntry, VetListSummary, } from "./core/types.js";
-export type { ScoutState, ScoutPreferences, RepoScore, RepoSignals, IssueVettingResult, ContributionGuidelines, TrackedIssue, IssueScope, ProjectCategory, StoredMergedPR, StoredClosedPR, SearchStrategy, SkippedIssue, } from "./core/schemas.js";
+export type { ScoutConfig, SearchOptions, SearchResult, IssueCandidate, MergedPRRecord, ClosedPRRecord, OpenPRRecord, RepoScoreUpdate, ProjectHealth, SearchPriority, CheckResult, VetListOptions, VetListResult, VetListEntry, VetListSummary, } from "./core/types.js";
+export type { ScoutState, ScoutPreferences, RepoScore, RepoSignals, IssueVettingResult, ContributionGuidelines, TrackedIssue, IssueScope, ProjectCategory, StoredMergedPR, StoredClosedPR, StoredOpenPR, SearchStrategy, SkippedIssue, } from "./core/schemas.js";
 export { ScoutStateSchema, ScoutPreferencesSchema, RepoScoreSchema, IssueScopeSchema, ProjectCategorySchema, SearchStrategySchema, SkippedIssueSchema, } from "./core/schemas.js";
 export { requireGitHubToken, getGitHubToken } from "./core/utils.js";
 export { IssueDiscovery } from "./core/issue-discovery.js";

package/dist/scout.d.ts

@@ -6,7 +6,7 @@
  */
 import type { ScoutStateReader } from "./core/issue-vetting.js";
 import type { ScoutState, ScoutPreferences, RepoScore, SavedCandidate, SkippedIssue } from "./core/schemas.js";
-import type { ScoutConfig, SearchOptions, SearchResult, IssueCandidate, MergedPRRecord, ClosedPRRecord, RepoScoreUpdate, ProjectCategory, VetListOptions, VetListResult } from "./core/types.js";
+import type { ScoutConfig, SearchOptions, SearchResult, IssueCandidate, MergedPRRecord, ClosedPRRecord, OpenPRRecord, RepoScoreUpdate, ProjectCategory, VetListOptions, VetListResult } from "./core/types.js";
 import { GistStateStore } from "./core/gist-state-store.js";
 /**
  * Create an OssScout instance.
@@ -59,6 +59,7 @@ export declare class OssScout implements ScoutStateReader {
     vetList(options?: VetListOptions): Promise<VetListResult>;
     private classifyVetResult;
     getReposWithMergedPRs(): string[];
+    getReposWithOpenPRs(): string[];
     getStarredRepos(): string[];
     getProjectCategories(): ProjectCategory[];
     getRepoScore(repo: string): number | null;
@@ -75,6 +76,11 @@ export declare class OssScout implements ScoutStateReader {
      * Record that a PR was closed without merge.
      */
     recordClosedPR(pr: ClosedPRRecord): void;
+    /**
+     * Record that a PR is currently open in this repo.
+     * Open PRs signal active engagement even when nothing is merged yet.
+     */
+    recordOpenPR(pr: OpenPRRecord): void;
     /**
      * Update repo score with observed signals.
      */

package/dist/scout.js

@@ -236,6 +236,18 @@ export class OssScout {
             .sort((a, b) => b[1] - a[1])
             .map(([repo]) => repo);
     }
+    getReposWithOpenPRs() {
+        const repoCounts = new Map();
+        for (const pr of this.state.openPRs ?? []) {
+            const repo = extractRepoFromUrl(pr.url);
+            if (repo) {
+                repoCounts.set(repo, (repoCounts.get(repo) ?? 0) + 1);
+            }
+        }
+        return [...repoCounts.entries()]
+            .sort((a, b) => b[1] - a[1])
+            .map(([repo]) => repo);
+    }
     getStarredRepos() {
         return this.state.starredRepos;
     }
@@ -285,6 +297,20 @@ export class OssScout {
         this.updateRepoScoreFromPRs(pr.repo);
         this.dirty = true;
     }
+    /**
+     * Record that a PR is currently open in this repo.
+     * Open PRs signal active engagement even when nothing is merged yet.
+     */
+    recordOpenPR(pr) {
+        const existing = this.state.openPRs ?? [];
+        if (existing.some((p) => p.url === pr.url))
+            return;
+        this.state.openPRs = [
+            ...existing,
+            { url: pr.url, title: pr.title, openedAt: pr.openedAt },
+        ];
+        this.dirty = true;
+    }
     /**
      * Update repo score with observed signals.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oss-scout/core",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Personalized GitHub issue finder with multi-strategy search, deep vetting, and viability scoring — CLI, library, MCP server, and Claude Code plugin",
   "type": "module",
   "bin": {
@@ -21,16 +21,6 @@
     "!dist/**/*.map",
     "!dist/core/test-utils.*"
   ],
-  "scripts": {
-    "build": "tsc",
-    "bundle": "esbuild src/cli.ts --bundle --platform=node --target=node20 --format=cjs --minify --sourcemap --outfile=dist/cli.bundle.cjs",
-    "start": "tsx src/cli.ts",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:coverage": "vitest run --coverage",
-    "test:watch": "vitest",
-    "prepublishOnly": "pnpm run build && pnpm run bundle"
-  },
   "keywords": [
     "open-source",
     "github",
@@ -65,10 +55,20 @@
   },
   "devDependencies": {
     "@types/node": "^25.5.0",
-    "@vitest/coverage-v8": "^4.1.0",
+    "@vitest/coverage-v8": "^4.1.4",
     "esbuild": "^0.27.4",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
-    "vitest": "^4.1.0"
+    "vite": "^8.0.5",
+    "vitest": "^4.1.4"
+  },
+  "scripts": {
+    "build": "tsc",
+    "bundle": "esbuild src/cli.ts --bundle --platform=node --target=node20 --format=cjs --minify --sourcemap --outfile=dist/cli.bundle.cjs",
+    "start": "tsx src/cli.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest"
   }
-}
+}

package/dist/core/concurrency.d.ts

@@ -1,6 +0,0 @@
-/**
- * Runs a worker pool that processes items with bounded concurrency.
- * N workers consume from a shared index. On any worker error, remaining
- * workers are aborted via a shared flag and the error is propagated.
- */
-export declare function runWorkerPool<T>(items: T[], worker: (item: T) => Promise<void>, concurrency: number): Promise<void>;

package/dist/core/concurrency.js

@@ -1,25 +0,0 @@
-/**
- * Runs a worker pool that processes items with bounded concurrency.
- * N workers consume from a shared index. On any worker error, remaining
- * workers are aborted via a shared flag and the error is propagated.
- */
-export async function runWorkerPool(items, worker, concurrency) {
-    let index = 0;
-    let aborted = false;
-    const poolWorker = async () => {
-        while (index < items.length) {
-            if (aborted)
-                break;
-            const item = items[index++];
-            try {
-                await worker(item);
-            }
-            catch (err) {
-                aborted = true;
-                throw err;
-            }
-        }
-    };
-    const workerCount = Math.min(concurrency, items.length);
-    await Promise.all(Array.from({ length: workerCount }, () => poolWorker()));
-}