gitpadi 2.1.2 → 2.1.4

package/src/commands/drips.ts

@@ -1,7 +1,10 @@
-// commands/drips.ts — Apply for bounty issues on Drips Network from your terminal
+// commands/drips.ts — Smart Drips Network issue applicant
 //
-// API reverse-engineered from https://github.com/drips-network/app
-// Base: https://wave-api.drips.network
+// 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';
@@ -23,9 +26,19 @@ const yellow = chalk.yellowBright;
 const green = chalk.greenBright;
 const bold = chalk.bold;
 const red = chalk.redBright;
+const magenta = chalk.magentaBright;
 
 // ── Types ─────────────────────────────────────────────────────────────────────
 
+type Track = 'backend' | 'frontend' | 'contract' | 'all';
+
+interface DripsProfile {
+    track: Track;
+    techStack: string[];   // e.g. ["TypeScript", "Node.js", "PostgreSQL"]
+    minPoints: number;     // only apply to issues worth >= this
+    programSlug: string;   // e.g. "stellar"
+}
+
 interface DripsIssue {
     id: string;
     title: string;
@@ -61,6 +74,33 @@ interface DripsProgram {
     presetBudgetUSD: string;
 }
 
+interface ScoredIssue {
+    issue: DripsIssue;
+    score: number;
+    matchReasons: string[];
+}
+
+// ── Track keyword maps ────────────────────────────────────────────────────────
+
+const TRACK_KEYWORDS: Record<Exclude<Track, 'all'>, string[]> = {
+    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(): Record<string, any> {
@@ -68,10 +108,22 @@ function loadConfig(): Record<string, any> {
     try { return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8')); } catch { return {}; }
 }
 
-function saveDripsToken(token: string): void {
+function saveConfig(patch: Record<string, any>): void {
     const current = loadConfig();
     if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
-    fs.writeFileSync(CONFIG_FILE, JSON.stringify({ ...current, dripsToken: token }, null, 2));
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify({ ...current, ...patch }, null, 2));
+}
+
+function loadProfile(): DripsProfile | null {
+    return loadConfig().dripsProfile ?? null;
+}
+
+function saveProfile(profile: DripsProfile): void {
+    saveConfig({ dripsProfile: profile });
+}
+
+function saveDripsToken(token: string): void {
+    saveConfig({ dripsToken: token });
 }
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
@@ -98,6 +150,49 @@ function parseSlug(input: string): string {
     return input.replace(/^\/+|\/+$/g, '').split('/').pop() || input;
 }
 
+function issueLabels(issue: DripsIssue): string[] {
+    return issue.labels.map(l => l.name.toLowerCase());
+}
+
+const ORG_APPLICATION_LIMIT = 4;
+
+/** Extract the org/owner from a repo fullName like "myorg/myrepo" */
+function extractOrg(issue: DripsIssue): string {
+    return issue.repo?.fullName?.split('/')[0]?.toLowerCase() || '__unknown__';
+}
+
+/** Detect which track an issue belongs to based on its labels and title */
+function detectTrack(issue: DripsIssue): Exclude<Track, 'all'> | null {
+    const haystack = [...issueLabels(issue), issue.title.toLowerCase()].join(' ');
+    for (const [track, keywords] of Object.entries(TRACK_KEYWORDS) as [Exclude<Track, 'all'>, string[]][]) {
+        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: DripsIssue, techStack: string[]): { score: number; matchReasons: string[] } {
+    const haystack = [...issueLabels(issue), issue.title.toLowerCase()].join(' ');
+    const matchReasons: string[] = [];
+
+    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: DripsIssue, track: Track): boolean {
+    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: string, token?: string): Promise<any> {
@@ -127,40 +222,51 @@ async function dripsPost(endpoint: string, body: any, token: string): Promise<an
     try { return JSON.parse(text); } catch { return {}; }
 }
 
+async function fetchIssuePage(
+    programId: string,
+    page: number,
+    limit: number = 50,
+): Promise<{ data: DripsIssue[]; pagination: DripsPagination }> {
+    return dripsGet(
+        `/api/issues?waveProgramId=${programId}&state=open&page=${page}&limit=${limit}&sortBy=updatedAt`,
+    );
+}
+
+async function getWaveProgram(slug: string): Promise<DripsProgram> {
+    const data = await dripsGet(`/api/wave-programs?slug=${encodeURIComponent(slug)}`);
+    if (data?.id) return data as DripsProgram;
+    if (Array.isArray(data?.data) && data.data.length > 0) return data.data[0] as DripsProgram;
+    throw new Error(`Wave program "${slug}" not found. Check the slug or URL.`);
+}
+
 // ── Auth ──────────────────────────────────────────────────────────────────────
 
 export async function ensureDripsAuth(): Promise<string> {
     const config = loadConfig();
 
     if (config.dripsToken) {
-        // Validate by hitting a quota endpoint that requires auth
         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 as string;
-        } catch { /* network issue, let user try anyway */ }
+        } catch { /* network issue */ }
     }
 
-    // Show how-to instructions
     console.log();
     console.log(dim('  ┌─ Connect your Drips Network account ────────────────────────┐'));
     console.log(dim('  │'));
-    console.log(dim('  │  Drips uses GitHub OAuth. Here\'s how to get your token:'));
-    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 now)'));
+    console.log(dim('  │     (GitPadi will open it in your browser)'));
     console.log(dim('  │'));
-    console.log(dim('  │  2. After logging in with GitHub, open DevTools:'));
-    console.log(dim('  │     ') + bold('F12') + dim(' (or Cmd+Option+I on Mac)'));
-    console.log(dim('  │     → ') + bold('Application') + dim(' tab'));
-    console.log(dim('  │     → ') + bold('Cookies') + dim(' → ') + cyan('www.drips.network'));
+    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 named ') + yellow('wave_access_token'));
-    console.log(dim('  │     Copy the full value (it starts with ') + dim('eyJ...') + 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('  │  GitPadi saves it once — you won\'t need to do this again.'));
+    console.log(dim('  │  This is a one-time step — GitPadi saves it for future use.'));
     console.log(dim('  │'));
     console.log(dim('  └─────────────────────────────────────────────────────────────┘'));
     console.log();
@@ -186,98 +292,343 @@ export async function ensureDripsAuth(): Promise<string> {
         mask: '•',
         validate: (v: string) => {
             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 — make sure you copied wave_access_token, not another cookie';
+            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 — you\'re all set!\n'));
+    console.log(green('\n  ✅ Drips session saved.\n'));
     return t;
 }
 
-// ── Program lookup ────────────────────────────────────────────────────────────
+// ── Profile setup ─────────────────────────────────────────────────────────────
 
-async function getWaveProgram(slug: string): Promise<DripsProgram> {
-    const data = await dripsGet(`/api/wave-programs?slug=${encodeURIComponent(slug)}`);
-    if (data?.id) return data as DripsProgram;
-    if (Array.isArray(data?.data) && data.data.length > 0) return data.data[0] as DripsProgram;
-    throw new Error(`Wave program "${slug}" not found. Check the slug or URL.`);
-}
+async function setupProfile(existing?: DripsProfile): Promise<DripsProfile> {
+    console.log();
+    console.log(bold('  Set up your Drips profile — GitPadi uses this to find the right issues for you.'));
+    console.log();
 
-// ── Issues ────────────────────────────────────────────────────────────────────
+    const { programInput } = await inquirer.prompt([{
+        type: 'input',
+        name: 'programInput',
+        message: bold('Drips Wave program (slug or URL):'),
+        default: existing?.programSlug || 'stellar',
+    }]);
 
-async function getIssues(
-    programId: string,
-    page: number,
-): Promise<{ data: DripsIssue[]; pagination: DripsPagination }> {
-    return dripsGet(
-        `/api/issues?waveProgramId=${programId}&state=open&page=${page}&limit=20&sortBy=updatedAt`,
-    );
+    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: string) => 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 ?? 100,
+        choices: [
+            { name: `  Any (including unspecified)`, value: 0 },
+            { name: `  100 pts`,                    value: 100 },
+            { name: `  150 pts`,                    value: 150 },
+            { name: `  200 pts`,                    value: 200 },
+        ],
+    }]);
+
+    const techStack = stackInput.split(',').map((s: string) => s.trim()).filter(Boolean);
+    const programSlug = parseSlug(programInput.trim());
+
+    const profile: DripsProfile = { track, techStack, minPoints, programSlug };
+    saveProfile(profile);
+
+    console.log(green(`\n  ✅ Profile saved — track: ${bold(track)}, stack: ${techStack.join(', ')}, min: ${minPoints}pts\n`));
+    return profile;
 }
 
-// ── Main menu ─────────────────────────────────────────────────────────────────
+// ── Auto-apply ────────────────────────────────────────────────────────────────
 
-export async function dripsMenu(): Promise<void> {
+async function autoApply(program: DripsProgram, profile: DripsProfile): Promise<void> {
     console.log();
-    console.log(bold('  Drips Network — Apply for bounty issues from your terminal'));
-    console.log(dim('  Browse issues from any Wave program and apply in seconds.'));
+    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 { input } = await inquirer.prompt([{
-        type: 'input',
-        name: 'input',
-        message: bold('Enter Drips Wave URL or program slug:'),
-        default: 'stellar',
-        validate: (v: string) => v.trim().length > 0 || 'Required',
+    const spinner = ora(dim('  Fetching open issues…')).start();
+    const scored: ScoredIssue[] = [];
+    let page = 1;
+    const MAX_PAGES = 10; // scan up to 500 issues
+
+    while (page <= MAX_PAGES) {
+        let data: DripsIssue[];
+        let pagination: DripsPagination;
+
+        try {
+            const res = await fetchIssuePage(program.id, page, 50);
+            data = res.data;
+            pagination = res.pagination;
+        } catch (e: any) {
+            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
+    // Pre-compute org counts to show how many slots remain per org
+    const previewOrgCounts = new Map<string, number>();
+    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 org = extractOrg(issue);
+        const orgSlots = ORG_APPLICATION_LIMIT - (previewOrgCounts.get(org) || 0);
+        const orgTag = dim(`(${org} ${orgSlots}/${ORG_APPLICATION_LIMIT} slots)`);
+        const title = truncate(issue.title, 40);
+        const autoCheck = score >= 1 && orgSlots > 0;
+        if (autoCheck) previewOrgCounts.set(org, (previewOrgCounts.get(org) || 0) + 1);
+        return {
+            name: `  ${pts}  ${bold(title)}  ${match}  ${applicants}  ${orgTag}`,
+            value: issue,
+            checked: autoCheck,
+        };
+    });
+
+    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: any[]) => selected.length > 0 || 'Select at least one issue',
     }]);
 
-    const slug = parseSlug(input.trim());
+    if (!selectedIssues || selectedIssues.length === 0) {
+        console.log(dim('\n  No issues selected.\n'));
+        return;
+    }
 
-    const progSpinner = ora(dim(`  Loading "${slug}" wave program…`)).start();
-    let program: DripsProgram;
+    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: string;
+    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: string) => 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: string;
     try {
-        program = await getWaveProgram(slug);
-        progSpinner.succeed(
-            `  ${bold(program.name)} · ${cyan(program.issueCount.toLocaleString() + ' open issues')} · ${green(program.presetBudgetUSD + '/mo')} · ${dim(program.approvedRepoCount + ' repos')}`
-        );
-    } catch (e: any) {
-        progSpinner.fail(`  ${e.message}`);
+        token = await ensureDripsAuth();
+    } catch {
+        console.log(red('\n  Authentication cancelled.\n'));
         return;
     }
 
+    console.log();
+    let applied = 0;
+    let failed = 0;
+    let skipped = 0;
+    const orgCounts = new Map<string, number>();
+
+    for (const issue of selectedIssues as DripsIssue[]) {
+        const org = extractOrg(issue);
+        const orgCount = orgCounts.get(org) || 0;
+
+        if (orgCount >= ORG_APPLICATION_LIMIT) {
+            console.log(yellow(`  ⚠  Skipped: ${truncate(issue.title, 50)} — already applied to ${ORG_APPLICATION_LIMIT} issues from ${org}`));
+            skipped++;
+            continue;
+        }
+
+        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,
+            );
+            orgCounts.set(org, orgCount + 1);
+            spinner.succeed(green(`  ✅ ${truncate(issue.title, 55)}`) + (issue.points ? dim(` (+${issue.points}pts)`) : '') + dim(` [${org}: ${orgCount + 1}/${ORG_APPLICATION_LIMIT}]`));
+            applied++;
+        } catch (e: any) {
+            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')}${skipped > 0 ? ', ' + yellow(skipped + ' skipped (org limit)') : ''}${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: DripsProgram, profile: DripsProfile): Promise<void> {
+    // 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: Track = browseTrack;
     let page = 1;
 
     while (true) {
-        const issSpinner = ora(dim(`  Fetching issues (page ${page})…`)).start();
-        let issues: DripsIssue[];
-        let pagination: DripsPagination;
+        const spinner = ora(dim(`  Fetching unassigned issues (page ${page})…`)).start();
+        let allIssues: DripsIssue[] = [];
+        let hasNextPage = false;
+        let totalFetched = 0;
+
+        // Fetch a batch and filter client-side for unassigned + track
         try {
-            const res = await getIssues(program.id, page);
-            issues = res.data;
-            pagination = res.pagination;
-            issSpinner.succeed(
-                `  Showing ${((page - 1) * 20) + 1}–${Math.min(page * 20, pagination.total)} of ${pagination.total.toLocaleString()} open issues`
+            // 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: any) {
-            issSpinner.fail(`  ${e.message}`);
+            spinner.fail(`  ${e.message}`);
             return;
         }
 
-        console.log();
+        if (allIssues.length === 0) {
+            console.log(yellow(`\n  No unassigned ${selectedTrack} issues found on this page. Try next page or change track.\n`));
+        }
 
-        const choices = issues.map((issue) => {
+        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 pts = issue.points ? green(`+${issue.points}pts`) : dim('  —pts');
             const applicants = issue.pendingApplicationsCount > 0
-                ? yellow(`${issue.pendingApplicationsCount} applied`)
-                : dim('0 applied');
-            const taken = issue.assignedApplicant ? red(' [assigned]') : '';
-            const title = truncate(issue.title, 48);
+                ? 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)}  ${applicants}${taken}  ${ageStr}`,
+                name: `  ${pts}  ${bold(title)}  ${trackTag}  ${applicants}  ${ageStr}`,
                 value: issue,
                 short: issue.title,
             };
@@ -286,15 +637,15 @@ export async function dripsMenu(): Promise<void> {
         const nav: any[] = [
             new inquirer.Separator(dim('  ─────────────────────────────────────────────────────')),
         ];
-        if (pagination.hasNextPage) nav.push({ name: `  ${dim('→  Next page')}`, value: '__next__' });
+        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} Wave — choose an issue to apply for:`),
-            choices: [...choices, ...nav],
+            message: bold(`${program.name} — ${selectedTrack} issues sorted by points:`),
+            choices: allIssues.length > 0 ? [...choices, ...nav] : nav,
             pageSize: 18,
         }]);
 
@@ -302,34 +653,29 @@ export async function dripsMenu(): Promise<void> {
         if (selected === '__next__') { page++; continue; }
         if (selected === '__prev__') { page = Math.max(1, page - 1); continue; }
 
-        await applyToDripsIssue(program, selected as DripsIssue);
+        await applySingle(program, selected as DripsIssue, profile);
     }
 }
 
-// ── Apply ─────────────────────────────────────────────────────────────────────
+// ── Apply single ──────────────────────────────────────────────────────────────
 
-async function applyToDripsIssue(program: DripsProgram, issue: DripsIssue): Promise<void> {
+async function applySingle(program: DripsProgram, issue: DripsIssue, profile: DripsProfile): Promise<void> {
     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.assignedApplicant) {
-        console.log(`  ${yellow('⚠  Already assigned — you can still apply as a backup')}`);
-    }
-    if (issue.gitHubIssueUrl) {
-        console.log(`  ${dim('GitHub:  ')} ${dim(issue.gitHubIssueUrl)}`);
-    }
+    if (issue.gitHubIssueUrl) console.log(`  ${dim('GitHub:  ')} ${dim(issue.gitHubIssueUrl)}`);
     console.log();
 
     const { style } = await inquirer.prompt([{
         type: 'list',
         name: 'style',
-        message: bold('How would you like to apply?'),
+        message: bold('Application style:'),
         choices: [
-            { name: `  ${green('⚡')}  Quick apply — standard intro message`, value: 'quick' },
-            { name: `  ${cyan('📝')}  Custom message — write your own`, value: 'custom' },
-            new inquirer.Separator(dim('  ─────────────────────────────────')),
+            { name: `  ${green('⚡')}  Quick — standard intro`, value: 'quick' },
+            { name: `  ${cyan('📝')}  Custom — write your own`, value: 'custom' },
+            new inquirer.Separator(dim('  ────────────────')),
             { name: `  ${dim('⬅  Cancel')}`, value: 'cancel' },
         ],
     }]);
@@ -337,49 +683,33 @@ async function applyToDripsIssue(program: DripsProgram, issue: DripsIssue): Prom
     if (style === 'cancel') return;
 
     let applicationText: string;
-
     if (style === 'quick') {
-        applicationText = [
-            `Hi! I'd like to work on this issue.`,
-            ``,
-            `I'm available to start right away and will keep you updated on progress. Please consider assigning this to me.`,
-            ``,
-            `*Applied via [GitPadi](https://github.com/Netwalls/contributor-agent)*`,
-        ].join('\n');
+        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 application message (min 10 chars):'),
-            validate: (v: string) => v.trim().length >= 10 || 'Please write at least 10 characters',
+            message: bold('Your message:'),
+            validate: (v: string) => v.trim().length >= 10 || 'Write at least 10 characters',
         }]);
-        applicationText = [
-            msg.trim(),
-            ``,
-            `*Applied via [GitPadi](https://github.com/Netwalls/contributor-agent)*`,
-        ].join('\n');
+        applicationText = `${msg.trim()}\n\n*Applied via [GitPadi](https://github.com/Netwalls/contributor-agent)*`;
     }
 
-    // Preview
     console.log();
-    console.log(dim('  ── Preview ───────────────────────────────────────────────────'));
+    console.log(dim('  ── Preview ────────────────────────────────────────────────────'));
     applicationText.split('\n').forEach(l => console.log(`  ${dim(l)}`));
-    console.log(dim('  ──────────────────────────────────────────────────────────────'));
+    console.log(dim('  ───────────────────────────────────────────────────────────────'));
     console.log();
 
     const { confirm } = await inquirer.prompt([{
-        type: 'list',
+        type: 'confirm',
         name: 'confirm',
-        message: bold('Submit this application?'),
-        choices: [
-            { name: `  ${green('✅  Yes, apply')}`, value: 'yes' },
-            { name: `  ${dim('❌  Cancel')}`, value: 'no' },
-        ],
+        message: bold('Submit application?'),
+        default: true,
     }]);
 
-    if (confirm === 'no') return;
+    if (!confirm) return;
 
-    // Ensure auth only when the user actually commits to applying
     let token: string;
     try {
         token = await ensureDripsAuth();
@@ -388,16 +718,15 @@ async function applyToDripsIssue(program: DripsProgram, issue: DripsIssue): Prom
         return;
     }
 
-    const spinner = ora('  Submitting application…').start();
+    const spinner = ora('  Submitting…').start();
     try {
         await dripsPost(
             `/api/wave-programs/${program.id}/issues/${issue.id}/applications`,
             { applicationText },
             token,
         );
-        spinner.succeed(green(`  Applied for: ${bold(issue.title)}`));
-        console.log(dim(`\n  Track your applications:`));
-        console.log(dim(`  ${cyan(DRIPS_WEB + '/wave/' + program.slug)}\n`));
+        spinner.succeed(green(`  ✅ Applied! ${bold(issue.title)}`));
+        console.log(dim(`\n  Track: ${cyan(DRIPS_WEB + '/wave/' + program.slug)}\n`));
     } catch (e: any) {
         spinner.fail(red(`  Failed: ${e.message}`));
         if (e.message.startsWith('401')) {
@@ -406,3 +735,75 @@ async function applyToDripsIssue(program: DripsProgram, issue: DripsIssue): Prom
         }
     }
 }
+
+// ── Main menu ─────────────────────────────────────────────────────────────────
+
+export async function dripsMenu(): Promise<void> {
+    // 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: DripsProgram;
+    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: any) {
+        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: any) {
+                    s.fail(`  ${e.message}`);
+                }
+            }
+        }
+    }
+}