gitpadi 2.1.1 → 2.1.3

package/dist/commands/drips.js

@@ -0,0 +1,669 @@
+// commands/drips.ts — Smart Drips Network issue applicant
+//
+// Features:
+//  1. Auto-Apply  — scan issues, score against your tech stack, batch-apply
+//  2. Browse by Track — unassigned only, sorted by points, filter backend/frontend/contract
+//
+// API: https://wave-api.drips.network
+// Auth: GitHub OAuth → JWT cookie (wave_access_token)
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import os from 'node:os';
+const DRIPS_API = 'https://wave-api.drips.network';
+const DRIPS_WEB = 'https://www.drips.network';
+const CONFIG_DIR = path.join(os.homedir(), '.gitpadi');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const dim = chalk.dim;
+const cyan = chalk.cyanBright;
+const yellow = chalk.yellowBright;
+const green = chalk.greenBright;
+const bold = chalk.bold;
+const red = chalk.redBright;
+const magenta = chalk.magentaBright;
+// ── Track keyword maps ────────────────────────────────────────────────────────
+const TRACK_KEYWORDS = {
+    contract: [
+        'solidity', 'smart contract', 'contract', 'blockchain', 'web3',
+        'evm', 'anchor', 'defi', 'nft', 'token', 'wallet', 'on-chain',
+        'hardhat', 'foundry', 'wagmi', 'ethers',
+    ],
+    backend: [
+        'backend', 'api', 'server', 'database', 'db', 'node', 'python',
+        'golang', 'go', 'java', 'rust', 'graphql', 'rest', 'grpc',
+        'postgresql', 'postgres', 'mysql', 'redis', 'kafka', 'docker',
+        'microservice', 'auth', 'authentication', 'authorization',
+    ],
+    frontend: [
+        'frontend', 'ui', 'ux', 'react', 'svelte', 'vue', 'angular',
+        'css', 'html', 'tailwind', 'mobile', 'ios', 'android', 'flutter',
+        'next', 'nuxt', 'design', 'component', 'responsive', 'a11y',
+    ],
+};
+// ── Config ────────────────────────────────────────────────────────────────────
+function loadConfig() {
+    if (!fs.existsSync(CONFIG_FILE))
+        return {};
+    try {
+        return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+function saveConfig(patch) {
+    const current = loadConfig();
+    if (!fs.existsSync(CONFIG_DIR))
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify({ ...current, ...patch }, null, 2));
+}
+function loadProfile() {
+    return loadConfig().dripsProfile ?? null;
+}
+function saveProfile(profile) {
+    saveConfig({ dripsProfile: profile });
+}
+function saveDripsToken(token) {
+    saveConfig({ dripsToken: token });
+}
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function truncate(text, max) {
+    return text.length <= max ? text : text.slice(0, max - 1) + '…';
+}
+function diffDays(dateStr) {
+    return Math.floor((Date.now() - new Date(dateStr).getTime()) / 86_400_000);
+}
+function openBrowser(url) {
+    try {
+        if (process.platform === 'darwin')
+            execSync(`open "${url}"`, { stdio: 'ignore' });
+        else if (process.platform === 'win32')
+            execSync(`start "" "${url}"`, { stdio: 'ignore' });
+        else
+            execSync(`xdg-open "${url}"`, { stdio: 'ignore' });
+    }
+    catch { /* ignore */ }
+}
+function parseSlug(input) {
+    const m = input.match(/drips\.network\/wave\/([^/?#\s]+)/);
+    if (m)
+        return m[1];
+    return input.replace(/^\/+|\/+$/g, '').split('/').pop() || input;
+}
+function issueLabels(issue) {
+    return issue.labels.map(l => l.name.toLowerCase());
+}
+/** Detect which track an issue belongs to based on its labels and title */
+function detectTrack(issue) {
+    const haystack = [...issueLabels(issue), issue.title.toLowerCase()].join(' ');
+    for (const [track, keywords] of Object.entries(TRACK_KEYWORDS)) {
+        if (keywords.some(kw => haystack.includes(kw)))
+            return track;
+    }
+    return null;
+}
+/** Score an issue against the user's tech stack. Returns 0 if no match. */
+function scoreIssue(issue, techStack) {
+    const haystack = [...issueLabels(issue), issue.title.toLowerCase()].join(' ');
+    const matchReasons = [];
+    for (const tech of techStack) {
+        if (haystack.includes(tech.toLowerCase())) {
+            matchReasons.push(tech);
+        }
+    }
+    return { score: matchReasons.length, matchReasons };
+}
+/** Filter issues matching the user's track preference */
+function matchesTrack(issue, track) {
+    if (track === 'all')
+        return true;
+    const detected = detectTrack(issue);
+    if (detected === track)
+        return true;
+    // Also accept issues with no detected track when browsing 'all'
+    return false;
+}
+// ── API ───────────────────────────────────────────────────────────────────────
+async function dripsGet(endpoint, token) {
+    const headers = { Accept: 'application/json' };
+    if (token)
+        headers['Cookie'] = `wave_access_token=${token}`;
+    const res = await fetch(`${DRIPS_API}${endpoint}`, { headers });
+    if (!res.ok)
+        throw new Error(`Drips API ${res.status} on ${endpoint}`);
+    return res.json();
+}
+async function dripsPost(endpoint, body, token) {
+    const res = await fetch(`${DRIPS_API}${endpoint}`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
+            Cookie: `wave_access_token=${token}`,
+        },
+        body: JSON.stringify(body),
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        let msg = text;
+        try {
+            msg = JSON.parse(text)?.message || text;
+        }
+        catch { }
+        throw new Error(`${res.status}: ${msg}`);
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return {};
+    }
+}
+async function fetchIssuePage(programId, page, limit = 50) {
+    return dripsGet(`/api/issues?waveProgramId=${programId}&state=open&page=${page}&limit=${limit}&sortBy=updatedAt`);
+}
+async function getWaveProgram(slug) {
+    const data = await dripsGet(`/api/wave-programs?slug=${encodeURIComponent(slug)}`);
+    if (data?.id)
+        return data;
+    if (Array.isArray(data?.data) && data.data.length > 0)
+        return data.data[0];
+    throw new Error(`Wave program "${slug}" not found. Check the slug or URL.`);
+}
+// ── Auth ──────────────────────────────────────────────────────────────────────
+export async function ensureDripsAuth() {
+    const config = loadConfig();
+    if (config.dripsToken) {
+        try {
+            const res = await fetch(`${DRIPS_API}/api/wave-programs/fdc01c95-806f-4b6a-998b-a6ed37e0d81b/quotas/applications`, { headers: { Cookie: `wave_access_token=${config.dripsToken}`, Accept: 'application/json' } });
+            if (res.status !== 401)
+                return config.dripsToken;
+        }
+        catch { /* network issue */ }
+    }
+    console.log();
+    console.log(dim('  ┌─ Connect your Drips Network account ────────────────────────┐'));
+    console.log(dim('  │'));
+    console.log(dim('  │  1. Log in at: ') + cyan(DRIPS_WEB + '/wave/login'));
+    console.log(dim('  │     (GitPadi will open it in your browser)'));
+    console.log(dim('  │'));
+    console.log(dim('  │  2. After login, open DevTools:'));
+    console.log(dim('  │     ') + bold('F12') + dim(' → ') + bold('Application') + dim(' → ') + bold('Cookies') + dim(' → ') + cyan('www.drips.network'));
+    console.log(dim('  │'));
+    console.log(dim('  │  3. Find the cookie: ') + yellow('wave_access_token'));
+    console.log(dim('  │     Copy its full value (starts with ') + dim('eyJ...') + dim(')'));
+    console.log(dim('  │'));
+    console.log(dim('  │  This is a one-time step — GitPadi saves it for future use.'));
+    console.log(dim('  │'));
+    console.log(dim('  └─────────────────────────────────────────────────────────────┘'));
+    console.log();
+    const { launch } = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'launch',
+            message: 'Open drips.network login in your browser?',
+            default: true,
+        }]);
+    if (launch) {
+        openBrowser(`${DRIPS_WEB}/wave/login?skipWelcome=false`);
+        console.log(dim('\n  Browser opened. Log in with GitHub, then come back here.\n'));
+    }
+    else {
+        console.log(dim(`\n  Open manually: ${cyan(DRIPS_WEB + '/wave/login')}\n`));
+    }
+    const { token } = await inquirer.prompt([{
+            type: 'password',
+            name: 'token',
+            message: cyan('Paste your wave_access_token cookie value:'),
+            mask: '•',
+            validate: (v) => {
+                if (!v || v.trim().length < 20)
+                    return 'Token seems too short — copy the full value from DevTools';
+                if (!v.trim().startsWith('eyJ'))
+                    return 'Expected a JWT starting with eyJ — check you copied wave_access_token';
+                return true;
+            },
+        }]);
+    const t = token.trim();
+    saveDripsToken(t);
+    console.log(green('\n  ✅ Drips session saved.\n'));
+    return t;
+}
+// ── Profile setup ─────────────────────────────────────────────────────────────
+async function setupProfile(existing) {
+    console.log();
+    console.log(bold('  Set up your Drips profile — GitPadi uses this to find the right issues for you.'));
+    console.log();
+    const { programInput } = await inquirer.prompt([{
+            type: 'input',
+            name: 'programInput',
+            message: bold('Drips Wave program (slug or URL):'),
+            default: existing?.programSlug || 'stellar',
+        }]);
+    const { track } = await inquirer.prompt([{
+            type: 'list',
+            name: 'track',
+            message: bold('What is your track?'),
+            default: existing?.track || 'backend',
+            choices: [
+                { name: `  ${cyan('⚙️')}  Backend       ${dim('— APIs, servers, databases, Node.js, Rust, Go...')}`, value: 'backend' },
+                { name: `  ${magenta('🎨')}  Frontend      ${dim('— React, Svelte, Vue, CSS, mobile...')}`, value: 'frontend' },
+                { name: `  ${yellow('📜')}  Smart Contract ${dim('— Solidity, EVM, Anchor, DeFi, Web3...')}`, value: 'contract' },
+                { name: `  ${green('🌐')}  All tracks    ${dim('— show everything, filter by tech stack only')}`, value: 'all' },
+            ],
+        }]);
+    const { stackInput } = await inquirer.prompt([{
+            type: 'input',
+            name: 'stackInput',
+            message: bold('Your tech stack (comma-separated):'),
+            default: existing?.techStack.join(', ') || 'TypeScript, Node.js',
+            validate: (v) => v.trim().length > 0 || 'Enter at least one technology',
+        }]);
+    const { minPoints } = await inquirer.prompt([{
+            type: 'list',
+            name: 'minPoints',
+            message: bold('Minimum points to apply for:'),
+            default: existing?.minPoints || 0,
+            choices: [
+                { name: `  Any points (including unspecified)`, value: 0 },
+                { name: `  50+ pts`, value: 50 },
+                { name: `  100+ pts`, value: 100 },
+                { name: `  200+ pts`, value: 200 },
+                { name: `  500+ pts`, value: 500 },
+            ],
+        }]);
+    const techStack = stackInput.split(',').map((s) => s.trim()).filter(Boolean);
+    const programSlug = parseSlug(programInput.trim());
+    const profile = { track, techStack, minPoints, programSlug };
+    saveProfile(profile);
+    console.log(green(`\n  ✅ Profile saved — track: ${bold(track)}, stack: ${techStack.join(', ')}, min: ${minPoints}pts\n`));
+    return profile;
+}
+// ── Auto-apply ────────────────────────────────────────────────────────────────
+async function autoApply(program, profile) {
+    console.log();
+    console.log(bold(`  Scanning ${program.name} issues for matches…`));
+    console.log(dim(`  Track: ${profile.track}  |  Stack: ${profile.techStack.join(', ')}  |  Min: ${profile.minPoints}pts`));
+    console.log();
+    const spinner = ora(dim('  Fetching open issues…')).start();
+    const scored = [];
+    let page = 1;
+    const MAX_PAGES = 10; // scan up to 500 issues
+    while (page <= MAX_PAGES) {
+        let data;
+        let pagination;
+        try {
+            const res = await fetchIssuePage(program.id, page, 50);
+            data = res.data;
+            pagination = res.pagination;
+        }
+        catch (e) {
+            spinner.fail(`  Fetch error: ${e.message}`);
+            return;
+        }
+        for (const issue of data) {
+            // Skip assigned issues
+            if (issue.assignedApplicant !== null)
+                continue;
+            // Skip below min points (only if points are set)
+            if (profile.minPoints > 0 && issue.points !== null && issue.points < profile.minPoints)
+                continue;
+            // Skip if track doesn't match
+            if (!matchesTrack(issue, profile.track))
+                continue;
+            // Score against tech stack
+            const { score, matchReasons } = scoreIssue(issue, profile.techStack);
+            // For 'all' track, accept any score >= 0. For specific tracks, require at least a label match
+            if (profile.track !== 'all' && score === 0) {
+                // Still include it if it clearly matches the track (track filter already handled above)
+                // but boost score so track-matching issues without stack matches still show up
+                scored.push({ issue, score: 0.5, matchReasons: [profile.track] });
+            }
+            else {
+                scored.push({ issue, score, matchReasons: score > 0 ? matchReasons : [profile.track] });
+            }
+        }
+        spinner.text = dim(`  Scanned ${page * 50} issues, found ${scored.length} matches so far…`);
+        if (!pagination.hasNextPage || scored.length >= 50)
+            break;
+        page++;
+    }
+    // Sort: by score desc, then by points desc
+    scored.sort((a, b) => {
+        if (b.score !== a.score)
+            return b.score - a.score;
+        return (b.issue.points || 0) - (a.issue.points || 0);
+    });
+    const top = scored.slice(0, 30);
+    spinner.succeed(`  Found ${scored.length} matching issue(s) — showing top ${top.length}`);
+    if (top.length === 0) {
+        console.log(yellow('\n  No matching unassigned issues found. Try broadening your tech stack or lowering min points.\n'));
+        return;
+    }
+    console.log();
+    // Checkbox selection
+    const checkboxChoices = top.map(({ issue, score, matchReasons }) => {
+        const pts = issue.points ? green(`+${issue.points}pts`) : dim('—pts');
+        const applicants = issue.pendingApplicationsCount > 0 ? yellow(`${issue.pendingApplicationsCount}▲`) : dim('0▲');
+        const match = matchReasons.length > 0 ? cyan(`[${matchReasons.slice(0, 3).join(', ')}]`) : '';
+        const title = truncate(issue.title, 44);
+        return {
+            name: `  ${pts}  ${bold(title)}  ${match}  ${applicants}`,
+            value: issue,
+            checked: score >= 1, // pre-select strong matches
+        };
+    });
+    const { selectedIssues } = await inquirer.prompt([{
+            type: 'checkbox',
+            name: 'selectedIssues',
+            message: bold('Select issues to apply for (Space to toggle, Enter to confirm):'),
+            choices: checkboxChoices,
+            pageSize: 20,
+            validate: (selected) => selected.length > 0 || 'Select at least one issue',
+        }]);
+    if (!selectedIssues || selectedIssues.length === 0) {
+        console.log(dim('\n  No issues selected.\n'));
+        return;
+    }
+    console.log();
+    console.log(bold(`  ${selectedIssues.length} issue(s) selected. Composing application message…`));
+    console.log();
+    // Single application message for all
+    const { style } = await inquirer.prompt([{
+            type: 'list',
+            name: 'style',
+            message: bold('Application message for all selected issues:'),
+            choices: [
+                { name: `  ${green('⚡')}  Quick — standard intro message`, value: 'quick' },
+                { name: `  ${cyan('📝')}  Custom — write one message for all`, value: 'custom' },
+            ],
+        }]);
+    let baseMessage;
+    if (style === 'quick') {
+        baseMessage = `Hi! I'd like to work on this issue.\n\nI'm available to start right away and will keep you updated on my progress. My stack includes ${profile.techStack.join(', ')}. Please consider assigning this to me.\n\n*Applied via [GitPadi](https://github.com/Netwalls/contributor-agent)*`;
+    }
+    else {
+        const { msg } = await inquirer.prompt([{
+                type: 'input',
+                name: 'msg',
+                message: bold('Your message (applies to all selected issues):'),
+                validate: (v) => v.trim().length >= 10 || 'Write at least 10 characters',
+            }]);
+        baseMessage = `${msg.trim()}\n\n*Applied via [GitPadi](https://github.com/Netwalls/contributor-agent)*`;
+    }
+    const { go } = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'go',
+            message: bold(`Apply to ${selectedIssues.length} issue(s) now?`),
+            default: true,
+        }]);
+    if (!go)
+        return;
+    // Auth
+    let token;
+    try {
+        token = await ensureDripsAuth();
+    }
+    catch {
+        console.log(red('\n  Authentication cancelled.\n'));
+        return;
+    }
+    console.log();
+    let applied = 0;
+    let failed = 0;
+    for (const issue of selectedIssues) {
+        const spinner = ora(`  Applying to: ${truncate(issue.title, 50)}…`).start();
+        try {
+            await dripsPost(`/api/wave-programs/${program.id}/issues/${issue.id}/applications`, { applicationText: baseMessage }, token);
+            spinner.succeed(green(`  ✅ ${truncate(issue.title, 55)}`) + (issue.points ? dim(` (+${issue.points}pts)`) : ''));
+            applied++;
+        }
+        catch (e) {
+            spinner.fail(red(`  ✗  ${truncate(issue.title, 55)} — ${e.message}`));
+            failed++;
+            if (e.message.startsWith('401')) {
+                saveDripsToken('');
+                console.log(yellow('\n  Session expired — run again to re-authenticate.\n'));
+                break;
+            }
+        }
+    }
+    console.log();
+    console.log(bold(`  Done: ${green(applied + ' applied')}${failed > 0 ? ', ' + red(failed + ' failed') : ''}`));
+    console.log(dim(`\n  Track your applications: ${cyan(DRIPS_WEB + '/wave/' + program.slug)}\n`));
+}
+// ── Browse by track ───────────────────────────────────────────────────────────
+async function browseByTrack(program, profile) {
+    // Ask which track to browse if they want to override
+    const { browseTrack } = await inquirer.prompt([{
+            type: 'list',
+            name: 'browseTrack',
+            message: bold('Browse which track?'),
+            default: profile.track,
+            choices: [
+                { name: `  ${cyan('⚙️')}  Backend`, value: 'backend' },
+                { name: `  ${magenta('🎨')}  Frontend`, value: 'frontend' },
+                { name: `  ${yellow('📜')}  Smart Contract`, value: 'contract' },
+                { name: `  ${green('🌐')}  All tracks`, value: 'all' },
+            ],
+        }]);
+    const selectedTrack = browseTrack;
+    let page = 1;
+    while (true) {
+        const spinner = ora(dim(`  Fetching unassigned issues (page ${page})…`)).start();
+        let allIssues = [];
+        let hasNextPage = false;
+        let totalFetched = 0;
+        // Fetch a batch and filter client-side for unassigned + track
+        try {
+            // Fetch 2 pages worth (100 issues) to ensure we have enough unassigned after filtering
+            const batchStart = (page - 1) * 2 + 1;
+            const pageA = await fetchIssuePage(program.id, batchStart, 50);
+            const pageB = pageA.pagination.hasNextPage
+                ? await fetchIssuePage(program.id, batchStart + 1, 50)
+                : { data: [], pagination: { ...pageA.pagination, hasNextPage: false } };
+            const raw = [...pageA.data, ...pageB.data];
+            totalFetched = raw.length;
+            // Filter: unassigned + track + min points
+            allIssues = raw.filter(i => i.assignedApplicant === null &&
+                matchesTrack(i, selectedTrack) &&
+                (profile.minPoints === 0 || i.points === null || i.points >= profile.minPoints));
+            // Sort by points descending (highest reward first)
+            allIssues.sort((a, b) => (b.points || 0) - (a.points || 0));
+            hasNextPage = pageB.pagination.hasNextPage || (pageA.pagination.hasNextPage && !pageB.pagination.hasNextPage);
+            spinner.succeed(`  ${allIssues.length} unassigned ${selectedTrack} issue(s) found (from ${totalFetched} scanned) — sorted by points`);
+        }
+        catch (e) {
+            spinner.fail(`  ${e.message}`);
+            return;
+        }
+        if (allIssues.length === 0) {
+            console.log(yellow(`\n  No unassigned ${selectedTrack} issues found on this page. Try next page or change track.\n`));
+        }
+        console.log();
+        const choices = allIssues.slice(0, 20).map((issue) => {
+            const age = diffDays(issue.updatedAt);
+            const ageStr = age === 0 ? dim('today') : dim(`${age}d ago`);
+            const pts = issue.points ? green(`+${issue.points}pts`) : dim('  —pts');
+            const applicants = issue.pendingApplicationsCount > 0
+                ? yellow(`${issue.pendingApplicationsCount}▲`)
+                : dim('0▲');
+            const detected = detectTrack(issue);
+            const trackTag = detected ? dim(`[${detected}]`) : '';
+            const title = truncate(issue.title, 46);
+            return {
+                name: `  ${pts}  ${bold(title)}  ${trackTag}  ${applicants}  ${ageStr}`,
+                value: issue,
+                short: issue.title,
+            };
+        });
+        const nav = [
+            new inquirer.Separator(dim('  ─────────────────────────────────────────────────────')),
+        ];
+        if (hasNextPage)
+            nav.push({ name: `  ${dim('→  Next page')}`, value: '__next__' });
+        if (page > 1)
+            nav.push({ name: `  ${dim('←  Previous page')}`, value: '__prev__' });
+        nav.push({ name: `  ${dim('⬅  Back')}`, value: '__back__' });
+        const { selected } = await inquirer.prompt([{
+                type: 'list',
+                name: 'selected',
+                message: bold(`${program.name} — ${selectedTrack} issues sorted by points:`),
+                choices: allIssues.length > 0 ? [...choices, ...nav] : nav,
+                pageSize: 18,
+            }]);
+        if (selected === '__back__')
+            return;
+        if (selected === '__next__') {
+            page++;
+            continue;
+        }
+        if (selected === '__prev__') {
+            page = Math.max(1, page - 1);
+            continue;
+        }
+        await applySingle(program, selected, profile);
+    }
+}
+// ── Apply single ──────────────────────────────────────────────────────────────
+async function applySingle(program, issue, profile) {
+    console.log();
+    console.log(`  ${bold(cyan(truncate(issue.title, 72)))}`);
+    if (issue.repo)
+        console.log(`  ${dim('Repo:    ')} ${issue.repo.fullName}`);
+    console.log(`  ${dim('Points:  ')} ${issue.points ? green('+' + issue.points + ' pts') : dim('—')}`);
+    console.log(`  ${dim('Applied: ')} ${issue.pendingApplicationsCount} applicant(s)`);
+    if (issue.gitHubIssueUrl)
+        console.log(`  ${dim('GitHub:  ')} ${dim(issue.gitHubIssueUrl)}`);
+    console.log();
+    const { style } = await inquirer.prompt([{
+            type: 'list',
+            name: 'style',
+            message: bold('Application style:'),
+            choices: [
+                { name: `  ${green('⚡')}  Quick — standard intro`, value: 'quick' },
+                { name: `  ${cyan('📝')}  Custom — write your own`, value: 'custom' },
+                new inquirer.Separator(dim('  ────────────────')),
+                { name: `  ${dim('⬅  Cancel')}`, value: 'cancel' },
+            ],
+        }]);
+    if (style === 'cancel')
+        return;
+    let applicationText;
+    if (style === 'quick') {
+        applicationText = `Hi! I'd like to work on this issue.\n\nI'm available to start right away. My stack includes ${profile.techStack.join(', ')}. Please consider assigning this to me.\n\n*Applied via [GitPadi](https://github.com/Netwalls/contributor-agent)*`;
+    }
+    else {
+        const { msg } = await inquirer.prompt([{
+                type: 'input',
+                name: 'msg',
+                message: bold('Your message:'),
+                validate: (v) => v.trim().length >= 10 || 'Write at least 10 characters',
+            }]);
+        applicationText = `${msg.trim()}\n\n*Applied via [GitPadi](https://github.com/Netwalls/contributor-agent)*`;
+    }
+    console.log();
+    console.log(dim('  ── Preview ────────────────────────────────────────────────────'));
+    applicationText.split('\n').forEach(l => console.log(`  ${dim(l)}`));
+    console.log(dim('  ───────────────────────────────────────────────────────────────'));
+    console.log();
+    const { confirm } = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'confirm',
+            message: bold('Submit application?'),
+            default: true,
+        }]);
+    if (!confirm)
+        return;
+    let token;
+    try {
+        token = await ensureDripsAuth();
+    }
+    catch {
+        console.log(red('\n  Authentication cancelled.\n'));
+        return;
+    }
+    const spinner = ora('  Submitting…').start();
+    try {
+        await dripsPost(`/api/wave-programs/${program.id}/issues/${issue.id}/applications`, { applicationText }, token);
+        spinner.succeed(green(`  ✅ Applied! ${bold(issue.title)}`));
+        console.log(dim(`\n  Track: ${cyan(DRIPS_WEB + '/wave/' + program.slug)}\n`));
+    }
+    catch (e) {
+        spinner.fail(red(`  Failed: ${e.message}`));
+        if (e.message.startsWith('401')) {
+            saveDripsToken('');
+            console.log(yellow('\n  Session expired — run again to re-authenticate.\n'));
+        }
+    }
+}
+// ── Main menu ─────────────────────────────────────────────────────────────────
+export async function dripsMenu() {
+    // Load or set up profile first
+    let profile = loadProfile();
+    if (!profile) {
+        console.log();
+        console.log(bold('  Welcome to Drips Network! Let\'s set up your profile first.'));
+        profile = await setupProfile();
+    }
+    // Load the wave program
+    const progSpinner = ora(dim(`  Loading "${profile.programSlug}" wave program…`)).start();
+    let program;
+    try {
+        program = await getWaveProgram(profile.programSlug);
+        progSpinner.succeed(`  ${bold(program.name)} · ${cyan(program.issueCount.toLocaleString() + ' issues')} · ${green(program.presetBudgetUSD + '/mo')} · ${dim(program.approvedRepoCount + ' repos')}`);
+    }
+    catch (e) {
+        progSpinner.fail(`  ${e.message}`);
+        return;
+    }
+    while (true) {
+        console.log();
+        const { action } = await inquirer.prompt([{
+                type: 'list',
+                name: 'action',
+                message: bold(`Drips Network — ${program.name} Wave`),
+                choices: [
+                    {
+                        name: `  ${green('🤖')}  ${bold('Auto-Apply for Me')}        ${dim('— scan issues, match my stack, batch-apply')}`,
+                        value: 'auto',
+                    },
+                    {
+                        name: `  ${cyan('🔍')}  ${bold('Browse by Track')}          ${dim('— unassigned only, sorted by points, filter by track')}`,
+                        value: 'browse',
+                    },
+                    {
+                        name: `  ${dim('⚙️')}  ${dim('Update my Profile')}         ${dim('— change track, tech stack, min points')}`,
+                        value: 'profile',
+                    },
+                    new inquirer.Separator(dim('  ─────────────────────────────────────────────')),
+                    { name: `  ${dim('⬅  Back')}`, value: 'back' },
+                ],
+                loop: false,
+            }]);
+        if (action === 'back')
+            return;
+        if (action === 'auto') {
+            await autoApply(program, profile);
+        }
+        else if (action === 'browse') {
+            await browseByTrack(program, profile);
+        }
+        else if (action === 'profile') {
+            profile = await setupProfile(profile);
+            // Reload program if slug changed
+            if (profile.programSlug !== program.slug) {
+                const s = ora(dim(`  Switching to "${profile.programSlug}"…`)).start();
+                try {
+                    program = await getWaveProgram(profile.programSlug);
+                    s.succeed(`  ${bold(program.name)} loaded`);
+                }
+                catch (e) {
+                    s.fail(`  ${e.message}`);
+                }
+            }
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "gitpadi",
-    "version": "2.1.1",
+    "version": "2.1.3",
     "description": "GitPadi — AI-powered GitHub & GitLab management CLI. Fork repos, manage issues & PRs, score contributors, grade assignments, and automate everything. Powered by Anthropic Claude via GitLab Duo Agent Platform.",
     "type": "module",
     "bin": {