@oss-autopilot/core 0.41.0

package/dist/core/issue-vetting.js

@@ -0,0 +1,536 @@
+/**
+ * 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 { paginateAll } from './pagination.js';
+import { parseGitHubUrl, daysBetween } from './utils.js';
+import { ValidationError } from './errors.js';
+import { warn } from './logger.js';
+import { getHttpCache, cachedRequest } from './http-cache.js';
+import { calculateRepoQualityBonus, calculateViabilityScore } from './issue-scoring.js';
+const MODULE = 'issue-vetting';
+// Concurrency limit for parallel API calls
+const MAX_CONCURRENT_REQUESTS = 5;
+// Cache for contribution guidelines (expires after 1 hour, max 100 entries)
+const guidelinesCache = new Map();
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+const CACHE_MAX_SIZE = 100;
+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);
+        }
+    }
+}
+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.
+     */
+    async vetIssue(issueUrl) {
+        // 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,
+        });
+        // Run all vetting checks in parallel
+        const [existingPRCheck, claimCheck, projectHealth, contributionGuidelines, userMergedPRCount] = await Promise.all([
+            this.checkNoExistingPR(owner, repo, number),
+            this.checkNotClaimed(owner, repo, number, ghIssue.comments),
+            this.checkProjectHealth(owner, repo),
+            this.fetchContributionGuidelines(owner, repo),
+            this.checkUserMergedPRsInRepo(owner, repo),
+        ]);
+        const noExistingPR = existingPRCheck.passed;
+        const notClaimed = claimCheck.passed;
+        // Analyze issue quality
+        const clearRequirements = this.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 repoScoreRecord = this.stateManager.getRepoScore(repoFullName);
+        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)`);
+        }
+        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,
+        });
+        const starredRepos = this.stateManager.getStarredRepos();
+        let searchPriority = 'normal';
+        if (effectiveMergedCount > 0) {
+            searchPriority = 'merged_pr';
+        }
+        else if (starredRepos.includes(repoFullName)) {
+            searchPriority = 'starred';
+        }
+        return {
+            issue: trackedIssue,
+            vettingResult,
+            projectHealth,
+            recommendation,
+            reasonsToSkip,
+            reasonsToApprove,
+            viabilityScore,
+            searchPriority,
+        };
+    }
+    /**
+     * Vet multiple issues in parallel with concurrency limit
+     */
+    async vetIssuesParallel(urls, maxResults, priority) {
+        const candidates = [];
+        const pending = [];
+        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 (IssueVetter.isRateLimitError(error)) {
+                    rateLimitFailures++;
+                }
+                warn(MODULE, `Error vetting issue ${url}:`, error instanceof Error ? error.message : error);
+            });
+            pending.push(task);
+            // Limit concurrency
+            if (pending.length >= MAX_CONCURRENT_REQUESTS) {
+                // Wait for at least one to complete, then remove it
+                const completed = await Promise.race(pending.map((p, i) => p.then(() => i)));
+                pending.splice(completed, 1);
+            }
+        }
+        // Wait for remaining
+        await Promise.allSettled(pending);
+        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 };
+    }
+    /** Check if an error is a GitHub rate limit error (429 or rate-limit 403). */
+    static isRateLimitError(error) {
+        const status = error?.status;
+        if (status === 429)
+            return true;
+        if (status === 403) {
+            const msg = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+            return msg.includes('rate limit');
+        }
+        return false;
+    }
+    async checkNoExistingPR(owner, repo, issueNumber) {
+        try {
+            // Search for PRs that mention this issue
+            const { data } = await this.octokit.search.issuesAndPullRequests({
+                q: `repo:${owner}/${repo} is:pr ${issueNumber}`,
+                per_page: 5,
+            });
+            // Also check timeline for linked PRs
+            const timeline = await paginateAll((page) => this.octokit.issues.listEventsForTimeline({
+                owner,
+                repo,
+                issue_number: issueNumber,
+                per_page: 100,
+                page,
+            }));
+            const linkedPRs = timeline.filter((event) => {
+                const e = event;
+                return e.event === 'cross-referenced' && e.source?.issue?.pull_request;
+            });
+            return { passed: data.total_count === 0 && linkedPRs.length === 0 };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            warn(MODULE, `Failed to check for existing PRs on ${owner}/${repo}#${issueNumber}: ${errorMessage}. Assuming no existing PR.`);
+            return { passed: true, inconclusive: true, reason: errorMessage };
+        }
+    }
+    /**
+     * Check how many merged PRs the authenticated user has in a repo.
+     * Uses GitHub Search API. Returns 0 on error (non-fatal).
+     */
+    async checkUserMergedPRsInRepo(owner, repo) {
+        try {
+            // Use @me to search as the authenticated user
+            const { data } = await this.octokit.search.issuesAndPullRequests({
+                q: `repo:${owner}/${repo} is:pr is:merged author:@me`,
+                per_page: 1, // We only need total_count
+            });
+            return data.total_count;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            warn(MODULE, `Could not check merged PRs in ${owner}/${repo}: ${errorMessage}. Defaulting to 0.`);
+            return 0;
+        }
+    }
+    async checkNotClaimed(owner, repo, issueNumber, commentCount) {
+        if (commentCount === 0)
+            return { passed: true };
+        try {
+            // Paginate through all comments (up to 100)
+            const comments = await this.octokit.paginate(this.octokit.issues.listComments, {
+                owner,
+                repo,
+                issue_number: issueNumber,
+                per_page: 100,
+            }, (response) => response.data);
+            // Limit to last 100 comments to avoid excessive processing
+            const recentComments = comments.slice(-100);
+            // Look for claiming phrases
+            const claimPhrases = [
+                "i'm working on this",
+                'i am working on this',
+                "i'll take this",
+                'i will take this',
+                'working on it',
+                "i'd like to work on",
+                'i would like to work on',
+                'can i work on',
+                'may i work on',
+                'assigned to me',
+                "i'm on it",
+                "i'll submit a pr",
+                'i will submit a pr',
+                'working on a fix',
+                'working on a pr',
+            ];
+            for (const comment of recentComments) {
+                const body = (comment.body || '').toLowerCase();
+                if (claimPhrases.some((phrase) => body.includes(phrase))) {
+                    return { passed: false };
+                }
+            }
+            return { passed: true };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            warn(MODULE, `Failed to check claim status on ${owner}/${repo}#${issueNumber}: ${errorMessage}. Assuming not claimed.`);
+            return { passed: true, inconclusive: true, reason: errorMessage };
+        }
+    }
+    async checkProjectHealth(owner, repo) {
+        try {
+            // Get repo info (with ETag caching — repo metadata changes infrequently)
+            const cache = getHttpCache();
+            const url = `/repos/${owner}/${repo}`;
+            const repoData = await cachedRequest(cache, url, (headers) => this.octokit.repos.get({ owner, repo, headers }));
+            // Get recent commits
+            const { data: commits } = await this.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 this.octokit.actions.listRepoWorkflows({
+                    owner,
+                    repo,
+                    per_page: 1,
+                });
+                if (workflows.total_count > 0) {
+                    ciStatus = 'passing'; // Assume passing if workflows exist
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                warn(MODULE, `Failed to check CI status for ${owner}/${repo}: ${errorMessage}. 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,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            warn(MODULE, `Error checking project health for ${owner}/${repo}: ${errorMessage}`);
+            return {
+                repo: `${owner}/${repo}`,
+                lastCommitAt: '',
+                daysSinceLastCommit: 999,
+                openIssuesCount: 0,
+                avgIssueResponseDays: 0,
+                ciStatus: 'unknown',
+                isActive: false,
+                checkFailed: true,
+                failureReason: errorMessage,
+            };
+        }
+    }
+    async fetchContributionGuidelines(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'];
+        for (const file of filesToCheck) {
+            try {
+                const { data } = await this.octokit.repos.getContent({
+                    owner,
+                    repo,
+                    path: file,
+                });
+                if ('content' in data) {
+                    const content = Buffer.from(data.content, 'base64').toString('utf-8');
+                    const guidelines = this.parseContributionGuidelines(content);
+                    // Cache the result and prune if needed
+                    guidelinesCache.set(cacheKey, { guidelines, fetchedAt: Date.now() });
+                    pruneCache();
+                    return guidelines;
+                }
+            }
+            catch (error) {
+                // File not found is expected; only log unexpected errors
+                if (error instanceof Error && !error.message.includes('404') && !error.message.includes('Not Found')) {
+                    warn(MODULE, `Unexpected error fetching ${file} from ${owner}/${repo}: ${error.message}`);
+                }
+            }
+        }
+        // Cache the negative result too and prune if needed
+        guidelinesCache.set(cacheKey, { guidelines: undefined, fetchedAt: Date.now() });
+        pruneCache();
+        return undefined;
+    }
+    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;
+    }
+    analyzeRequirements(body) {
+        if (!body || body.length < 50)
+            return false;
+        // Check for clear structure
+        const hasSteps = /\d+\.|[-*]\s/.test(body);
+        const hasCodeBlock = /```/.test(body);
+        const hasExpectedBehavior = /expect|should|must|want/i.test(body);
+        // Must have at least two indicators of clarity
+        const indicators = [hasSteps, hasCodeBlock, hasExpectedBehavior, body.length > 200];
+        return indicators.filter(Boolean).length >= 2;
+    }
+    /**
+     * 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/logger.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Lightweight debug logger for oss-autopilot.
+ * Activated by the global --debug CLI flag.
+ *
+ * All debug/warn output goes to stderr so it never contaminates
+ * the --json stdout contract.
+ */
+export declare function enableDebug(): void;
+export declare function isDebugEnabled(): boolean;
+/**
+ * Log a debug message. Only outputs when --debug is enabled.
+ */
+export declare function debug(module: string, message: string, ...args: unknown[]): void;
+/**
+ * Log a warning. Always outputs.
+ */
+export declare function warn(module: string, message: string, ...args: unknown[]): void;
+/**
+ * Time an async operation and log duration in debug mode.
+ */
+export declare function timed<T>(module: string, label: string, fn: () => Promise<T>): Promise<T>;

package/dist/core/logger.js

@@ -0,0 +1,49 @@
+/**
+ * Lightweight debug logger for oss-autopilot.
+ * Activated by the global --debug CLI flag.
+ *
+ * All debug/warn output goes to stderr so it never contaminates
+ * the --json stdout contract.
+ */
+let debugEnabled = false;
+export function enableDebug() {
+    debugEnabled = true;
+}
+export function isDebugEnabled() {
+    return debugEnabled;
+}
+/**
+ * Log a debug message. Only outputs when --debug is enabled.
+ */
+export function debug(module, message, ...args) {
+    if (!debugEnabled)
+        return;
+    const timestamp = new Date().toISOString();
+    console.error(`[${timestamp}] [DEBUG] [${module}] ${message}`, ...args);
+}
+/**
+ * Log a warning. Always outputs.
+ */
+export function warn(module, message, ...args) {
+    const timestamp = new Date().toISOString();
+    console.error(`[${timestamp}] [WARN] [${module}] ${message}`, ...args);
+}
+/**
+ * Time an async operation and log duration in debug mode.
+ */
+export async function timed(module, label, fn) {
+    if (!debugEnabled)
+        return fn();
+    const start = performance.now();
+    try {
+        const result = await fn();
+        const duration = (performance.now() - start).toFixed(0);
+        debug(module, `${label} completed in ${duration}ms`);
+        return result;
+    }
+    catch (err) {
+        const duration = (performance.now() - start).toFixed(0);
+        debug(module, `${label} failed after ${duration}ms`);
+        throw err;
+    }
+}

package/dist/core/maintainer-analysis.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Maintainer Analysis - Action hint extraction from maintainer comments.
+ * Extracted from PRMonitor to isolate maintainer-comment-related logic (#263).
+ */
+import { MaintainerActionHint, ReviewDecision } from './types.js';
+/**
+ * Extract action hints from maintainer comments using keyword matching.
+ * Returns an array of hints about what the maintainer is asking for.
+ */
+export declare function extractMaintainerActionHints(commentBody: string | undefined, reviewDecision: ReviewDecision): MaintainerActionHint[];

package/dist/core/maintainer-analysis.js

@@ -0,0 +1,59 @@
+/**
+ * Maintainer Analysis - Action hint extraction from maintainer comments.
+ * Extracted from PRMonitor to isolate maintainer-comment-related logic (#263).
+ */
+/**
+ * Extract action hints from maintainer comments using keyword matching.
+ * Returns an array of hints about what the maintainer is asking for.
+ */
+export function extractMaintainerActionHints(commentBody, reviewDecision) {
+    const hints = [];
+    if (reviewDecision === 'changes_requested') {
+        hints.push('changes_requested');
+    }
+    if (!commentBody)
+        return hints;
+    const lower = commentBody.toLowerCase();
+    // Demo/screenshot requests
+    const demoKeywords = [
+        'screenshot',
+        'demo',
+        'recording',
+        'screen recording',
+        'before/after',
+        'before and after',
+        'gif',
+        'video',
+        'screencast',
+        'show me',
+        'can you show',
+    ];
+    if (demoKeywords.some((kw) => lower.includes(kw))) {
+        hints.push('demo_requested');
+    }
+    // Test requests
+    const testKeywords = [
+        'add test',
+        'test coverage',
+        'unit test',
+        'missing test',
+        'add a test',
+        'write test',
+        'needs test',
+        'need test',
+    ];
+    if (testKeywords.some((kw) => lower.includes(kw))) {
+        hints.push('tests_requested');
+    }
+    // Documentation requests
+    const docKeywords = ['documentation', 'readme', 'jsdoc', 'docstring', 'add docs', 'update docs', 'document this'];
+    if (docKeywords.some((kw) => lower.includes(kw))) {
+        hints.push('docs_requested');
+    }
+    // Rebase requests
+    const rebaseKeywords = ['rebase', 'merge conflict', 'out of date', 'behind main', 'behind master'];
+    if (rebaseKeywords.some((kw) => lower.includes(kw))) {
+        hints.push('rebase_requested');
+    }
+    return hints;
+}