@oss-autopilot/core 0.41.0

package/dist/commands/comments.js

@@ -0,0 +1,311 @@
+/**
+ * Comments, Post, and Claim commands
+ * Handles GitHub comment interactions
+ */
+import { getStateManager, getOctokit, parseGitHubUrl, formatRelativeTime, getGitHubToken } from '../core/index.js';
+import { paginateAll } from '../core/pagination.js';
+import { outputJson, outputJsonError } from '../formatters/json.js';
+import { validateUrl, validateMessage } from './validation.js';
+export async function runComments(options) {
+    validateUrl(options.prUrl);
+    // Token is guaranteed by the preAction hook in cli.ts for non-LOCAL_ONLY_COMMANDS.
+    const token = getGitHubToken();
+    const stateManager = getStateManager();
+    const octokit = getOctokit(token);
+    // Parse PR URL
+    const parsed = parseGitHubUrl(options.prUrl);
+    if (!parsed || parsed.type !== 'pull') {
+        if (options.json) {
+            outputJsonError('Invalid PR URL format');
+        }
+        else {
+            console.error('Invalid PR URL format');
+        }
+        process.exit(1);
+    }
+    const { owner, repo, number: pull_number } = parsed;
+    // Get PR details
+    const { data: pr } = await octokit.pulls.get({ owner, repo, pull_number });
+    // Get review comments (inline code comments)
+    const reviewComments = await paginateAll((page) => octokit.pulls.listReviewComments({
+        owner,
+        repo,
+        pull_number,
+        per_page: 100,
+        page,
+    }));
+    // Get issue comments (general PR discussion)
+    const issueComments = await paginateAll((page) => octokit.issues.listComments({
+        owner,
+        repo,
+        issue_number: pull_number,
+        per_page: 100,
+        page,
+    }));
+    // Get reviews
+    const reviews = await paginateAll((page) => octokit.pulls.listReviews({
+        owner,
+        repo,
+        pull_number,
+        per_page: 100,
+        page,
+    }));
+    // Filter out own comments, optionally show bots
+    const username = stateManager.getState().config.githubUsername;
+    const filterComment = (c) => {
+        if (!c.user)
+            return false;
+        if (c.user.login === username)
+            return false;
+        if (c.user.type === 'Bot' && !options.showBots)
+            return false;
+        return true;
+    };
+    const relevantReviewComments = reviewComments
+        .filter(filterComment)
+        .sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+    const relevantIssueComments = issueComments
+        .filter(filterComment)
+        .sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+    const relevantReviews = reviews
+        .filter((r) => filterComment(r) && r.body && r.body.trim())
+        .sort((a, b) => new Date(b.submitted_at || 0).getTime() - new Date(a.submitted_at || 0).getTime());
+    if (options.json) {
+        outputJson({
+            pr: {
+                title: pr.title,
+                state: pr.state,
+                mergeable: pr.mergeable,
+                head: pr.head.ref,
+                base: pr.base.ref,
+                url: pr.html_url,
+            },
+            reviews: relevantReviews.map((r) => ({
+                user: r.user?.login,
+                state: r.state,
+                body: r.body,
+                submittedAt: r.submitted_at,
+            })),
+            reviewComments: relevantReviewComments.map((c) => ({
+                user: c.user?.login,
+                body: c.body,
+                path: c.path,
+                createdAt: c.created_at,
+            })),
+            issueComments: relevantIssueComments.map((c) => ({
+                user: c.user?.login,
+                body: c.body,
+                createdAt: c.created_at,
+            })),
+            summary: {
+                reviewCount: relevantReviews.length,
+                inlineCommentCount: relevantReviewComments.length,
+                discussionCommentCount: relevantIssueComments.length,
+            },
+        });
+        return;
+    }
+    // Text output
+    console.log(`\n💬 Fetching comments for: ${options.prUrl}\n`);
+    console.log(`## ${pr.title}\n`);
+    console.log(`**Status:** ${pr.state} | **Mergeable:** ${pr.mergeable ?? 'checking...'}`);
+    console.log(`**Branch:** ${pr.head.ref} → ${pr.base.ref}`);
+    console.log(`**URL:** ${pr.html_url}\n`);
+    if (relevantReviews.length > 0) {
+        console.log('### Reviews (newest first)\n');
+        for (const review of relevantReviews) {
+            const state = review.state === 'APPROVED' ? '✅' : review.state === 'CHANGES_REQUESTED' ? '❌' : '💬';
+            const time = review.submitted_at ? formatRelativeTime(review.submitted_at) : '';
+            console.log(`${state} **@${review.user?.login}** (${review.state}) - ${time}`);
+            if (review.body) {
+                console.log(`> ${review.body.split('\n').join('\n> ')}\n`);
+            }
+        }
+    }
+    if (relevantReviewComments.length > 0) {
+        console.log('### Inline Comments (newest first)\n');
+        for (const comment of relevantReviewComments) {
+            const time = formatRelativeTime(comment.created_at);
+            console.log(`**@${comment.user?.login}** on \`${comment.path}\` - ${time}`);
+            console.log(`> ${comment.body.split('\n').join('\n> ')}`);
+            if (comment.diff_hunk) {
+                console.log(`\`\`\`diff\n${comment.diff_hunk.slice(-500)}\n\`\`\``);
+            }
+            console.log('');
+        }
+    }
+    if (relevantIssueComments.length > 0) {
+        console.log('### Discussion (newest first)\n');
+        for (const comment of relevantIssueComments) {
+            const time = formatRelativeTime(comment.created_at);
+            console.log(`**@${comment.user?.login}** - ${time}`);
+            console.log(`> ${comment.body?.split('\n').join('\n> ')}\n`);
+        }
+    }
+    if (relevantReviewComments.length === 0 && relevantIssueComments.length === 0 && relevantReviews.length === 0) {
+        console.log('No comments from other users.\n');
+    }
+    console.log('---');
+    console.log(`**Summary:** ${relevantReviews.length} reviews, ${relevantReviewComments.length} inline comments, ${relevantIssueComments.length} discussion comments`);
+}
+export async function runPost(options) {
+    validateUrl(options.url);
+    // Token is guaranteed by the preAction hook in cli.ts for non-LOCAL_ONLY_COMMANDS.
+    const token = getGitHubToken();
+    let message = options.message;
+    // Read from stdin if specified
+    if (options.stdin) {
+        const chunks = [];
+        for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+        }
+        message = Buffer.concat(chunks).toString('utf-8').trim();
+    }
+    if (!message) {
+        if (options.json) {
+            outputJsonError('No message provided');
+        }
+        else {
+            console.error('Error: No message provided');
+        }
+        process.exit(1);
+    }
+    try {
+        validateMessage(message);
+    }
+    catch (error) {
+        if (options.json) {
+            outputJsonError(error instanceof Error ? error.message : 'Invalid message');
+        }
+        else {
+            console.error(`Error: ${error instanceof Error ? error.message : 'Invalid message'}`);
+        }
+        process.exit(1);
+    }
+    // Parse URL
+    const parsed = parseGitHubUrl(options.url);
+    if (!parsed) {
+        if (options.json) {
+            outputJsonError('Invalid GitHub URL format');
+        }
+        else {
+            console.error('Invalid GitHub URL format');
+        }
+        process.exit(1);
+    }
+    const { owner, repo, number } = parsed;
+    const octokit = getOctokit(token);
+    if (!options.json) {
+        console.log('\n📝 Posting comment to:', options.url);
+        console.log('---');
+        console.log(message);
+        console.log('---\n');
+    }
+    try {
+        const { data: comment } = await octokit.issues.createComment({
+            owner,
+            repo,
+            issue_number: number,
+            body: message,
+        });
+        if (options.json) {
+            outputJson({
+                commentUrl: comment.html_url,
+                url: options.url,
+            });
+        }
+        else {
+            console.log('✅ Comment posted successfully!');
+            console.log(`   ${comment.html_url}`);
+        }
+    }
+    catch (error) {
+        if (options.json) {
+            outputJsonError(error instanceof Error ? error.message : 'Unknown error');
+        }
+        else {
+            console.error('❌ Failed to post comment:', error instanceof Error ? error.message : error);
+        }
+        process.exit(1);
+    }
+}
+export async function runClaim(options) {
+    validateUrl(options.issueUrl);
+    // Token is guaranteed by the preAction hook in cli.ts for non-LOCAL_ONLY_COMMANDS.
+    const token = getGitHubToken();
+    // Default claim message or custom
+    const message = options.message || "Hi! I'd like to work on this issue. Could you assign it to me?";
+    try {
+        validateMessage(message);
+    }
+    catch (error) {
+        if (options.json) {
+            outputJsonError(error instanceof Error ? error.message : 'Invalid message');
+        }
+        else {
+            console.error(`Error: ${error instanceof Error ? error.message : 'Invalid message'}`);
+        }
+        process.exit(1);
+    }
+    // Parse URL
+    const parsed = parseGitHubUrl(options.issueUrl);
+    if (!parsed || parsed.type !== 'issues') {
+        if (options.json) {
+            outputJsonError('Invalid issue URL format (must be an issue, not a PR)');
+        }
+        else {
+            console.error('Invalid issue URL format (must be an issue, not a PR)');
+        }
+        process.exit(1);
+    }
+    const { owner, repo, number } = parsed;
+    if (!options.json) {
+        console.log('\n🙋 Claiming issue:', options.issueUrl);
+        console.log('---');
+        console.log(message);
+        console.log('---\n');
+    }
+    const octokit = getOctokit(token);
+    try {
+        const { data: comment } = await octokit.issues.createComment({
+            owner,
+            repo,
+            issue_number: number,
+            body: message,
+        });
+        // Add to tracked issues
+        const stateManager = getStateManager();
+        stateManager.addIssue({
+            id: number,
+            url: options.issueUrl,
+            repo: `${owner}/${repo}`,
+            number,
+            title: '(claimed)',
+            status: 'claimed',
+            labels: [],
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            vetted: false,
+        });
+        stateManager.save();
+        if (options.json) {
+            outputJson({
+                commentUrl: comment.html_url,
+                issueUrl: options.issueUrl,
+            });
+        }
+        else {
+            console.log('✅ Issue claimed!');
+            console.log(`   ${comment.html_url}`);
+        }
+    }
+    catch (error) {
+        if (options.json) {
+            outputJsonError(error instanceof Error ? error.message : 'Unknown error');
+        }
+        else {
+            console.error('❌ Failed to claim issue:', error instanceof Error ? error.message : error);
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/config.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Config command
+ * Shows or updates configuration
+ */
+interface ConfigOptions {
+    key?: string;
+    value?: string;
+    json?: boolean;
+}
+export declare function runConfig(options: ConfigOptions): Promise<void>;
+export {};

package/dist/commands/config.js

@@ -0,0 +1,82 @@
+/**
+ * Config command
+ * Shows or updates configuration
+ */
+import { getStateManager } from '../core/index.js';
+import { outputJson, outputJsonError } from '../formatters/json.js';
+function exitWithError(msg, json) {
+    if (json) {
+        outputJsonError(msg);
+    }
+    else {
+        console.error(msg);
+    }
+    process.exit(1);
+}
+export async function runConfig(options) {
+    const stateManager = getStateManager();
+    const currentConfig = stateManager.getState().config;
+    if (!options.key) {
+        // Show current config
+        if (options.json) {
+            outputJson({ config: currentConfig });
+        }
+        else {
+            console.log('\n⚙️ Current Configuration:\n');
+            console.log(JSON.stringify(currentConfig, null, 2));
+        }
+        return;
+    }
+    if (!options.value) {
+        exitWithError('Value required', options.json);
+    }
+    const value = options.value;
+    // Handle specific config keys
+    switch (options.key) {
+        case 'username':
+            stateManager.updateConfig({ githubUsername: value });
+            break;
+        case 'add-language':
+            if (!currentConfig.languages.includes(value)) {
+                stateManager.updateConfig({ languages: [...currentConfig.languages, value] });
+            }
+            break;
+        case 'add-label':
+            if (!currentConfig.labels.includes(value)) {
+                stateManager.updateConfig({ labels: [...currentConfig.labels, value] });
+            }
+            break;
+        case 'exclude-repo': {
+            const parts = value.split('/');
+            if (parts.length !== 2 || !parts[0] || !parts[1]) {
+                exitWithError(`Invalid repo format "${value}". Use "owner/repo" format. To exclude an entire org, use: config exclude-org ${value}`, options.json);
+            }
+            const valueLower = value.toLowerCase();
+            if (!currentConfig.excludeRepos.some((r) => r.toLowerCase() === valueLower)) {
+                stateManager.updateConfig({ excludeRepos: [...currentConfig.excludeRepos, value] });
+                stateManager.cleanupExcludedData([value], []);
+            }
+            break;
+        }
+        case 'exclude-org': {
+            if (value.includes('/')) {
+                exitWithError(`Invalid org name "${value}". Use just the org name (e.g., "facebook"), not "owner/repo" format. To exclude a specific repo, use: config exclude-repo ${value}`, options.json);
+            }
+            const currentOrgs = currentConfig.excludeOrgs ?? [];
+            if (!currentOrgs.some((o) => o.toLowerCase() === value.toLowerCase())) {
+                stateManager.updateConfig({ excludeOrgs: [...currentOrgs, value] });
+                stateManager.cleanupExcludedData([], [value]);
+            }
+            break;
+        }
+        default:
+            exitWithError(`Unknown config key: ${options.key}`, options.json);
+    }
+    stateManager.save();
+    if (options.json) {
+        outputJson({ success: true, key: options.key, value });
+    }
+    else {
+        console.log(`Set ${options.key} to: ${value}`);
+    }
+}

package/dist/commands/daily.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Daily check command
+ * Fetches all open PRs fresh from GitHub (v2: no PR-level state tracking),
+ * generates a digest, and updates repo scores and analytics in local state.
+ *
+ * Domain logic lives in src/core/daily-logic.ts; this file is a thin
+ * orchestration layer that wires up the phases and handles I/O.
+ */
+import { type DailyOutput } from '../formatters/json.js';
+export { computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatBriefSummary, formatSummary, printDigest, CRITICAL_STATUSES, } from '../core/index.js';
+interface DailyOptions {
+    json?: boolean;
+}
+export declare function runDaily(options: DailyOptions): Promise<void>;
+/**
+ * Core daily check logic, extracted for reuse by the startup command.
+ * Fetches all open PRs, updates state, and returns structured output.
+ *
+ * Returns a deduplicated DailyOutput where category arrays contain PR URLs
+ * instead of full objects (#287). Full PR objects are in digest.openPRs only.
+ *
+ * Orchestrates five named phases:
+ *   1. fetchPRData        — fetch open PRs, merged/closed counts, issues
+ *   2. updateRepoScores   — update signals, star counts, trust in state
+ *   3. updateAnalytics    — store monthly chart data
+ *   4. partitionPRs       — expire snoozes, shelve/unshelve, generate digest
+ *   5. generateDigestOutput — capacity, dismiss filter, action menu assembly
+ */
+export declare function executeDailyCheck(token: string): Promise<DailyOutput>;