@oss-autopilot/core 0.41.0

package/dist/commands/search.js

@@ -0,0 +1,74 @@
+/**
+ * Search command
+ * Searches for new issues to work on
+ */
+import { IssueDiscovery, getGitHubToken, getStateManager, DEFAULT_CONFIG } from '../core/index.js';
+import { outputJson } from '../formatters/json.js';
+export async function runSearch(options) {
+    // Token is guaranteed by the preAction hook in cli.ts for non-LOCAL_ONLY_COMMANDS.
+    const token = getGitHubToken();
+    const discovery = new IssueDiscovery(token);
+    if (!options.json) {
+        console.log(`\n🔍 Searching for issues (max ${options.maxResults})...\n`);
+    }
+    const candidates = await discovery.searchIssues({ maxResults: options.maxResults });
+    if (options.json) {
+        const stateManager = getStateManager();
+        const { config } = stateManager.getState();
+        const excludedRepos = config.excludeRepos || [];
+        const aiPolicyBlocklist = config.aiPolicyBlocklist ?? DEFAULT_CONFIG.aiPolicyBlocklist ?? [];
+        const searchOutput = {
+            candidates: candidates.map((c) => {
+                const repoScoreRecord = stateManager.getRepoScore(c.issue.repo);
+                return {
+                    issue: {
+                        repo: c.issue.repo,
+                        number: c.issue.number,
+                        title: c.issue.title,
+                        url: c.issue.url,
+                        labels: c.issue.labels,
+                    },
+                    recommendation: c.recommendation,
+                    reasonsToApprove: c.reasonsToApprove,
+                    reasonsToSkip: c.reasonsToSkip,
+                    searchPriority: c.searchPriority,
+                    viabilityScore: c.viabilityScore,
+                    repoScore: repoScoreRecord
+                        ? {
+                            score: repoScoreRecord.score,
+                            mergedPRCount: repoScoreRecord.mergedPRCount,
+                            closedWithoutMergeCount: repoScoreRecord.closedWithoutMergeCount,
+                            isResponsive: repoScoreRecord.signals?.isResponsive ?? false,
+                            lastMergedAt: repoScoreRecord.lastMergedAt,
+                        }
+                        : undefined,
+                };
+            }),
+            excludedRepos,
+            aiPolicyBlocklist,
+        };
+        if (discovery.rateLimitWarning) {
+            searchOutput.rateLimitWarning = discovery.rateLimitWarning;
+        }
+        outputJson(searchOutput);
+    }
+    else {
+        if (candidates.length === 0) {
+            if (discovery.rateLimitWarning) {
+                console.warn(`\n⚠ ${discovery.rateLimitWarning}\n`);
+            }
+            else {
+                console.log('No matching issues found.');
+            }
+            return;
+        }
+        if (discovery.rateLimitWarning) {
+            console.warn(`\n⚠ ${discovery.rateLimitWarning}\n`);
+        }
+        console.log(`Found ${candidates.length} candidates:\n`);
+        for (const candidate of candidates) {
+            console.log(discovery.formatCandidate(candidate));
+            console.log('---');
+        }
+    }
+}

package/dist/commands/setup.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Setup command
+ * Interactive setup / configuration
+ */
+interface SetupOptions {
+    reset?: boolean;
+    set?: string[];
+    json?: boolean;
+}
+interface CheckSetupOptions {
+    json?: boolean;
+}
+export declare function runSetup(options: SetupOptions): Promise<void>;
+export declare function runCheckSetup(options: CheckSetupOptions): Promise<void>;
+export {};

package/dist/commands/setup.js

@@ -0,0 +1,276 @@
+/**
+ * Setup command
+ * Interactive setup / configuration
+ */
+import { getStateManager, DEFAULT_CONFIG } from '../core/index.js';
+import { outputJson } from '../formatters/json.js';
+import { validateGitHubUsername } from './validation.js';
+export async function runSetup(options) {
+    const stateManager = getStateManager();
+    const config = stateManager.getState().config;
+    // Handle --set mode: apply settings directly
+    if (options.set && options.set.length > 0) {
+        const results = {};
+        for (const setting of options.set) {
+            const [key, ...valueParts] = setting.split('=');
+            const value = valueParts.join('=');
+            switch (key) {
+                case 'username':
+                    validateGitHubUsername(value);
+                    stateManager.updateConfig({ githubUsername: value });
+                    results[key] = value;
+                    break;
+                case 'maxActivePRs':
+                    stateManager.updateConfig({ maxActivePRs: parseInt(value) || 10 });
+                    results[key] = value;
+                    break;
+                case 'dormantDays':
+                    stateManager.updateConfig({ dormantThresholdDays: parseInt(value) || 30 });
+                    results[key] = value;
+                    break;
+                case 'approachingDays':
+                    stateManager.updateConfig({ approachingDormantDays: parseInt(value) || 25 });
+                    results[key] = value;
+                    break;
+                case 'languages':
+                    stateManager.updateConfig({ languages: value.split(',').map((l) => l.trim()) });
+                    results[key] = value;
+                    break;
+                case 'labels':
+                    stateManager.updateConfig({ labels: value.split(',').map((l) => l.trim()) });
+                    results[key] = value;
+                    break;
+                case 'showHealthCheck':
+                    stateManager.updateConfig({ showHealthCheck: value !== 'false' });
+                    results[key] = value !== 'false' ? 'true' : 'false';
+                    break;
+                case 'squashByDefault':
+                    if (value === 'ask') {
+                        stateManager.updateConfig({ squashByDefault: 'ask' });
+                        results[key] = 'ask';
+                    }
+                    else {
+                        stateManager.updateConfig({ squashByDefault: value !== 'false' });
+                        results[key] = value !== 'false' ? 'true' : 'false';
+                    }
+                    break;
+                case 'minStars': {
+                    const parsed = parseInt(value);
+                    stateManager.updateConfig({ minStars: isNaN(parsed) ? 50 : parsed });
+                    results[key] = value;
+                    break;
+                }
+                case 'includeDocIssues':
+                    stateManager.updateConfig({ includeDocIssues: value === 'true' });
+                    results[key] = value === 'true' ? 'true' : 'false';
+                    break;
+                case 'aiPolicyBlocklist': {
+                    const entries = value
+                        .split(',')
+                        .map((r) => r.trim())
+                        .filter(Boolean);
+                    const valid = [];
+                    const invalid = [];
+                    for (const entry of entries) {
+                        const normalized = entry.replace(/\s+/g, '');
+                        if (/^[a-zA-Z0-9._-]+\/[a-zA-Z0-9._-]+$/.test(normalized)) {
+                            valid.push(normalized);
+                        }
+                        else {
+                            invalid.push(entry);
+                        }
+                    }
+                    if (invalid.length > 0) {
+                        if (!options.json) {
+                            console.warn(`Warning: Skipping invalid entries (expected "owner/repo" format): ${invalid.join(', ')}`);
+                        }
+                        results['aiPolicyBlocklist_invalidEntries'] = invalid.join(', ');
+                    }
+                    if (valid.length === 0 && entries.length > 0) {
+                        if (!options.json) {
+                            console.warn('Warning: All entries were invalid. Blocklist not updated.');
+                        }
+                        results[key] = '(all entries invalid)';
+                        break;
+                    }
+                    stateManager.updateConfig({ aiPolicyBlocklist: valid });
+                    results[key] = valid.length > 0 ? valid.join(', ') : '(empty)';
+                    break;
+                }
+                case 'complete':
+                    if (value === 'true') {
+                        stateManager.markSetupComplete();
+                        results[key] = 'true';
+                    }
+                    break;
+                default:
+                    if (!options.json) {
+                        console.warn(`Unknown setting: ${key}`);
+                    }
+            }
+        }
+        stateManager.save();
+        if (options.json) {
+            outputJson({ success: true, settings: results });
+        }
+        else {
+            for (const [key, value] of Object.entries(results)) {
+                console.log(`✓ ${key}: ${value}`);
+            }
+        }
+        return;
+    }
+    // Show setup status
+    if (config.setupComplete && !options.reset) {
+        if (options.json) {
+            outputJson({
+                setupComplete: true,
+                config: {
+                    githubUsername: config.githubUsername,
+                    maxActivePRs: config.maxActivePRs,
+                    dormantThresholdDays: config.dormantThresholdDays,
+                    approachingDormantDays: config.approachingDormantDays,
+                    languages: config.languages,
+                    labels: config.labels,
+                },
+            });
+        }
+        else {
+            console.log('\n⚙️  OSS Autopilot Setup\n');
+            console.log('✓ Setup already complete!\n');
+            console.log('Current settings:');
+            console.log(`  GitHub username:    ${config.githubUsername || '(not set)'}`);
+            console.log(`  Max active PRs:     ${config.maxActivePRs}`);
+            console.log(`  Dormant threshold:  ${config.dormantThresholdDays} days`);
+            console.log(`  Approaching dormant: ${config.approachingDormantDays} days`);
+            console.log(`  Languages:          ${config.languages.join(', ')}`);
+            console.log(`  Labels:             ${config.labels.join(', ')}`);
+            console.log(`\nRun 'setup --reset' to reconfigure.`);
+        }
+        return;
+    }
+    // Output setup prompts
+    if (options.json) {
+        outputJson({
+            setupRequired: true,
+            prompts: [
+                {
+                    setting: 'username',
+                    prompt: 'What is your GitHub username?',
+                    current: config.githubUsername || null,
+                    required: true,
+                    type: 'string',
+                },
+                {
+                    setting: 'maxActivePRs',
+                    prompt: 'How many PRs do you want to work on at once?',
+                    current: config.maxActivePRs,
+                    default: 10,
+                    type: 'number',
+                },
+                {
+                    setting: 'dormantDays',
+                    prompt: 'After how many days of inactivity should a PR be considered dormant?',
+                    current: config.dormantThresholdDays,
+                    default: 30,
+                    type: 'number',
+                },
+                {
+                    setting: 'approachingDays',
+                    prompt: 'At how many days should we warn about approaching dormancy?',
+                    current: config.approachingDormantDays,
+                    default: 25,
+                    type: 'number',
+                },
+                {
+                    setting: 'languages',
+                    prompt: 'What programming languages do you want to contribute to?',
+                    current: config.languages,
+                    default: ['typescript', 'javascript'],
+                    type: 'list',
+                },
+                {
+                    setting: 'labels',
+                    prompt: 'What issue labels should we search for?',
+                    current: config.labels,
+                    default: ['good first issue', 'help wanted'],
+                    type: 'list',
+                },
+                {
+                    setting: 'aiPolicyBlocklist',
+                    prompt: 'Repos with anti-AI contribution policies to block (owner/repo, comma-separated)?',
+                    current: config.aiPolicyBlocklist ?? DEFAULT_CONFIG.aiPolicyBlocklist,
+                    default: ['matplotlib/matplotlib'],
+                    type: 'list',
+                },
+            ],
+        });
+    }
+    else {
+        console.log('\n⚙️  OSS Autopilot Setup\n');
+        console.log('SETUP_REQUIRED');
+        console.log('---');
+        console.log('Please configure the following settings:\n');
+        console.log('SETTING: username');
+        console.log('PROMPT: What is your GitHub username?');
+        console.log(`CURRENT: ${config.githubUsername || '(not set)'}`);
+        console.log('REQUIRED: true');
+        console.log('');
+        console.log('SETTING: maxActivePRs');
+        console.log('PROMPT: How many PRs do you want to work on at once?');
+        console.log(`CURRENT: ${config.maxActivePRs}`);
+        console.log('DEFAULT: 10');
+        console.log('TYPE: number');
+        console.log('');
+        console.log('SETTING: dormantDays');
+        console.log('PROMPT: After how many days of inactivity should a PR be considered dormant?');
+        console.log(`CURRENT: ${config.dormantThresholdDays}`);
+        console.log('DEFAULT: 30');
+        console.log('TYPE: number');
+        console.log('');
+        console.log('SETTING: approachingDays');
+        console.log('PROMPT: At how many days should we warn about approaching dormancy?');
+        console.log(`CURRENT: ${config.approachingDormantDays}`);
+        console.log('DEFAULT: 25');
+        console.log('TYPE: number');
+        console.log('');
+        console.log('SETTING: languages');
+        console.log('PROMPT: What programming languages do you want to contribute to? (comma-separated)');
+        console.log(`CURRENT: ${config.languages.join(', ')}`);
+        console.log('DEFAULT: typescript, javascript');
+        console.log('TYPE: list');
+        console.log('');
+        console.log('SETTING: labels');
+        console.log('PROMPT: What issue labels should we search for? (comma-separated)');
+        console.log(`CURRENT: ${config.labels.join(', ')}`);
+        console.log('DEFAULT: good first issue, help wanted');
+        console.log('TYPE: list');
+        console.log('');
+        console.log('SETTING: aiPolicyBlocklist');
+        console.log('PROMPT: Repos with anti-AI contribution policies to block? (owner/repo, comma-separated)');
+        console.log(`CURRENT: ${(config.aiPolicyBlocklist ?? DEFAULT_CONFIG.aiPolicyBlocklist ?? []).join(', ')}`);
+        console.log('DEFAULT: matplotlib/matplotlib');
+        console.log('TYPE: list');
+        console.log('');
+        console.log('---');
+        console.log('END_SETUP_PROMPTS');
+    }
+}
+export async function runCheckSetup(options) {
+    const stateManager = getStateManager();
+    if (options.json) {
+        outputJson({
+            setupComplete: stateManager.isSetupComplete(),
+            username: stateManager.getState().config.githubUsername,
+        });
+    }
+    else {
+        if (stateManager.isSetupComplete()) {
+            console.log('SETUP_COMPLETE');
+            console.log(`username=${stateManager.getState().config.githubUsername}`);
+        }
+        else {
+            console.log('SETUP_INCOMPLETE');
+        }
+    }
+}

package/dist/commands/shelve.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Shelve/Unshelve commands
+ * Manages shelving PRs to exclude them from capacity and actionable issues.
+ * Shelved PRs are auto-unshelved when a maintainer engages.
+ */
+import { PR_URL_PATTERN } from './validation.js';
+interface ShelveCommandOptions {
+    prUrl: string;
+    json?: boolean;
+}
+export { PR_URL_PATTERN };
+export declare function runShelve(options: ShelveCommandOptions): Promise<void>;
+export declare function runUnshelve(options: ShelveCommandOptions): Promise<void>;

package/dist/commands/shelve.js

@@ -0,0 +1,49 @@
+/**
+ * Shelve/Unshelve commands
+ * Manages shelving PRs to exclude them from capacity and actionable issues.
+ * Shelved PRs are auto-unshelved when a maintainer engages.
+ */
+import { getStateManager } from '../core/index.js';
+import { outputJson } from '../formatters/json.js';
+import { PR_URL_PATTERN, validateGitHubUrl, validateUrl } from './validation.js';
+// Re-export for backward compatibility with tests
+export { PR_URL_PATTERN };
+export async function runShelve(options) {
+    validateUrl(options.prUrl);
+    validateGitHubUrl(options.prUrl, PR_URL_PATTERN, 'PR', options.json);
+    const stateManager = getStateManager();
+    const added = stateManager.shelvePR(options.prUrl);
+    if (added) {
+        stateManager.save();
+    }
+    if (options.json) {
+        outputJson({ shelved: added, url: options.prUrl });
+    }
+    else if (added) {
+        console.log(`Shelved: ${options.prUrl}`);
+        console.log('This PR is now excluded from capacity and actionable issues.');
+        console.log('It will auto-unshelve if a maintainer engages.');
+    }
+    else {
+        console.log('PR is already shelved.');
+    }
+}
+export async function runUnshelve(options) {
+    validateUrl(options.prUrl);
+    validateGitHubUrl(options.prUrl, PR_URL_PATTERN, 'PR', options.json);
+    const stateManager = getStateManager();
+    const removed = stateManager.unshelvePR(options.prUrl);
+    if (removed) {
+        stateManager.save();
+    }
+    if (options.json) {
+        outputJson({ unshelved: removed, url: options.prUrl });
+    }
+    else if (removed) {
+        console.log(`Unshelved: ${options.prUrl}`);
+        console.log('This PR is now active again.');
+    }
+    else {
+        console.log('PR was not shelved.');
+    }
+}

package/dist/commands/snooze.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Snooze/Unsnooze commands
+ * Manages snoozing CI failure notifications for PRs with known upstream/infrastructure issues.
+ * Snoozed PRs are excluded from the actionable CI failure list until the snooze expires.
+ */
+interface SnoozeCommandOptions {
+    prUrl: string;
+    reason: string;
+    days?: number;
+    json?: boolean;
+}
+interface UnsnoozeCommandOptions {
+    prUrl: string;
+    json?: boolean;
+}
+export declare function runSnooze(options: SnoozeCommandOptions): Promise<void>;
+export declare function runUnsnooze(options: UnsnoozeCommandOptions): Promise<void>;
+export {};

package/dist/commands/snooze.js

@@ -0,0 +1,83 @@
+/**
+ * Snooze/Unsnooze commands
+ * Manages snoozing CI failure notifications for PRs with known upstream/infrastructure issues.
+ * Snoozed PRs are excluded from the actionable CI failure list until the snooze expires.
+ */
+import { getStateManager } from '../core/index.js';
+import { outputJson, outputJsonError } from '../formatters/json.js';
+import { PR_URL_PATTERN, validateGitHubUrl, validateUrl, validateMessage } from './validation.js';
+const DEFAULT_SNOOZE_DAYS = 7;
+export async function runSnooze(options) {
+    validateUrl(options.prUrl);
+    validateGitHubUrl(options.prUrl, PR_URL_PATTERN, 'PR', options.json);
+    validateMessage(options.reason);
+    const days = options.days ?? DEFAULT_SNOOZE_DAYS;
+    if (!Number.isFinite(days) || days <= 0) {
+        if (options.json) {
+            outputJsonError('Snooze duration must be a positive number of days.');
+        }
+        else {
+            console.error('Error: Snooze duration must be a positive number of days.');
+        }
+        process.exit(1);
+    }
+    try {
+        const stateManager = getStateManager();
+        const added = stateManager.snoozePR(options.prUrl, options.reason, days);
+        if (added) {
+            stateManager.save();
+        }
+        const snoozeInfo = stateManager.getSnoozeInfo(options.prUrl);
+        if (options.json) {
+            outputJson({
+                snoozed: added,
+                url: options.prUrl,
+                days,
+                reason: options.reason,
+                expiresAt: snoozeInfo?.expiresAt,
+            });
+        }
+        else if (added) {
+            console.log(`Snoozed: ${options.prUrl}`);
+            console.log(`Reason: ${options.reason}`);
+            console.log(`Duration: ${days} day${days === 1 ? '' : 's'}`);
+            console.log(`Expires: ${snoozeInfo?.expiresAt ? new Date(snoozeInfo.expiresAt).toLocaleString() : 'unknown'}`);
+            console.log('CI failure notifications are now muted for this PR.');
+        }
+        else {
+            console.log('PR is already snoozed.');
+            if (snoozeInfo) {
+                console.log(`Expires: ${new Date(snoozeInfo.expiresAt).toLocaleString()}`);
+            }
+        }
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (options.json) {
+            outputJsonError(`Snooze failed: ${msg}`);
+        }
+        else {
+            console.error(`Error: Snooze failed: ${msg}`);
+        }
+        process.exit(1);
+    }
+}
+export async function runUnsnooze(options) {
+    validateUrl(options.prUrl);
+    validateGitHubUrl(options.prUrl, PR_URL_PATTERN, 'PR', options.json);
+    const stateManager = getStateManager();
+    const removed = stateManager.unsnoozePR(options.prUrl);
+    if (removed) {
+        stateManager.save();
+    }
+    if (options.json) {
+        outputJson({ unsnoozed: removed, url: options.prUrl });
+    }
+    else if (removed) {
+        console.log(`Unsnoozed: ${options.prUrl}`);
+        console.log('CI failure notifications are active again for this PR.');
+    }
+    else {
+        console.log('PR was not snoozed.');
+    }
+}

package/dist/commands/startup.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Startup command
+ * Combines all pre-flight checks into a single CLI invocation:
+ * auth check, setup check, daily fetch, dashboard generation, version detection, issue list detection.
+ *
+ * Replaces the ~100-line inline bash script in commands/oss.md with a single
+ * `node cli.bundle.cjs startup --json` call, reducing UI noise in Claude Code.
+ */
+import { type IssueListInfo } from '../formatters/json.js';
+interface StartupOptions {
+    json?: boolean;
+}
+/**
+ * Parse issueListPath from a config file's YAML frontmatter.
+ * Returns the path string or undefined if not found.
+ */
+export declare function parseIssueListPathFromConfig(configContent: string): string | undefined;
+/**
+ * Count available and completed items in an issue list file.
+ * Available: list items (- [) NOT struck through or marked Done.
+ * Completed: list items that ARE struck through or marked Done.
+ */
+export declare function countIssueListItems(content: string): {
+    availableCount: number;
+    completedCount: number;
+};
+/**
+ * Detect an issue list file from config or known paths.
+ * Returns IssueListInfo or undefined if no list found.
+ */
+export declare function detectIssueList(): IssueListInfo | undefined;
+export declare function runStartup(options: StartupOptions): Promise<void>;
+export {};