gitpadi 2.0.7 → 2.1.2

package/src/commands/apply-for-issue.ts

@@ -0,0 +1,452 @@
+// commands/apply-for-issue.ts — Browse open issues and apply to work on them
+//
+// Like Drips/Algora/Gitcoin — but from your terminal.
+// Finds "good first issue" / "help wanted" issues, shows them in a table,
+// lets you pick one and post a polished application comment.
+// Optionally forks + branches immediately after applying.
+
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import * as fs from 'fs';
+import { getOctokit, getOwner, getRepo, getAuthenticatedUser, forkRepo } from '../core/github.js';
+import { execFileSync } from 'child_process';
+
+const dim = chalk.dim;
+const cyan = chalk.cyan;
+const yellow = chalk.yellow;
+const green = chalk.green;
+const bold = chalk.bold;
+const magenta = chalk.magenta;
+
+// Labels that signal "open to external contributors"
+const BOUNTY_LABELS = [
+    'good first issue',
+    'help wanted',
+    'bounty',
+    'hacktoberfest',
+    'up for grabs',
+    'first-timers-only',
+    'easy',
+    'beginner',
+    'contributions welcome',
+    'open to pr',
+];
+
+function truncate(text: string, max: number): string {
+    return text.length <= max ? text : text.slice(0, max - 1) + '…';
+}
+
+function labelStr(labels: any[]): string {
+    return labels
+        .map((l: any) => (typeof l === 'string' ? l : l.name || ''))
+        .filter(Boolean)
+        .map((l: string) => dim(`[${l}]`))
+        .join(' ');
+}
+
+function diffDays(dateStr: string): number {
+    return Math.floor((Date.now() - new Date(dateStr).getTime()) / 86_400_000);
+}
+
+// ── Main export ─────────────────────────────────────────────────────────────
+
+export async function browseAndApply(targetOwner?: string, targetRepo?: string): Promise<void> {
+    const octokit = getOctokit();
+    let owner = targetOwner || getOwner();
+    let repo = targetRepo || getRepo();
+
+    // If no repo context, ask the user for a target
+    if (!owner || !repo) {
+        const { target } = await inquirer.prompt([{
+            type: 'input',
+            name: 'target',
+            message: bold('Enter repo or issue URL (owner/repo or github.com/…):'),
+            validate: (v: string) => v.trim().length > 0 || 'Required',
+        }]);
+
+        const parsed = parseTarget(target.trim());
+        owner = parsed.owner;
+        repo = parsed.repo;
+
+        // If they pasted a direct issue URL, skip the browse step
+        if (parsed.issue) {
+            return applyToIssue(owner, repo, parsed.issue);
+        }
+    }
+
+    console.log();
+    const spinner = ora(`  Fetching open issues for ${cyan(`${owner}/${repo}`)}…`).start();
+
+    let issues: any[] = [];
+    try {
+        // First try bounty/help-wanted labels, fall back to all open issues
+        const { data } = await octokit.issues.listForRepo({
+            owner, repo,
+            state: 'open',
+            per_page: 100,
+            sort: 'updated',
+            direction: 'desc',
+        });
+
+        // Filter out pull requests (GitHub returns them in issues endpoint)
+        const realIssues = data.filter((i: any) => !i.pull_request);
+
+        // Prefer issues with contributor-friendly labels
+        const prioritised = realIssues.filter((i: any) =>
+            i.labels.some((l: any) => BOUNTY_LABELS.includes((typeof l === 'string' ? l : l.name || '').toLowerCase()))
+        );
+
+        issues = prioritised.length > 0 ? prioritised : realIssues;
+        spinner.succeed(`  Found ${issues.length} open issue(s)`);
+    } catch (e: any) {
+        spinner.fail(`  Could not fetch issues: ${e.message}`);
+        return;
+    }
+
+    if (issues.length === 0) {
+        console.log(yellow('\n  No open issues found.'));
+        return;
+    }
+
+    // Show issue list
+    console.log();
+    const choices = issues.slice(0, 30).map((issue: any) => {
+        const age = diffDays(issue.updated_at);
+        const ageStr = age === 0 ? dim('today') : age === 1 ? dim('1d ago') : dim(`${age}d ago`);
+        const labels = labelStr(issue.labels);
+        const title = truncate(issue.title, 52);
+        return {
+            name: `  ${cyan(`#${issue.number}`)} ${bold(title)} ${labels} ${ageStr}`,
+            value: issue.number,
+            short: `#${issue.number} ${issue.title}`,
+        };
+    });
+
+    (choices as any[]).push(
+        new inquirer.Separator(dim('  ──────────────────────────────────────')),
+        { name: `  ${dim('🔍  Enter issue number manually')}`, value: '__manual__', short: 'manual' },
+        { name: `  ${dim('⬅   Back')}`, value: '__back__', short: 'back' },
+    );
+
+    const { issueNumber } = await inquirer.prompt([{
+        type: 'list',
+        name: 'issueNumber',
+        message: bold(`Choose an issue to apply for (${owner}/${repo}):`),
+        choices,
+        pageSize: 15,
+    }]);
+
+    if (issueNumber === '__back__') return;
+
+    if (issueNumber === '__manual__') {
+        const { num } = await inquirer.prompt([{
+            type: 'input',
+            name: 'num',
+            message: bold('Issue number:'),
+            validate: (v: string) => /^\d+$/.test(v.trim()) || 'Enter a number',
+        }]);
+        return applyToIssue(owner, repo, parseInt(num));
+    }
+
+    return applyToIssue(owner, repo, issueNumber);
+}
+
+// ── Apply to a specific issue ────────────────────────────────────────────────
+
+export async function applyToIssue(owner: string, repo: string, issueNumber: number): Promise<void> {
+    const octokit = getOctokit();
+    const spinner = ora(`  Loading issue #${issueNumber}…`).start();
+
+    let issue: any;
+    try {
+        const { data } = await octokit.issues.get({ owner, repo, issue_number: issueNumber });
+        issue = data;
+        spinner.succeed();
+    } catch (e: any) {
+        spinner.fail(`  Issue not found: ${e.message}`);
+        return;
+    }
+
+    // Show the issue
+    console.log();
+    console.log(`  ${cyan(bold(`#${issue.number}`))} — ${bold(issue.title)}`);
+    console.log(`  ${dim('Labels:')} ${labelStr(issue.labels) || dim('none')}`);
+    if (issue.assignees?.length > 0) {
+        const names = issue.assignees.map((a: any) => `@${a.login}`).join(', ');
+        console.log(`  ${yellow(`⚠  Already assigned to: ${names}`)}`);
+    }
+    console.log();
+    if (issue.body) {
+        const preview = issue.body.replace(/\r?\n/g, ' ').trim();
+        console.log(`  ${dim(truncate(preview, 200))}`);
+        console.log();
+    }
+
+    // Check if already commented
+    const me = await getAuthenticatedUser();
+    const { data: existingComments } = await octokit.issues.listComments({
+        owner, repo, issue_number: issueNumber, per_page: 100,
+    });
+    const alreadyApplied = existingComments.some(
+        (c: any) => c.user?.login === me && /i('d| would| want| will)|assign.*me|let me|i can|i'm interested|claiming this/i.test(c.body || '')
+    );
+
+    if (alreadyApplied) {
+        console.log(yellow(`  ⚠  You've already applied for this issue.\n`));
+        const { cont } = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'cont',
+            message: 'Apply again anyway?',
+            default: false,
+        }]);
+        if (!cont) return;
+    }
+
+    // Pick application style
+    const { style } = await inquirer.prompt([{
+        type: 'list',
+        name: 'style',
+        message: bold('How would you like to apply?'),
+        choices: [
+            { name: `  ${cyan('📝')} Write a custom message`, value: 'custom' },
+            { name: `  ${green('⚡')} Quick apply (standard template)`, value: 'quick' },
+            { name: `  ${magenta('🤖')} Detailed application (shows your skills)`, value: 'detailed' },
+            new inquirer.Separator(dim('  ─────────────────')),
+            { name: `  ${dim('⬅  Cancel')}`, value: 'cancel' },
+        ],
+    }]);
+
+    if (style === 'cancel') return;
+
+    let commentBody = '';
+
+    if (style === 'quick') {
+        commentBody = buildQuickApplication(issue.title);
+    } else if (style === 'detailed') {
+        commentBody = await buildDetailedApplication(me, owner, repo, issue);
+    } else {
+        // Custom message
+        const { msg } = await inquirer.prompt([{
+            type: 'input',
+            name: 'msg',
+            message: bold('Your application message:'),
+            validate: (v: string) => v.trim().length >= 10 || 'Please write at least 10 characters',
+        }]);
+        commentBody = buildCustomApplication(msg.trim(), issue.title);
+    }
+
+    // Preview
+    console.log();
+    console.log(dim('  ── Preview ──────────────────────────────────'));
+    commentBody.split('\n').forEach(line => console.log(`  ${dim(line)}`));
+    console.log(dim('  ─────────────────────────────────────────────'));
+    console.log();
+
+    const { confirm } = await inquirer.prompt([{
+        type: 'list',
+        name: 'confirm',
+        message: bold('Post this application?'),
+        choices: [
+            { name: `  ${green('✅  Yes, post it')}`, value: 'yes' },
+            { name: `  ${yellow('✏️   Edit message')}`, value: 'edit' },
+            { name: `  ${dim('❌  Cancel')}`, value: 'no' },
+        ],
+    }]);
+
+    if (confirm === 'no') return;
+
+    if (confirm === 'edit') {
+        const { edited } = await inquirer.prompt([{
+            type: 'editor',
+            name: 'edited',
+            message: 'Edit your application:',
+            default: commentBody,
+        }]);
+        commentBody = edited.trim();
+    }
+
+    const postSpinner = ora('  Posting application…').start();
+    try {
+        const { data: posted } = await octokit.issues.createComment({
+            owner, repo, issue_number: issueNumber, body: commentBody,
+        });
+        postSpinner.succeed(green(`  Application posted! → ${posted.html_url}`));
+    } catch (e: any) {
+        postSpinner.fail(`  Failed to post: ${e.message}`);
+        return;
+    }
+
+    // Offer to fork + branch immediately
+    console.log();
+    const { forkNow } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'forkNow',
+        message: bold(`Fork ${owner}/${repo} and create a branch for this issue now?`),
+        default: true,
+    }]);
+
+    if (forkNow) {
+        await forkAndBranchForIssue(owner, repo, issueNumber, issue.title);
+    }
+}
+
+// ── Application message builders ────────────────────────────────────────────
+
+function buildQuickApplication(issueTitle: string): string {
+    return `Hey! I'd like to work on this issue.
+
+I'm available to start right away and will keep you updated on progress. Please assign this to me if you think I'm a good fit.
+
+> Issue: *${issueTitle}*
+
+---
+*Sent via [GitPadi](https://github.com/Netwalls/contributor-agent) 🤖*`;
+}
+
+function buildCustomApplication(message: string, issueTitle: string): string {
+    // Ensure it matches APPLICATION_PATTERNS so applicant-scorer fires
+    const opener = /i('d| would| want| will)|assign.*me|let me|i can|i'm interested|claiming this/i.test(message)
+        ? ''
+        : "I'd like to work on this issue.\n\n";
+
+    return `${opener}${message}
+
+---
+*Sent via [GitPadi](https://github.com/Netwalls/contributor-agent) 🤖*`;
+}
+
+async function buildDetailedApplication(me: string, owner: string, repo: string, issue: any): Promise<string> {
+    const octokit = getOctokit();
+    const spinner = ora('  Fetching your GitHub profile…').start();
+
+    let userBio = '';
+    let topLanguages: string[] = [];
+    let mergedPRs = 0;
+
+    try {
+        const { data: user } = await octokit.users.getByUsername({ username: me });
+        userBio = user.bio || '';
+
+        // Count merged PRs in this repo
+        const { data: prs } = await octokit.pulls.list({ owner, repo, state: 'closed', per_page: 100 });
+        mergedPRs = prs.filter((p: any) => p.user?.login === me && p.merged_at).length;
+
+        // Get top languages from user's repos
+        const { data: repos } = await octokit.repos.listForUser({ username: me, per_page: 20, sort: 'updated' });
+        const langCounts: Record<string, number> = {};
+        repos.forEach((r: any) => { if (r.language) langCounts[r.language] = (langCounts[r.language] || 0) + 1; });
+        topLanguages = Object.entries(langCounts).sort((a, b) => b[1] - a[1]).slice(0, 4).map(([l]) => l);
+
+        spinner.succeed();
+    } catch {
+        spinner.warn('  Could not fully load profile — using basic template');
+    }
+
+    const langLine = topLanguages.length > 0 ? `**Languages:** ${topLanguages.join(', ')}` : '';
+    const prLine = mergedPRs > 0 ? `**${mergedPRs} merged PR(s)** in this repo` : '';
+    const statsLines = [langLine, prLine].filter(Boolean).join(' · ');
+
+    const { approach } = await inquirer.prompt([{
+        type: 'input',
+        name: 'approach',
+        message: bold('Briefly describe your approach / why you want this issue:'),
+        validate: (v: string) => v.trim().length >= 10 || 'Please write at least 10 characters',
+    }]);
+
+    const { eta } = await inquirer.prompt([{
+        type: 'list',
+        name: 'eta',
+        message: bold('Expected time to complete:'),
+        choices: ['1–2 days', '3–5 days', '1 week', '2 weeks', 'Unsure — I\'ll update you'],
+    }]);
+
+    return `## Application — ${issue.title}
+
+I'd like to work on this issue.
+
+**Why I'm a good fit:**
+${approach.trim()}
+
+**My approach:**
+- I'll start by reviewing the codebase around this issue
+- Open a draft PR early so you can track progress
+- Will ask questions here if anything is unclear
+
+**Timeline:** ~${eta}
+
+${statsLines ? `---\n${statsLines}` : ''}
+
+---
+*Sent via [GitPadi](https://github.com/Netwalls/contributor-agent) 🤖*`;
+}
+
+// ── Fork + branch helper ─────────────────────────────────────────────────────
+
+async function forkAndBranchForIssue(owner: string, repo: string, issueNumber: number, issueTitle: string): Promise<void> {
+    const octokit = getOctokit();
+    const me = await getAuthenticatedUser();
+    const spinner = ora(`  Forking ${owner}/${repo}…`).start();
+
+    try {
+        await forkRepo(owner, repo);
+        spinner.succeed(`  Forked → ${me}/${repo}`);
+    } catch (e: any) {
+        if (/already exists/i.test(e.message)) {
+            spinner.info(`  Fork already exists at ${me}/${repo}`);
+        } else {
+            spinner.fail(`  Fork failed: ${e.message}`);
+            return;
+        }
+    }
+
+    const { cloneDir } = await inquirer.prompt([{
+        type: 'input',
+        name: 'cloneDir',
+        message: bold('Where to clone?'),
+        default: `./${repo}`,
+    }]);
+
+    const dir = cloneDir.trim();
+
+    if (!fs.existsSync(dir)) {
+        const cloneSpinner = ora(`  Cloning into ${dir}…`).start();
+        try {
+            execFileSync('git', ['clone', `https://github.com/${me}/${repo}.git`, dir], { stdio: 'pipe' });
+            cloneSpinner.succeed();
+        } catch (e: any) {
+            cloneSpinner.fail(`  Clone failed: ${e.message}`);
+            return;
+        }
+    }
+
+    // Add upstream
+    try {
+        execFileSync('git', ['remote', 'add', 'upstream', `https://github.com/${owner}/${repo}.git`], { cwd: dir, stdio: 'pipe' });
+    } catch { /* already exists */ }
+
+    // Create branch
+    const branchName = `fix/issue-${issueNumber}`;
+    try {
+        execFileSync('git', ['checkout', '-b', branchName], { cwd: dir, stdio: 'pipe' });
+        console.log(green(`\n  ✅ Branch created: ${cyan(branchName)}`));
+        console.log(dim(`  cd ${dir} && npx gitpadi`));
+        console.log();
+    } catch (e: any) {
+        console.log(yellow(`  ⚠  Could not create branch: ${e.message}`));
+    }
+}
+
+// ── URL parser ───────────────────────────────────────────────────────────────
+
+function parseTarget(input: string): { owner: string; repo: string; issue?: number } {
+    const urlMatch = input.match(/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?\/?(?:issues\/(\d+))?(?:\?|$|\/)/);
+    if (urlMatch) {
+        return { owner: urlMatch[1], repo: urlMatch[2], issue: urlMatch[3] ? parseInt(urlMatch[3]) : undefined };
+    }
+    const parts = input.replace(/https?:\/\/github\.com\//, '').split('/');
+    if (parts.length >= 2) {
+        return { owner: parts[0], repo: parts[1], issue: parts[3] ? parseInt(parts[3]) : undefined };
+    }
+    throw new Error('Use a GitHub URL or "owner/repo" format.');
+}