@oss-autopilot/core 0.41.0

package/dist/core/issue-filtering.js

@@ -0,0 +1,103 @@
+/**
+ * Issue Filtering — pure functions for filtering and spam detection on search results.
+ *
+ * Extracted from issue-discovery.ts (#356) to isolate filtering logic:
+ * label farming detection, doc-only filtering, per-repo caps, templated title detection.
+ */
+/** Labels that indicate documentation-only issues (#105). */
+export const DOC_ONLY_LABELS = new Set(['documentation', 'docs', 'typo', 'spelling']);
+/**
+ * Check if an issue's labels are ALL documentation-related (#105).
+ * Issues with mixed labels (e.g., "good first issue" + "documentation") pass through.
+ * Issues with no labels are not considered doc-only.
+ */
+export function isDocOnlyIssue(item) {
+    if (!item.labels || !Array.isArray(item.labels) || item.labels.length === 0)
+        return false;
+    const labelNames = item.labels.map((l) => (typeof l === 'string' ? l : l.name || '').toLowerCase());
+    // Filter out empty label names before checking
+    const nonEmptyLabels = labelNames.filter((n) => n.length > 0);
+    if (nonEmptyLabels.length === 0)
+        return false;
+    return nonEmptyLabels.every((n) => DOC_ONLY_LABELS.has(n));
+}
+/** Known beginner-type label names used to detect label-farming repos (#97). */
+export const BEGINNER_LABELS = new Set([
+    'good first issue',
+    'hacktoberfest',
+    'easy',
+    'up-for-grabs',
+    'first-timers-only',
+    'beginner-friendly',
+    'beginner',
+    'starter',
+    'newbie',
+    'low-hanging-fruit',
+    'community',
+]);
+/** Check if a single issue has an excessive number of beginner labels (>= 5). */
+export function isLabelFarming(item) {
+    if (!item.labels || !Array.isArray(item.labels))
+        return false;
+    const labelNames = item.labels.map((l) => (typeof l === 'string' ? l : l.name || '').toLowerCase());
+    const beginnerCount = labelNames.filter((n) => BEGINNER_LABELS.has(n)).length;
+    return beginnerCount >= 5;
+}
+/** Detect mass-created issue titles like "Add Trivia Question 61" or "Create Entry #5". */
+export function hasTemplatedTitle(title) {
+    if (!title)
+        return false;
+    // Matches "<anything> <category-noun> <number>" where category nouns are typical
+    // of mass-created templated issues. This avoids false positives on legitimate titles
+    // like "Add support for Python 3" or "Implement RFC 7231" which lack category nouns.
+    return /^.+\s+(question|fact|point|item|task|entry|post|challenge|exercise|example|problem|tip|recipe|snippet)\s+#?\d+$/i.test(title);
+}
+/**
+ * Batch-analyze search items to detect label-farming repositories (#97).
+ * Returns a Set of repo full names (owner/repo) that appear to be spam.
+ *
+ * A repo is flagged if:
+ * - ANY single issue has >= 5 beginner labels (strong individual signal), OR
+ * - It has >= 3 issues with templated titles (batch signal)
+ */
+export function detectLabelFarmingRepos(items) {
+    const spamRepos = new Set();
+    const repoSpamCounts = new Map();
+    for (const item of items) {
+        const repoFullName = item.repository_url.split('/').slice(-2).join('/');
+        // Strong signal: single issue with 5+ beginner labels
+        if (isLabelFarming(item)) {
+            spamRepos.add(repoFullName);
+            continue;
+        }
+        // Weaker signal: templated title
+        if (item.title && hasTemplatedTitle(item.title)) {
+            repoSpamCounts.set(repoFullName, (repoSpamCounts.get(repoFullName) || 0) + 1);
+        }
+    }
+    // Flag repos with 3+ templated-title issues
+    for (const [repo, count] of repoSpamCounts) {
+        if (count >= 3) {
+            spamRepos.add(repo);
+        }
+    }
+    return spamRepos;
+}
+/**
+ * Apply per-repo cap to candidates (#105).
+ * Keeps at most `maxPerRepo` issues from any single repo.
+ * Maintains the existing sort order — first N from each repo are kept,
+ * excess issues from over-represented repos are dropped.
+ */
+export function applyPerRepoCap(candidates, maxPerRepo) {
+    const repoCounts = new Map();
+    const kept = [];
+    for (const c of candidates) {
+        const count = repoCounts.get(c.issue.repo) || 0;
+        if (count < maxPerRepo) {
+            kept.push(c);
+            repoCounts.set(c.issue.repo, count + 1);
+        }
+    }
+    return kept;
+}

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

@@ -0,0 +1,40 @@
+/**
+ * Issue Scoring — pure functions for computing viability scores and quality bonuses.
+ *
+ * Extracted from issue-discovery.ts (#356) to isolate scoring logic.
+ */
+/**
+ * Calculate a quality bonus based on repo star and fork counts (#98).
+ * Stars: <50 → 0, 50-499 → +3, 500-4999 → +5, 5000+ → +8
+ * Forks: 50+ → +2, 500+ → +4
+ * Natural max is 12 (8 stars + 4 forks).
+ */
+export declare function calculateRepoQualityBonus(stargazersCount: number, forksCount: number): number;
+export interface ViabilityScoreParams {
+    repoScore: number | null;
+    hasExistingPR: boolean;
+    isClaimed: boolean;
+    clearRequirements: boolean;
+    hasContributionGuidelines: boolean;
+    issueUpdatedAt: string;
+    closedWithoutMergeCount: number;
+    mergedPRCount: number;
+    orgHasMergedPRs: boolean;
+    repoQualityBonus?: number;
+}
+/**
+ * Calculate viability score for an issue (0-100 scale)
+ * Scoring:
+ * - Base: 50 points
+ * - +repoScore*2 (up to +20 for score of 10)
+ * - +repoQualityBonus (up to +12 for established repos, from star/fork counts) (#98)
+ * - +15 for merged PR in this repo (direct proven relationship) (#99)
+ * - +15 for clear requirements (clarity)
+ * - +15 for freshness (recently updated)
+ * - +10 for contribution guidelines
+ * - +5 for org affinity (merged PRs in same org)
+ * - -30 if existing PR
+ * - -20 if claimed
+ * - -15 if closed-without-merge history with no merges
+ */
+export declare function calculateViabilityScore(params: ViabilityScoreParams): number;

package/dist/core/issue-scoring.js

@@ -0,0 +1,92 @@
+/**
+ * Issue Scoring — pure functions for computing viability scores and quality bonuses.
+ *
+ * Extracted from issue-discovery.ts (#356) to isolate scoring logic.
+ */
+import { daysBetween } from './utils.js';
+/**
+ * Calculate a quality bonus based on repo star and fork counts (#98).
+ * Stars: <50 → 0, 50-499 → +3, 500-4999 → +5, 5000+ → +8
+ * Forks: 50+ → +2, 500+ → +4
+ * Natural max is 12 (8 stars + 4 forks).
+ */
+export function calculateRepoQualityBonus(stargazersCount, forksCount) {
+    let bonus = 0;
+    // Star tiers
+    if (stargazersCount >= 5000)
+        bonus += 8;
+    else if (stargazersCount >= 500)
+        bonus += 5;
+    else if (stargazersCount >= 50)
+        bonus += 3;
+    // Fork tiers
+    if (forksCount >= 500)
+        bonus += 4;
+    else if (forksCount >= 50)
+        bonus += 2;
+    return bonus;
+}
+/**
+ * Calculate viability score for an issue (0-100 scale)
+ * Scoring:
+ * - Base: 50 points
+ * - +repoScore*2 (up to +20 for score of 10)
+ * - +repoQualityBonus (up to +12 for established repos, from star/fork counts) (#98)
+ * - +15 for merged PR in this repo (direct proven relationship) (#99)
+ * - +15 for clear requirements (clarity)
+ * - +15 for freshness (recently updated)
+ * - +10 for contribution guidelines
+ * - +5 for org affinity (merged PRs in same org)
+ * - -30 if existing PR
+ * - -20 if claimed
+ * - -15 if closed-without-merge history with no merges
+ */
+export function calculateViabilityScore(params) {
+    let score = 50; // Base score
+    // Add repo score contribution (up to +20)
+    if (params.repoScore !== null) {
+        score += params.repoScore * 2;
+    }
+    // Repo quality bonus from star/fork counts (#98, up to +12)
+    score += params.repoQualityBonus ?? 0;
+    // Merged PR bonus (+15) — direct proven relationship with this repo (#99)
+    if (params.mergedPRCount > 0) {
+        score += 15;
+    }
+    // Clarity bonus (+15)
+    if (params.clearRequirements) {
+        score += 15;
+    }
+    // Freshness bonus (+15 for issues updated within last 14 days)
+    const updatedAt = new Date(params.issueUpdatedAt);
+    const daysSinceUpdate = daysBetween(updatedAt);
+    if (daysSinceUpdate <= 14) {
+        score += 15;
+    }
+    else if (daysSinceUpdate <= 30) {
+        // Partial bonus for 15-30 days
+        score += Math.round(15 * (1 - (daysSinceUpdate - 14) / 16));
+    }
+    // Contribution guidelines bonus (+10)
+    if (params.hasContributionGuidelines) {
+        score += 10;
+    }
+    // Org affinity bonus (+5) — user has merged PRs in another repo under same org
+    if (params.orgHasMergedPRs) {
+        score += 5;
+    }
+    // Penalty for existing PR (-30)
+    if (params.hasExistingPR) {
+        score -= 30;
+    }
+    // Penalty for claimed issue (-20)
+    if (params.isClaimed) {
+        score -= 20;
+    }
+    // Penalty for closed-without-merge history with no successful merges (-15)
+    if (params.closedWithoutMergeCount > 0 && params.mergedPRCount === 0) {
+        score -= 15;
+    }
+    // Clamp to 0-100
+    return Math.max(0, Math.min(100, score));
+}

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

@@ -0,0 +1,49 @@
+/**
+ * Issue Vetting — checks individual issues for claimability, existing PRs,
+ * project health, contribution guidelines, and requirement clarity.
+ *
+ * Extracted from issue-discovery.ts (#356) to isolate vetting logic.
+ */
+import { Octokit } from '@octokit/rest';
+import { ContributionGuidelines, ProjectHealth, type SearchPriority, type IssueCandidate } from './types.js';
+import { getStateManager } from './state.js';
+/** Result of a vetting check that may be inconclusive due to API errors. */
+export interface CheckResult {
+    passed: boolean;
+    inconclusive?: boolean;
+    reason?: string;
+}
+export declare class IssueVetter {
+    private octokit;
+    private stateManager;
+    constructor(octokit: Octokit, stateManager: ReturnType<typeof getStateManager>);
+    /**
+     * Vet a specific issue — runs all checks and computes recommendation + viability score.
+     */
+    vetIssue(issueUrl: string): Promise<IssueCandidate>;
+    /**
+     * Vet multiple issues in parallel with concurrency limit
+     */
+    vetIssuesParallel(urls: string[], maxResults: number, priority?: SearchPriority): Promise<{
+        candidates: IssueCandidate[];
+        allFailed: boolean;
+        rateLimitHit: boolean;
+    }>;
+    /** Check if an error is a GitHub rate limit error (429 or rate-limit 403). */
+    static isRateLimitError(error: unknown): boolean;
+    checkNoExistingPR(owner: string, repo: string, issueNumber: number): Promise<CheckResult>;
+    /**
+     * Check how many merged PRs the authenticated user has in a repo.
+     * Uses GitHub Search API. Returns 0 on error (non-fatal).
+     */
+    checkUserMergedPRsInRepo(owner: string, repo: string): Promise<number>;
+    checkNotClaimed(owner: string, repo: string, issueNumber: number, commentCount: number): Promise<CheckResult>;
+    checkProjectHealth(owner: string, repo: string): Promise<ProjectHealth>;
+    fetchContributionGuidelines(owner: string, repo: string): Promise<ContributionGuidelines | undefined>;
+    parseContributionGuidelines(content: string): ContributionGuidelines;
+    analyzeRequirements(body: string): boolean;
+    /**
+     * Get the repo score from state, or return null if not evaluated
+     */
+    private getRepoScore;
+}