gitpadi 2.0.7 → 2.1.1

package/dist/commands/bounty-hunter.js

@@ -0,0 +1,441 @@
+// commands/bounty-hunter.ts — Autonomous Bounty Hunter
+//
+// Searches Drips Wave and GrantFox for open issues, scores them against your
+// GitHub profile, and automatically posts applications — no human input needed.
+//
+// How it works:
+//   Drips Wave  → GitHub issues labeled "Stellar Wave" across 196+ orgs
+//   GrantFox    → GitHub issues in org:GrantChain and known partner repos
+//
+// Both platforms sync from GitHub, so posting a matching application comment
+// IS the application. Their bots pick it up automatically.
+//
+// Usage:
+//   gitpadi hunt
+//   gitpadi hunt --platform drips --max 5 --dry-run
+import chalk from 'chalk';
+import ora from 'ora';
+import { getOctokit, getAuthenticatedUser } from '../core/github.js';
+const dim = chalk.dim;
+const cyan = chalk.cyan;
+const green = chalk.green;
+const yellow = chalk.yellow;
+const bold = chalk.bold;
+const magenta = chalk.magenta;
+const red = chalk.red;
+// ── Point values for Drips Wave complexity labels ────────────────────────────
+const DRIPS_COMPLEXITY = {
+    'small': 100, 'trivial': 100,
+    'medium': 150,
+    'large': 200, 'high': 200, 'complex': 200,
+};
+// Drips 3× multiplier repos (highest reward)
+const DRIPS_3X_REPOS = new Set([
+    'akkuea/akkuea',
+    'tupui/soroban-versioning',
+    'OFFER-HUB/offer-hub-monorepo',
+    'safetrustcr/frontend-SafeTrust',
+    'kindfi-org/kindfi',
+    'Stellopay/stellopay-frontend',
+    'Stellar-Rent/stellar-rent',
+    'Stellopay/stellopay-core',
+    'boundlessfi/bounties',
+    'BuenDia-Builders/be-energy',
+    'Trustless-Work/clonable-backoffice',
+    'Trustless-Work/tokenization-private-credit-oss',
+    'safetrustcr/backend-SafeTrust',
+]);
+// GrantFox partner orgs on GitHub
+const GRANTFOX_ORGS = ['GrantChain', 'Trustless-Work'];
+// Labels that signal open contribution opportunity
+const CONTRIBUTOR_LABELS = [
+    'good first issue', 'help wanted', 'bounty', 'hacktoberfest',
+    'up for grabs', 'stellar wave', 'grantfox',
+    'contributions welcome', 'open to pr',
+];
+const DEFAULT_OPTIONS = {
+    platform: 'all',
+    maxApplications: 3,
+    dryRun: false,
+    skills: [],
+    minPoints: 0,
+    skipAssigned: true,
+    verbose: false,
+};
+// ── Search ───────────────────────────────────────────────────────────────────
+async function searchDripsIssues(octokit, skills) {
+    const issues = [];
+    // Primary: label "Stellar Wave" — this is the official Drips Wave label
+    const queries = [
+        'label:"Stellar Wave" state:open type:issue',
+        'label:"stellar-wave" state:open type:issue',
+    ];
+    for (const q of queries) {
+        try {
+            const { data } = await octokit.search.issuesAndPullRequests({
+                q, per_page: 50, sort: 'updated', order: 'desc',
+            });
+            for (const item of data.items) {
+                if (item.pull_request)
+                    continue;
+                const [owner, repo] = (item.repository_url?.replace('https://api.github.com/repos/', '') || '/').split('/');
+                const fullRepo = `${owner}/${repo}`;
+                const labels = item.labels.map((l) => (l.name || '').toLowerCase());
+                // Parse complexity from labels
+                let complexity = 'medium';
+                let points = 150;
+                for (const [lbl, pts] of Object.entries(DRIPS_COMPLEXITY)) {
+                    if (labels.some((l) => l.includes(lbl))) {
+                        complexity = lbl;
+                        points = pts;
+                        break;
+                    }
+                }
+                const multiplier = DRIPS_3X_REPOS.has(fullRepo) ? 3 : 1;
+                issues.push({
+                    platform: 'drips',
+                    owner, repo,
+                    number: item.number,
+                    title: item.title,
+                    body: item.body || '',
+                    url: item.html_url,
+                    labels,
+                    points,
+                    multiplier,
+                    effectivePoints: points * multiplier,
+                    complexity,
+                    assignees: item.assignees?.map((a) => a.login) || [],
+                    hasPr: false,
+                    skillMatch: calcSkillMatch(item.title + ' ' + (item.body || '') + ' ' + labels.join(' '), skills),
+                    age: Math.floor((Date.now() - new Date(item.updated_at).getTime()) / 86_400_000),
+                });
+            }
+        }
+        catch { /* rate limit or no results */ }
+    }
+    return dedupeIssues(issues);
+}
+async function searchGrantFoxIssues(octokit, skills) {
+    const issues = [];
+    const queries = [
+        // GrantFox own repositories
+        ...GRANTFOX_ORGS.map(org => `org:${org} state:open type:issue`),
+        // Issues tagged with contributor-friendly labels in known partner orgs
+        'label:"good first issue" org:Trustless-Work state:open type:issue',
+        'label:"help wanted" org:Trustless-Work state:open type:issue',
+        'label:bounty state:open type:issue org:GrantChain',
+    ];
+    for (const q of queries) {
+        try {
+            const { data } = await octokit.search.issuesAndPullRequests({
+                q, per_page: 30, sort: 'updated', order: 'desc',
+            });
+            for (const item of data.items) {
+                if (item.pull_request)
+                    continue;
+                const [owner, repo] = (item.repository_url?.replace('https://api.github.com/repos/', '') || '/').split('/');
+                const labels = item.labels.map((l) => (l.name || '').toLowerCase());
+                issues.push({
+                    platform: 'grantfox',
+                    owner, repo,
+                    number: item.number,
+                    title: item.title,
+                    body: item.body || '',
+                    url: item.html_url,
+                    labels,
+                    points: 0,
+                    multiplier: 1,
+                    effectivePoints: 0,
+                    complexity: 'unknown',
+                    assignees: item.assignees?.map((a) => a.login) || [],
+                    hasPr: false,
+                    skillMatch: calcSkillMatch(item.title + ' ' + (item.body || '') + ' ' + labels.join(' '), skills),
+                    age: Math.floor((Date.now() - new Date(item.updated_at).getTime()) / 86_400_000),
+                });
+            }
+        }
+        catch { /* rate limit or no results */ }
+    }
+    return dedupeIssues(issues);
+}
+// ── Scoring helpers ──────────────────────────────────────────────────────────
+function calcSkillMatch(text, skills) {
+    if (skills.length === 0)
+        return 50; // neutral
+    const lower = text.toLowerCase();
+    const hits = skills.filter(s => lower.includes(s.toLowerCase()));
+    return Math.round((hits.length / skills.length) * 100);
+}
+function scoreIssue(issue) {
+    let score = 0;
+    score += issue.skillMatch * 0.4; // 40% skill match
+    score += Math.min(issue.effectivePoints / 6, 33); // up to 33 pts for reward
+    score += issue.assignees.length === 0 ? 20 : 0; // unassigned bonus
+    score -= Math.min(issue.age / 10, 10); // penalise stale issues
+    return Math.round(Math.max(0, score));
+}
+function dedupeIssues(issues) {
+    const seen = new Set();
+    return issues.filter(i => {
+        const key = `${i.owner}/${i.repo}#${i.number}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+// ── Application comment builders ─────────────────────────────────────────────
+function buildDripsApplication(issue, me) {
+    const pts = issue.effectivePoints > 0
+        ? `\n\n> **Reward:** ${issue.points} pts${issue.multiplier > 1 ? ` × ${issue.multiplier}× = **${issue.effectivePoints} pts**` : ''} (${issue.complexity})`
+        : '';
+    return `Hey! I'd like to work on this issue.
+
+I'm available to start right away, will open a draft PR early to show progress, and will keep you updated.${pts}
+
+Please assign this to me if you think I'm a good fit — happy to answer any questions about my approach first.
+
+---
+*Applied via [GitPadi](https://github.com/Netwalls/contributor-agent) Bounty Hunter 🤖*`;
+}
+function buildGrantFoxApplication(issue, me) {
+    return `Hi! I'd like to work on this issue.
+
+I found this through GrantFox and I'm interested in contributing. I'll:
+- Open a draft PR early so you can track my progress
+- Ask questions here if anything needs clarification
+- Aim to complete within 3–5 days
+
+Please assign this to me if it's still open — I'm ready to start.
+
+---
+*Applied via [GitPadi](https://github.com/Netwalls/contributor-agent) Bounty Hunter 🤖*`;
+}
+// ── Check if already applied ─────────────────────────────────────────────────
+async function alreadyApplied(octokit, issue, me) {
+    try {
+        const { data: comments } = await octokit.issues.listComments({
+            owner: issue.owner,
+            repo: issue.repo,
+            issue_number: issue.number,
+            per_page: 100,
+        });
+        return comments.some((c) => c.user?.login === me &&
+            /i('d| would| want| will)|assign.*me|let me|i can|i'm interested|claiming|GitPadi Bounty Hunter/i.test(c.body || ''));
+    }
+    catch {
+        return false;
+    }
+}
+// ── Print helpers ────────────────────────────────────────────────────────────
+function platformBadge(platform) {
+    return platform === 'drips'
+        ? cyan('[Drips Wave]')
+        : magenta('[GrantFox]  ');
+}
+function pointsBadge(issue) {
+    if (issue.effectivePoints === 0)
+        return dim('      ');
+    if (issue.multiplier > 1)
+        return yellow(`${issue.effectivePoints}pts★`);
+    return dim(`${issue.effectivePoints}pts `);
+}
+function printIssueRow(issue, idx, status) {
+    const num = dim(`${idx + 1}.`);
+    const badge = platformBadge(issue.platform);
+    const pts = pointsBadge(issue);
+    const assigned = issue.assignees.length > 0 ? yellow(' [assigned]') : '';
+    const title = issue.title.length > 55 ? issue.title.slice(0, 54) + '…' : issue.title;
+    console.log(`  ${num} ${badge} ${pts}  ${bold(title)}${assigned}`);
+    console.log(`     ${dim(`${issue.owner}/${issue.repo}#${issue.number}`)}  ${dim('→')} ${dim(issue.url)}`);
+    console.log(`     ${status}`);
+    console.log();
+}
+// ── Main ─────────────────────────────────────────────────────────────────────
+export async function runBountyHunter(opts = {}) {
+    const options = { ...DEFAULT_OPTIONS, ...opts };
+    const octokit = getOctokit();
+    console.log();
+    console.log(bold(cyan('  🎯 GitPadi Bounty Hunter')));
+    console.log(dim(`  Platform: ${options.platform}  |  Max applications: ${options.maxApplications}  |  Dry-run: ${options.dryRun}`));
+    console.log();
+    // Get authenticated user + their languages
+    const spinner = ora('  Loading your GitHub profile…').start();
+    let me = '';
+    let myLanguages = options.skills;
+    try {
+        me = await getAuthenticatedUser();
+        if (myLanguages.length === 0) {
+            // Auto-detect user's top languages from their repos
+            const { data: myRepos } = await octokit.repos.listForAuthenticatedUser({
+                per_page: 50, sort: 'updated',
+            });
+            const langCounts = {};
+            myRepos.forEach((r) => {
+                if (r.language)
+                    langCounts[r.language] = (langCounts[r.language] || 0) + 1;
+            });
+            myLanguages = Object.entries(langCounts)
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 8)
+                .map(([l]) => l.toLowerCase());
+        }
+        spinner.succeed(`  Logged in as @${me}  |  Skills: ${myLanguages.join(', ') || 'all'}`);
+    }
+    catch (e) {
+        spinner.fail(`  Could not load profile: ${e.message}`);
+        return;
+    }
+    // Search issues
+    const searches = [];
+    if (options.platform === 'drips' || options.platform === 'all') {
+        const s = ora('  Searching Drips Wave issues…').start();
+        searches.push(searchDripsIssues(octokit, myLanguages)
+            .then(r => { s.succeed(`  Drips Wave: ${r.length} issues found`); return r; })
+            .catch(e => { s.fail(`  Drips search failed: ${e.message}`); return []; }));
+    }
+    if (options.platform === 'grantfox' || options.platform === 'all') {
+        const s = ora('  Searching GrantFox issues…').start();
+        searches.push(searchGrantFoxIssues(octokit, myLanguages)
+            .then(r => { s.succeed(`  GrantFox: ${r.length} issues found`); return r; })
+            .catch(e => { s.fail(`  GrantFox search failed: ${e.message}`); return []; }));
+    }
+    const results = await Promise.all(searches);
+    let allIssues = dedupeIssues(results.flat());
+    // Filter
+    if (options.skipAssigned) {
+        allIssues = allIssues.filter(i => i.assignees.length === 0);
+    }
+    if (options.minPoints > 0) {
+        allIssues = allIssues.filter(i => i.platform === 'grantfox' || i.effectivePoints >= options.minPoints);
+    }
+    if (options.skills.length > 0) {
+        allIssues = allIssues.filter(i => i.skillMatch > 0);
+    }
+    // Rank
+    allIssues.sort((a, b) => scoreIssue(b) - scoreIssue(a));
+    if (allIssues.length === 0) {
+        console.log(yellow('\n  No matching issues found. Try --platform all or remove skill filters.'));
+        return;
+    }
+    console.log();
+    console.log(bold(`  Found ${allIssues.length} matching issue(s) — top picks:\n`));
+    // Show top issues
+    const TOP_DISPLAY = Math.min(allIssues.length, 10);
+    for (let i = 0; i < TOP_DISPLAY; i++) {
+        const issue = allIssues[i];
+        const rank = scoreIssue(issue);
+        const rankStr = rank >= 70 ? green(`match ${rank}%`) : rank >= 40 ? yellow(`match ${rank}%`) : dim(`match ${rank}%`);
+        printIssueRow(issue, i, rankStr);
+    }
+    if (allIssues.length > TOP_DISPLAY) {
+        console.log(dim(`  … and ${allIssues.length - TOP_DISPLAY} more\n`));
+    }
+    // Select top N for application
+    const candidates = allIssues.slice(0, options.maxApplications);
+    if (options.dryRun) {
+        console.log(yellow(`  [dry-run] Would apply to ${candidates.length} issue(s):`));
+        candidates.forEach((issue, i) => {
+            console.log(`  ${i + 1}. ${issue.owner}/${issue.repo}#${issue.number} — ${issue.title}`);
+        });
+        console.log();
+        console.log(dim('  Remove --dry-run to actually post applications.'));
+        return;
+    }
+    // Apply
+    console.log(bold(`\n  Applying to top ${candidates.length} issue(s)…\n`));
+    const results_ = [];
+    for (const issue of candidates) {
+        const label = `  ${platformBadge(issue.platform)} ${issue.owner}/${issue.repo}#${issue.number}`;
+        const applySpinner = ora(`${label}`).start();
+        // Check for existing application
+        const already = await alreadyApplied(octokit, issue, me);
+        if (already) {
+            applySpinner.warn(`${label} — already applied, skipping`);
+            results_.push({ issue, status: 'skipped' });
+            continue;
+        }
+        const body = issue.platform === 'drips'
+            ? buildDripsApplication(issue, me)
+            : buildGrantFoxApplication(issue, me);
+        try {
+            const { data: comment } = await octokit.issues.createComment({
+                owner: issue.owner,
+                repo: issue.repo,
+                issue_number: issue.number,
+                body,
+            });
+            applySpinner.succeed(`${label} — ${green('applied')} → ${dim(comment.html_url)}`);
+            results_.push({ issue, status: 'applied', url: comment.html_url });
+        }
+        catch (e) {
+            applySpinner.fail(`${label} — ${red('failed:')} ${e.message}`);
+            results_.push({ issue, status: 'failed' });
+        }
+        // Small delay to avoid rate limiting
+        await new Promise(r => setTimeout(r, 800));
+    }
+    // Summary
+    const applied = results_.filter(r => r.status === 'applied');
+    const skipped = results_.filter(r => r.status === 'skipped');
+    const failed = results_.filter(r => r.status === 'failed');
+    console.log();
+    console.log(bold('  ── Summary ───────────────────────────────────────────'));
+    console.log(`  ${green(`✅ Applied:  ${applied.length}`)}`);
+    if (skipped.length)
+        console.log(`  ${yellow(`⏭  Skipped:  ${skipped.length} (already applied)`)}`);
+    if (failed.length)
+        console.log(`  ${red(`❌ Failed:   ${failed.length}`)}`);
+    console.log();
+    if (applied.length > 0) {
+        console.log(dim('  What happens next:'));
+        const hasDrips = applied.some(r => r.issue.platform === 'drips');
+        const hasGF = applied.some(r => r.issue.platform === 'grantfox');
+        if (hasDrips) {
+            console.log(dim('  • Drips Wave: submit a PR when your fix is ready. Points are awarded on merge.'));
+        }
+        if (hasGF) {
+            console.log(dim('  • GrantFox:   maintainer will review your profile and assign if you\'re a good fit.'));
+        }
+        console.log(dim('  • Run `gitpadi` → Contributor → Sync with Upstream to stay current.'));
+        console.log();
+    }
+    // Offer to fork + branch for applied issues
+    if (applied.length > 0) {
+        console.log(bold('  Fork & branch for applied issues?'));
+        for (const r of applied) {
+            const { execFileSync } = await import('child_process');
+            const { forkRepo } = await import('../core/github.js');
+            const { existsSync } = await import('fs');
+            console.log(`\n  ${cyan(`${r.issue.owner}/${r.issue.repo}#${r.issue.number}`)}`);
+            try {
+                const forkSpinner = ora(`  Forking ${r.issue.owner}/${r.issue.repo}…`).start();
+                await forkRepo(r.issue.owner, r.issue.repo);
+                forkSpinner.succeed(`  Forked → ${me}/${r.issue.repo}`);
+                const dir = `./${r.issue.repo}-${r.issue.number}`;
+                if (!existsSync(dir)) {
+                    const cloneSpinner = ora(`  Cloning into ${dir}…`).start();
+                    execFileSync('git', ['clone', `https://github.com/${me}/${r.issue.repo}.git`, dir], { stdio: 'pipe' });
+                    cloneSpinner.succeed();
+                }
+                try {
+                    execFileSync('git', ['remote', 'add', 'upstream', `https://github.com/${r.issue.owner}/${r.issue.repo}.git`], { cwd: dir, stdio: 'pipe' });
+                }
+                catch { /* already exists */ }
+                const branch = `fix/issue-${r.issue.number}`;
+                execFileSync('git', ['checkout', '-b', branch], { cwd: dir, stdio: 'pipe' });
+                console.log(green(`  ✅ Branch ready: ${cyan(branch)}`));
+                console.log(dim(`  cd ${dir} && npx gitpadi`));
+            }
+            catch (e) {
+                if (/already exists/i.test(e.message)) {
+                    console.log(yellow(`  Fork already exists.`));
+                }
+                else {
+                    console.log(yellow(`  Could not fork/clone: ${e.message}`));
+                }
+            }
+        }
+        console.log();
+    }
+}