gitpadi 2.0.6 → 2.1.1

package/src/cli.ts

@@ -10,12 +10,17 @@ import inquirer from 'inquirer';
 import gradient from 'gradient-string';
 import figlet from 'figlet';
 import os from 'node:os';
-import { execSync } from 'child_process';
+import { execFileSync } from 'child_process';
 
 import boxen from 'boxen';
 import { createSpinner } from 'nanospinner';
 import { Octokit } from '@octokit/rest';
-import { initGitHub, setRepo, getOwner, getRepo, getOctokit, loadConfig, saveConfig, getToken, getAuthenticatedUser } from './core/github.js';
+import { initGitHub, setRepo, getOwner, getRepo, getOctokit, loadConfig, saveConfig, getToken, getAuthenticatedUser, getRepoPermissions } from './core/github.js';
+import {
+    initGitLab, getGitLabToken, getNamespace, getProject, getFullProject,
+    saveGitLabConfig, savePlatformPreference, loadPlatformPreference,
+    getAuthenticatedGitLabUser, getGitLabProject, setGitLabProject,
+} from './core/gitlab.js';
 
 import * as issues from './commands/issues.js';
 import * as prs from './commands/prs.js';
@@ -23,8 +28,15 @@ import * as repos from './commands/repos.js';
 import * as contributors from './commands/contributors.js';
 import * as releases from './commands/releases.js';
 import * as contribute from './commands/contribute.js';
+import * as applyForIssue from './commands/apply-for-issue.js';
+import { runBountyHunter } from './commands/bounty-hunter.js';
+import * as gitlabIssues from './commands/gitlab-issues.js';
+import * as gitlabMRs from './commands/gitlab-mrs.js';
+import * as gitlabPipelines from './commands/gitlab-pipelines.js';
 
-const VERSION = '2.0.0';
+const VERSION = '2.1.1';
+let targetConfirmed = false;
+let gitlabProjectConfirmed = false;
 
 // ── Styling ────────────────────────────────────────────────────────────
 const cyber = gradient(['#ff00ff', '#00ffff', '#ff00ff']);
@@ -114,7 +126,7 @@ async function bootSequence() {
     const bootSteps = [
         '▸ Initializing GitPadi engine',
         '▸ Loading command modules',
-        '▸ Establishing GitHub connection',
+        '▸ Connecting to GitHub & GitLab',
         '▸ Systems online',
     ];
 
@@ -149,6 +161,19 @@ async function ensureAuthenticated() {
 
     console.log(neon('  ⚡ Authentication — let\'s connect you to GitHub.\n'));
 
+    console.log(dim('  ┌─ How to get your GitHub Token ──────────────────────────────┐'));
+    console.log(dim('  │'));
+    console.log(dim('  │  1. Open: ') + cyan('https://github.com/settings/tokens'));
+    console.log(dim('  │  2. Click ') + bold('"Generate new token (classic)"'));
+    console.log(dim('  │  3. Give it a name (e.g. "gitpadi")'));
+    console.log(dim('  │  4. Select scopes: ') + yellow('repo') + dim('  (and ') + yellow('read:org') + dim(' for org repos)'));
+    console.log(dim('  │  5. Click "Generate token" and copy it'));
+    console.log(dim('  │'));
+    console.log(dim('  │  The token will look like: ') + dim('ghp_xxxxxxxxxxxxxxxxxxxx'));
+    console.log(dim('  │'));
+    console.log(dim('  └─────────────────────────────────────────────────────────────┘'));
+    console.log('');
+
     const { t } = await inquirer.prompt([{
         type: 'password',
         name: 't',
@@ -183,7 +208,18 @@ async function ensureTargetRepo(force = false) {
     let repo = getRepo();
 
     if (!force && owner && repo) {
-        return;
+        if (targetConfirmed) return;
+
+        const { confirm } = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'confirm',
+            message: cyan('🎯 Targeting ') + bold(`${owner}/${repo}`) + cyan('. Correct?'),
+            default: true
+        }]);
+        if (confirm) {
+            targetConfirmed = true;
+            return;
+        }
     }
 
     console.log(neon('\n  📦 Project Targeting — which repo are we working on?\n'));
@@ -240,38 +276,706 @@ async function ensureTargetRepo(force = false) {
 
     setRepo(targetOwner, repo as string);
     saveConfig({ token: getToken(), owner: targetOwner, repo: repo as string });
+    targetConfirmed = true;
+
+    // 4. Permission Check (for Maintainer safety)
+    const checkSpin = createSpinner(dim('Checking maintainer permissions...')).start();
+    try {
+        const perms = await getRepoPermissions(targetOwner, repo as string);
+        if (!perms.push && !perms.admin) {
+            checkSpin.warn({ text: yellow(`Limited Access → ${cyan(`${targetOwner}/${repo}`)}`) });
+            console.log(boxen(
+                chalk.yellow(`🛡️  Maintainer Mode Warning\n\n`) +
+                chalk.dim(`You do not have push/admin permissions for this repository.\n`) +
+                chalk.dim(`Most maintainer actions (bulk issues, merging PRs) will fail.`),
+                { padding: 1, borderColor: 'yellow', borderStyle: 'round' }
+            ));
+
+            const { proceed } = await inquirer.prompt([{
+                type: 'confirm',
+                name: 'proceed',
+                message: 'Continue anyway?',
+                default: false
+            }]);
+
+            if (!proceed) {
+                targetConfirmed = false;
+                throw new BackToMenu();
+            }
+        } else {
+            checkSpin.success({ text: green(`Permissions verified for ${cyan(`${targetOwner}/${repo}`)}`) });
+        }
+    } catch {
+        checkSpin.warn({ text: yellow('Could not verify permissions (API limit or private)') });
+    }
 
     console.log(green(`\n  ✅ Locked in → ${cyan(`${targetOwner}/${repo}`)}\n`));
 }
 
+// ── GitLab Authentication ───────────────────────────────────────────────
+async function ensureGitLabAuthenticated() {
+    initGitLab();
+    let token = getGitLabToken();
+
+    if (token) {
+        try {
+            await getAuthenticatedGitLabUser();
+            return; // token valid
+        } catch {
+            console.log(red('  ❌ Saved GitLab session invalid. Re-authenticating...'));
+            token = '';
+        }
+    }
+
+    console.log(neon('\n  ⚡ GitLab Authentication — connect your account.\n'));
+
+    console.log(dim('  ┌─ How to get your GitLab Personal Access Token ──────────────┐'));
+    console.log(dim('  │'));
+    console.log(dim('  │  1. Open: ') + cyan('https://gitlab.com/-/user_settings/personal_access_tokens'));
+    console.log(dim('  │  2. Click ') + bold('"Add new token"'));
+    console.log(dim('  │  3. Give it a name (e.g. "gitpadi") and set an expiry date'));
+    console.log(dim('  │  4. Select scopes: ') + yellow('api') + dim('  (covers read/write access)'));
+    console.log(dim('  │  5. Click "Create personal access token" and copy it'));
+    console.log(dim('  │'));
+    console.log(dim('  │  The token will look like: ') + dim('glpat-xxxxxxxxxxxxxxxxxxxx'));
+    console.log(dim('  │  For self-hosted GitLab, use your own host in the next step.'));
+    console.log(dim('  │'));
+    console.log(dim('  └─────────────────────────────────────────────────────────────┘'));
+    console.log('');
+
+    const { host } = await inquirer.prompt([{
+        type: 'input',
+        name: 'host',
+        message: cyan('🌐 GitLab host:'),
+        default: 'https://gitlab.com',
+    }]);
+
+    const { t } = await inquirer.prompt([{
+        type: 'password',
+        name: 't',
+        message: magenta('🔑 GitLab Personal Access Token') + dim(' (glpat-xxx):'),
+        mask: '•',
+        validate: async (v: string) => {
+            if (!v.startsWith('glpat-') && !v.startsWith('gl-')) {
+                return 'Token should start with glpat-';
+            }
+            const spinner = createSpinner(dim('Validating token...')).start();
+            try {
+                // Temp init to validate
+                const tmpRes = await fetch(`${host.replace(/\/$/, '')}/api/v4/user`, {
+                    headers: { 'PRIVATE-TOKEN': v },
+                });
+                if (!tmpRes.ok) throw new Error('Invalid');
+                spinner.success({ text: green('Token valid!') });
+                return true;
+            } catch {
+                spinner.error({ text: red('Invalid token — GitLab rejected it.') });
+                return 'Invalid token';
+            }
+        },
+    }]);
+
+    saveGitLabConfig(t, host, '', '');
+    initGitLab(t, '', '', host);
+    const user = await getAuthenticatedGitLabUser();
+    console.log(green(`\n  ✅ Authenticated as @${user.username}\n`));
+}
+
+/**
+ * Prompts user to select a GitLab project (namespace/project)
+ */
+async function ensureGitLabProject(force = false) {
+    let ns = getNamespace();
+    let proj = getProject();
+
+    if (!force && ns && proj) {
+        if (gitlabProjectConfirmed) return;
+        const { confirm } = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'confirm',
+            message: cyan('🎯 Targeting ') + bold(`${ns}/${proj}`) + cyan('. Correct?'),
+            default: true,
+        }]);
+        if (confirm) { gitlabProjectConfirmed = true; return; }
+    }
+
+    console.log(neon('\n  📦 GitLab Project — which project are we working on?\n'));
+
+    const user = await getAuthenticatedGitLabUser();
+
+    const { targetNs } = await inquirer.prompt([{
+        type: 'input',
+        name: 'targetNs',
+        message: cyan('👤 Namespace (user or group):'),
+        default: ns || user.username,
+        validate: (v: string) => v.length > 0 || 'Required',
+    }]);
+
+    const { targetProj } = await inquirer.prompt([{
+        type: 'input',
+        name: 'targetProj',
+        message: cyan('📦 Project path:'),
+        default: proj || '',
+        validate: (v: string) => v.length > 0 || 'Required',
+    }]);
+
+    // Verify project exists
+    const spin = createSpinner(dim(`Verifying ${targetNs}/${targetProj}...`)).start();
+    try {
+        const project = await getGitLabProject(targetNs, targetProj);
+        spin.success({ text: green(`Found: ${project.path_with_namespace}`) });
+    } catch {
+        spin.warn({ text: yellow('Could not verify project — proceeding anyway.') });
+    }
+
+    setGitLabProject(targetNs, targetProj);
+    gitlabProjectConfirmed = true;
+    console.log(green(`\n  ✅ Locked in → ${cyan(`${targetNs}/${targetProj}`)}\n`));
+}
+
+// ── GitLab Maintainer Menu ─────────────────────────────────────────────
+async function gitlabMaintainerMenu() {
+    while (true) {
+        line('═');
+        console.log(gradient(['#FC6D26', '#E24329'])('  🦊 GITPADI GITLAB MAINTAINER'));
+        console.log(dim('  Manage issues, merge requests, and pipelines'));
+        line('═');
+        console.log('');
+
+        const { category } = await inquirer.prompt([{
+            type: 'list',
+            name: 'category',
+            message: bold('Select operation:'),
+            choices: [
+                { name: `${magenta('📋')}  ${bold('Issues')}         ${dim('— create, close, comment')}`, value: 'issues' },
+                { name: `${cyan('🔀')}  ${bold('Merge Requests')} ${dim('— list, merge, review, diff')}`, value: 'mrs' },
+                { name: `${yellow('🔧')}  ${bold('Pipelines')}      ${dim('— list, view jobs, read logs')}`, value: 'pipelines' },
+                new inquirer.Separator(dim('  ─────────────────────────────')),
+                { name: `${dim('⚙️')}   ${dim('Switch Project')}`, value: 'switch' },
+                { name: `${dim('⬅')}   ${dim('Back to Mode Selector')}`, value: 'back' },
+            ],
+            loop: false,
+        }]);
+
+        if (category === 'back') break;
+
+        if (category === 'switch') {
+            await ensureGitLabProject(true);
+            continue;
+        }
+
+        if (category === 'issues') await safeMenu(gitlabIssueMenu);
+        else if (category === 'mrs') await safeMenu(gitlabMRMenu);
+        else if (category === 'pipelines') await safeMenu(gitlabPipelineMenu);
+
+        console.log('');
+    }
+}
+
+async function gitlabIssueMenu() {
+    const { action } = await inquirer.prompt([{
+        type: 'list', name: 'action', message: magenta('📋 Issue Operation:'),
+        choices: [
+            { name: `  ${dim('⬅  Back')}`, value: 'back' },
+            new inquirer.Separator(dim('  ─────────────────────────────')),
+            { name: `  ${green('▸')} List issues`, value: 'list' },
+            { name: `  ${green('▸')} Create issue`, value: 'create' },
+            { name: `  ${red('▸')} Close issue`, value: 'close' },
+            { name: `  ${green('▸')} Reopen issue`, value: 'reopen' },
+            { name: `  ${cyan('▸')} Comment on issue`, value: 'comment' },
+        ],
+    }]);
+
+    if (action === 'back') return;
+
+    if (action === 'list') {
+        const a = await ask([
+            { type: 'list', name: 'state', message: 'State:', choices: ['opened', 'closed', 'all'], default: 'opened' },
+            { type: 'input', name: 'limit', message: dim('Max results:'), default: '50' },
+        ]);
+        await gitlabIssues.listIssues({ state: a.state, limit: parseInt(a.limit) });
+    } else if (action === 'create') {
+        const a = await ask([
+            { type: 'input', name: 'title', message: yellow('Issue title'), validate: (v: string) => v.length > 0 || 'Required' },
+            { type: 'input', name: 'description', message: dim('Description (optional):'), default: '' },
+            { type: 'input', name: 'labels', message: dim('Labels (comma-separated):'), default: '' },
+        ]);
+        await gitlabIssues.createIssue({ title: a.title, description: a.description || undefined, labels: a.labels || undefined });
+    } else if (action === 'close' || action === 'reopen') {
+        const { n } = await ask([{ type: 'input', name: 'n', message: yellow('Issue #') + dim(' (q=back):') }]);
+        if (!n || isNaN(Number(n))) return;
+        if (action === 'close') await gitlabIssues.closeIssue(parseInt(n));
+        else await gitlabIssues.reopenIssue(parseInt(n));
+    } else if (action === 'comment') {
+        const a = await ask([
+            { type: 'input', name: 'n', message: yellow('Issue #') + dim(' (q=back):') },
+            { type: 'input', name: 'body', message: cyan('Comment:') },
+        ]);
+        if (!a.n || isNaN(Number(a.n))) return;
+        await gitlabIssues.commentOnIssue(parseInt(a.n), a.body);
+    }
+}
+
+async function gitlabMRMenu() {
+    const { action } = await inquirer.prompt([{
+        type: 'list', name: 'action', message: cyan('🔀 Merge Request Operation:'),
+        choices: [
+            { name: `  ${dim('⬅  Back')}`, value: 'back' },
+            new inquirer.Separator(dim('  ─────────────────────────────')),
+            { name: `  ${green('▸')} List merge requests`, value: 'list' },
+            { name: `  ${green('▸')} Merge MR ${dim('(checks pipeline first)')}`, value: 'merge' },
+            { name: `  ${yellow('▸')} Force merge ${dim('(skip pipeline)')}`, value: 'force-merge' },
+            { name: `  ${red('▸')} Close MR`, value: 'close' },
+            { name: `  ${yellow('▸')} Review MR`, value: 'review' },
+            { name: `  ${cyan('▸')} View diff`, value: 'diff' },
+        ],
+    }]);
+
+    if (action === 'back') return;
+
+    if (action === 'list') {
+        const a = await ask([
+            { type: 'list', name: 'state', message: 'State:', choices: ['opened', 'closed', 'merged', 'all'], default: 'opened' },
+            { type: 'input', name: 'limit', message: dim('Max results:'), default: '50' },
+        ]);
+        await gitlabMRs.listMRs({ state: a.state, limit: parseInt(a.limit) });
+    } else if (action === 'merge' || action === 'force-merge') {
+        const a = await ask([
+            { type: 'input', name: 'n', message: yellow('MR !') + dim('(q=back):') },
+            { type: 'confirm', name: 'squash', message: 'Squash commits?', default: true },
+            { type: 'confirm', name: 'confirm', message: action === 'force-merge' ? yellow('⚠️  Force merge (skip pipeline)?') : red('⚠️  Merge this MR?'), default: false },
+        ]);
+        if (a.confirm) await gitlabMRs.mergeMR(parseInt(a.n), { squash: a.squash, force: action === 'force-merge' });
+    } else {
+        const { n } = await ask([{ type: 'input', name: 'n', message: yellow('MR !') + dim('(q=back):') }]);
+        if (!n || isNaN(Number(n))) return;
+        if (action === 'close') await gitlabMRs.closeMR(parseInt(n));
+        else if (action === 'review') await gitlabMRs.reviewMR(parseInt(n));
+        else await gitlabMRs.diffMR(parseInt(n));
+    }
+}
+
+async function gitlabPipelineMenu() {
+    const { action } = await inquirer.prompt([{
+        type: 'list', name: 'action', message: yellow('🔧 Pipeline Operation:'),
+        choices: [
+            { name: `  ${dim('⬅  Back')}`, value: 'back' },
+            new inquirer.Separator(dim('  ─────────────────────────────')),
+            { name: `  ${green('▸')} List pipelines`, value: 'list' },
+            { name: `  ${cyan('▸')} View pipeline jobs`, value: 'jobs' },
+            { name: `  ${cyan('▸')} View job log`, value: 'log' },
+        ],
+    }]);
+
+    if (action === 'back') return;
+
+    if (action === 'list') {
+        const a = await ask([
+            { type: 'input', name: 'ref', message: dim('Branch/ref (blank for all):'), default: '' },
+            { type: 'input', name: 'limit', message: dim('Max results:'), default: '20' },
+        ]);
+        await gitlabPipelines.listPipelines({ ref: a.ref || undefined, limit: parseInt(a.limit) });
+    } else if (action === 'jobs') {
+        const { n } = await ask([{ type: 'input', name: 'n', message: yellow('Pipeline ID:') + dim(' (q=back):') }]);
+        if (!n || isNaN(Number(n))) return;
+        await gitlabPipelines.viewPipelineJobs(parseInt(n));
+    } else if (action === 'log') {
+        const { n } = await ask([{ type: 'input', name: 'n', message: yellow('Job ID:') + dim(' (q=back):') }]);
+        if (!n || isNaN(Number(n))) return;
+        await gitlabPipelines.viewJobLog(parseInt(n));
+    }
+}
+
+// ── Platform Selector ──────────────────────────────────────────────────
+async function selectPlatform(): Promise<'github' | 'gitlab'> {
+    const saved = loadPlatformPreference();
+    if (saved) {
+        const { keepPlatform } = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'keepPlatform',
+            message: `${dim('Last session:')} ${saved === 'github' ? cyan('GitHub') : gradient(['#FC6D26', '#E24329'])('GitLab')} — continue with this?`,
+            default: true,
+        }]);
+        if (keepPlatform) return saved;
+    }
+
+    const { platform } = await inquirer.prompt([{
+        type: 'list',
+        name: 'platform',
+        message: bold('Choose your platform:'),
+        choices: [
+            { name: `${cyan('🐙')}  ${bold('GitHub')}  ${dim('— github.com')}`, value: 'github' },
+            { name: `${gradient(['#FC6D26', '#E24329'])('🦊')}  ${bold('GitLab')}  ${dim('— gitlab.com or self-hosted')}`, value: 'gitlab' },
+        ],
+        loop: false,
+    }]);
+
+    savePlatformPreference(platform);
+    return platform;
+}
+
 // ── Mode Selector ──────────────────────────────────────────────────────
 async function mainMenu() {
+    const platform = await selectPlatform();
+
+    // Authenticate for selected platform
+    if (platform === 'gitlab') {
+        await ensureGitLabAuthenticated();
+    }
+
     while (true) {
         line('═');
-        console.log(cyber('  ⟨ GITPADI MODE SELECTOR ⟩'));
+        const platformLabel = platform === 'github'
+            ? cyan('GitHub')
+            : gradient(['#FC6D26', '#E24329'])('GitLab');
+        console.log(cyber(`  ⟨ GITPADI MODE SELECTOR ⟩`) + dim(`  [${platformLabel}]`));
         console.log(dim('  Select your workflow persona to continue'));
         line('═');
         console.log('');
 
-        const { mode } = await inquirer.prompt([{
+        if (platform === 'github') {
+            const { mode } = await inquirer.prompt([{
+                type: 'list',
+                name: 'mode',
+                message: bold('Choose your path:'),
+                choices: [
+                    { name: `${cyan('✨')}  ${bold('Contributor Mode')}    ${dim('— fork, clone, sync, submit PRs')}`, value: 'contributor' },
+                    { name: `${magenta('🛠️')}  ${bold('Maintainer Mode')}     ${dim('— manage issues, PRs, contributors')}`, value: 'maintainer' },
+                    { name: `${yellow('🏫')}  ${bold('Organization/School')} ${dim('— assignments, grading, leaderboard')}`, value: 'org' },
+                    new inquirer.Separator(dim('  ─────────────────────────────')),
+                    { name: `${dim('🔄')}  ${dim('Switch Platform')}`, value: 'switch' },
+                    { name: `${dim('👋')}  ${dim('Exit')}`, value: 'exit' },
+                ],
+                loop: false,
+            }]);
+
+            if (mode === 'exit') break;
+            if (mode === 'switch') { savePlatformPreference('gitlab'); return mainMenu(); }
+            if (mode === 'contributor') await safeMenu(contributorMenu);
+            else if (mode === 'maintainer') {
+                await ensureTargetRepo();
+                await safeMenu(maintainerMenu);
+            } else if (mode === 'org') {
+                await ensureTargetRepo();
+                await safeMenu(orgMenu);
+            }
+        } else {
+            // GitLab mode
+            const { mode } = await inquirer.prompt([{
+                type: 'list',
+                name: 'mode',
+                message: bold('Choose your path:'),
+                choices: [
+                    { name: `${gradient(['#FC6D26', '#E24329'])('🛠️')}  ${bold('GitLab Maintainer')} ${dim('— issues, MRs, pipelines')}`, value: 'gl-maintainer' },
+                    new inquirer.Separator(dim('  ─────────────────────────────')),
+                    { name: `${dim('🔄')}  ${dim('Switch Platform')}`, value: 'switch' },
+                    { name: `${dim('👋')}  ${dim('Exit')}`, value: 'exit' },
+                ],
+                loop: false,
+            }]);
+
+            if (mode === 'exit') break;
+            if (mode === 'switch') { savePlatformPreference('github'); return mainMenu(); }
+            if (mode === 'gl-maintainer') {
+                await ensureGitLabProject();
+                await safeMenu(gitlabMaintainerMenu);
+            }
+        }
+    }
+}
+
+// ── Organization / School Menu ─────────────────────────────────────────
+async function orgMenu() {
+    while (true) {
+        line('═');
+        console.log(yellow('  🏫 GITPADI ORGANIZATION / SCHOOL'));
+        console.log(dim('  Create assignments, grade PRs, track student performance'));
+        line('═');
+        console.log('');
+
+        const { action } = await inquirer.prompt([{
             type: 'list',
-            name: 'mode',
-            message: bold('Choose your path:'),
+            name: 'action',
+            message: bold('Select operation:'),
             choices: [
-                { name: `${cyan('✨')}  ${bold('Contributor Mode')}  ${dim('— fork, clone, sync, submit PRs')}`, value: 'contributor' },
-                { name: `${magenta('🛠️')}  ${bold('Maintainer Mode')}   ${dim('— manage issues, PRs, contributors')}`, value: 'maintainer' },
+                { name: `${yellow('📝')}  ${bold('Create Assignment')}   ${dim('— post a new assignment as an issue')}`, value: 'create' },
+                { name: `${green('📊')}  ${bold('Grade a PR')}          ${dim('— score a student submission')}`, value: 'grade' },
+                { name: `${cyan('🏆')}  ${bold('Cohort Leaderboard')}  ${dim('— rank all students by score')}`, value: 'leaderboard' },
                 new inquirer.Separator(dim('  ─────────────────────────────')),
-                { name: `${dim('👋')}  ${dim('Exit')}`, value: 'exit' },
+                { name: `${dim('⚙️')}   ${dim('Switch Repo')}`, value: 'switch' },
+                { name: `${dim('⬅')}   ${dim('Back to Mode Selector')}`, value: 'back' },
             ],
             loop: false,
         }]);
 
-        if (mode === 'contributor') await safeMenu(contributorMenu);
-        else if (mode === 'maintainer') {
-            await ensureTargetRepo();
-            await safeMenu(maintainerMenu);
+        if (action === 'back') break;
+
+        if (action === 'switch') {
+            await ensureTargetRepo(true);
+            continue;
+        }
+
+        // ── Create Assignment ──────────────────────────────────────────
+        if (action === 'create') {
+            const answers = await ask([
+                { type: 'input', name: 'title', message: yellow('Assignment title:') },
+                { type: 'input', name: 'description', message: yellow('Description (what students should build):') },
+                { type: 'input', name: 'deadline', message: yellow('Deadline (e.g. "March 15, 2026"):'), default: '' },
+                { type: 'input', name: 'files', message: yellow('Expected files/folders (comma-separated):'), default: '' },
+                { type: 'input', name: 'labels', message: yellow('Labels (space-separated):'), default: 'assignment' },
+            ]);
+
+            if (!answers.title) continue;
+
+            const ora = (await import('ora')).default;
+            const spinner = ora('Creating assignment...').start();
+            try {
+                const octokit = getOctokit();
+                const owner = getOwner();
+                const repo = getRepo();
+
+                let body = `## 📝 ${answers.title}\n\n`;
+                body += `${answers.description}\n\n`;
+                if (answers.deadline) body += `**Deadline:** ${answers.deadline}\n\n`;
+                if (answers.files) body += `**Expected files:** ${answers.files}\n\n`;
+                body += `---\n\n`;
+                body += `### Submission Instructions\n\n`;
+                body += `1. Fork this repository\n`;
+                body += `2. Create a branch named \`assignment-<issue-number>\` (e.g. \`assignment-5\`)\n`;
+                body += `3. Complete the assignment\n`;
+                body += `4. Open a Pull Request with \`Fixes #<issue-number>\` in the description\n`;
+                body += `5. GitPadi will automatically grade your submission\n\n`;
+                body += `### Grading Criteria\n\n`;
+                body += `| Criteria | Points |\n|----------|--------|\n`;
+                body += `| CI Passing | 25 |\n`;
+                body += `| Assignment Relevance | 25 |\n`;
+                body += `| Test Coverage | 20 |\n`;
+                body += `| Code Quality | 15 |\n`;
+                body += `| Submission Format | 15 |\n`;
+                body += `| **Total** | **100** |\n\n`;
+                body += `**Pass threshold:** 40/100 (Grade C or above)\n`;
+
+                const labels = answers.labels.split(/\s+/).filter((l: string) => l);
+
+                const { data: issue } = await octokit.issues.create({
+                    owner, repo,
+                    title: `📝 ${answers.title}`,
+                    body,
+                    labels,
+                });
+
+                spinner.succeed(green(`Assignment created: #${issue.number} — ${issue.html_url}`));
+            } catch (e: any) {
+                spinner.fail(e.message);
+            }
+        }
+
+        // ── Grade a PR ─────────────────────────────────────────────────
+        else if (action === 'grade') {
+            const { prNum } = await ask([{ type: 'input', name: 'prNum', message: cyan('PR number to grade:') }]);
+            if (!prNum || isNaN(Number(prNum))) continue;
+
+            const ora = (await import('ora')).default;
+            const spinner = ora('Grading submission...').start();
+            try {
+                const octokit = getOctokit();
+                const owner = getOwner();
+                const repo = getRepo();
+                const prNumber = parseInt(prNum);
+
+                const { data: pr } = await octokit.pulls.get({ owner, repo, pull_number: prNumber });
+                const student = pr.user?.login || 'unknown';
+                const branchName = pr.head.ref;
+                const prBody = pr.body || '';
+
+                // Detect assignment
+                const bodyMatch = prBody.match(/(?:fixes|closes|resolves|assignment)\s*#(\d+)/i);
+                const branchMatch = branchName.match(/(?:assignment|hw|task|fix\/issue)-(\d+)/i);
+                const assignmentNum = bodyMatch ? parseInt(bodyMatch[1]) : branchMatch ? parseInt(branchMatch[1]) : null;
+
+                if (!assignmentNum) {
+                    spinner.fail('No assignment issue linked. Student should use `Fixes #N` or branch `assignment-N`.');
+                    continue;
+                }
+
+                // Fetch assignment
+                const { data: issue } = await octokit.issues.get({ owner, repo, issue_number: assignmentNum });
+                const { data: files } = await octokit.pulls.listFiles({ owner, repo, pull_number: prNumber });
+                const totalChanges = files.reduce((sum: number, f: any) => sum + f.additions + f.deletions, 0);
+
+                // CI
+                const sha = pr.head.sha;
+                const { data: ciChecks } = await octokit.checks.listForRef({ owner, repo, ref: sha });
+                const { data: statuses } = await octokit.repos.getCombinedStatusForRef({ owner, repo, ref: sha });
+                const ciPassed = statuses.state === 'success' || (ciChecks.total_count > 0 && ciChecks.check_runs.every((c: any) => c.conclusion === 'success'));
+                const ciFailed = statuses.state === 'failure' || ciChecks.check_runs.some((c: any) => c.conclusion === 'failure');
+
+                // Quick score
+                let score = 0;
+                if (ciPassed) score += 25;
+                score += 15; // base relevance
+                const testFiles = files.filter((f: any) => f.filename.includes('test') || f.filename.includes('spec'));
+                if (testFiles.length > 0) score += 20; else score += 5;
+                if (totalChanges < 500) score += 15; else score += 5;
+                const hasRef = /(?:fixes|closes|resolves)\s+#\d+/i.test(prBody);
+                if (hasRef && prBody.length > 20) score += 15; else score += 5;
+
+                const letter = score >= 80 ? 'A' : score >= 60 ? 'B' : score >= 40 ? 'C' : score >= 20 ? 'D' : 'F';
+                const emoji = score >= 80 ? '🟢' : score >= 60 ? '🔵' : score >= 40 ? '🟡' : score >= 20 ? '🟠' : '🔴';
+                const passed = score >= 40;
+
+                spinner.stop();
+
+                console.log(bold(`\n  📊 Grade for @${student} — PR #${prNumber}`));
+                console.log(`  Assignment: ${issue.title} (#${assignmentNum})`);
+                console.log(`  Changes:    ${totalChanges} lines across ${files.length} files`);
+                console.log(`  CI:         ${ciPassed ? green('✅ Passed') : ciFailed ? red('❌ Failed') : yellow('⏳ Pending')}`);
+                console.log(`  Tests:      ${testFiles.length > 0 ? green(`${testFiles.length} file(s)`) : red('None')}`);
+                console.log(bold(`\n  Score: ${score}/100 — Grade ${letter} ${emoji}\n`));
+
+                // Post grade
+                const gradeBody = `## ${emoji} GitPadi Grade — PR #${prNumber}\n\n**Student:** @${student}\n**Assignment:** ${issue.title} (#${assignmentNum})\n**Score:** ${score}/100\n**Grade:** ${letter}\n\n${passed ? '> ✅ **Passed.**' : '> ❌ **Did not pass.** Please fix and re-submit.'}\n\n---\n_Graded by [GitPadi](https://github.com/Netwalls/contributor-agent) 📝_\n\n<!-- gitpadi-grade -->`;
+                await octokit.issues.createComment({ owner, repo, issue_number: prNumber, body: gradeBody });
+                console.log(green('  ✅ Grade posted to PR.'));
+
+                if (passed && ciPassed) {
+                    const { merge } = await inquirer.prompt([{
+                        type: 'list', name: 'merge', message: green('Merge this PR?'),
+                        choices: [
+                            { name: `${green('✅')}  Yes, squash & merge`, value: 'yes' },
+                            { name: `${dim('⬅')}   No`, value: 'no' },
+                        ]
+                    }]);
+                    if (merge === 'yes') {
+                        const mergeSpinner = ora('Merging...').start();
+                        await octokit.pulls.merge({
+                            owner, repo, pull_number: prNumber,
+                            merge_method: 'squash',
+                            commit_title: `[Grade ${letter}] ${pr.title} (#${prNumber})`,
+                        });
+                        mergeSpinner.succeed(green(`PR #${prNumber} merged!`));
+                    }
+                }
+            } catch (e: any) {
+                spinner.fail(e.message);
+            }
         }
-        else break;
+
+        // ── Cohort Leaderboard ─────────────────────────────────────────
+        else if (action === 'leaderboard') {
+            const ora = (await import('ora')).default;
+            const Table = (await import('cli-table3')).default;
+            const spinner = ora('Building cohort leaderboard...').start();
+
+            try {
+                const octokit = getOctokit();
+                const owner = getOwner();
+                const repo = getRepo();
+
+                // Find all PRs with grade comments
+                const { data: allPRs } = await octokit.pulls.list({ owner, repo, state: 'all', per_page: 100 });
+
+                const studentScores: Record<string, { scores: number[]; grades: string[]; prs: number[] }> = {};
+
+                for (const pr of allPRs) {
+                    const { data: comments } = await octokit.issues.listComments({ owner, repo, issue_number: pr.number });
+                    const gradeComment = comments.find(c => c.body?.includes('<!-- gitpadi-grade -->'));
+
+                    if (gradeComment && gradeComment.body) {
+                        const student = pr.user?.login || 'unknown';
+                        const scoreMatch = gradeComment.body.match(/\*\*Score:\*\*\s*(\d+)/);
+                        const gradeMatch = gradeComment.body.match(/\*\*Grade:\*\*\s*(\w)/);
+
+                        if (scoreMatch) {
+                            if (!studentScores[student]) studentScores[student] = { scores: [], grades: [], prs: [] };
+                            studentScores[student].scores.push(parseInt(scoreMatch[1]));
+                            studentScores[student].grades.push(gradeMatch ? gradeMatch[1] : '?');
+                            studentScores[student].prs.push(pr.number);
+                        }
+                    }
+                }
+
+                spinner.stop();
+
+                const students = Object.entries(studentScores)
+                    .map(([name, data]) => ({
+                        name,
+                        avg: Math.round(data.scores.reduce((a, b) => a + b, 0) / data.scores.length),
+                        total: data.scores.reduce((a, b) => a + b, 0),
+                        assignments: data.scores.length,
+                        grades: data.grades.join(', '),
+                    }))
+                    .sort((a, b) => b.avg - a.avg);
+
+                if (students.length === 0) {
+                    console.log(yellow('\n  No graded submissions found yet.\n'));
+                    continue;
+                }
+
+                const table = new Table({
+                    head: ['Rank', 'Student', 'Avg Score', 'Assignments', 'Grades', 'Total Points'].map(h => cyan(h)),
+                    style: { head: [], border: [] },
+                });
+
+                students.forEach((s, i) => {
+                    const medal = i === 0 ? '🥇' : i === 1 ? '🥈' : i === 2 ? '🥉' : `${i + 1}.`;
+                    const avgColor = s.avg >= 80 ? green : s.avg >= 60 ? cyan : s.avg >= 40 ? yellow : red;
+                    table.push([
+                        medal,
+                        bold(`@${s.name}`),
+                        avgColor(`${s.avg}/100`),
+                        `${s.assignments}`,
+                        s.grades,
+                        `${s.total}`,
+                    ]);
+                });
+
+                console.log(bold(`\n  🏆 COHORT LEADERBOARD — ${owner}/${repo}\n`));
+                console.log(table.toString());
+                console.log(green(`\n  👑 Top student: @${students[0].name} (${students[0].avg}/100 avg)\n`));
+
+                // Offer to post leaderboard as an issue comment
+                const { post } = await inquirer.prompt([{
+                    type: 'list', name: 'post',
+                    message: 'Post leaderboard to a pinned issue?',
+                    choices: [
+                        { name: `${green('✅')}  Yes`, value: 'yes' },
+                        { name: `${dim('⬅')}   No`, value: 'no' },
+                    ]
+                }]);
+
+                if (post === 'yes') {
+                    let leaderBody = `## 🏆 Cohort Leaderboard\n\n`;
+                    leaderBody += `_Last updated: ${new Date().toLocaleDateString()}_\n\n`;
+                    leaderBody += `| Rank | Student | Avg Score | Assignments | Grades |\n|------|---------|-----------|-------------|--------|\n`;
+                    students.forEach((s, i) => {
+                        const medal = i === 0 ? '🥇' : i === 1 ? '🥈' : i === 2 ? '🥉' : `${i + 1}`;
+                        leaderBody += `| ${medal} | @${s.name} | ${s.avg}/100 | ${s.assignments} | ${s.grades} |\n`;
+                    });
+                    leaderBody += `\n👑 **Top student:** @${students[0].name}\n\n<!-- gitpadi-leaderboard -->`;
+
+                    // Find or create leaderboard issue
+                    const { data: issues } = await octokit.issues.listForRepo({ owner, repo, state: 'open', labels: 'leaderboard', per_page: 5 });
+                    const existing = issues[0];
+
+                    if (existing) {
+                        await octokit.issues.update({ owner, repo, issue_number: existing.number, body: leaderBody });
+                        console.log(green(`  ✅ Leaderboard updated: ${existing.html_url}`));
+                    } else {
+                        const { data: newIssue } = await octokit.issues.create({
+                            owner, repo, title: '🏆 Cohort Leaderboard', body: leaderBody, labels: ['leaderboard'],
+                        });
+                        // Pin it
+                        try { await octokit.issues.update({ owner, repo, issue_number: newIssue.number }); } catch { }
+                        console.log(green(`  ✅ Leaderboard created: ${newIssue.html_url}`));
+                    }
+                }
+            } catch (e: any) {
+                spinner.fail(e.message);
+            }
+        }
+
+        console.log('');
     }
 }
 
@@ -283,29 +987,50 @@ async function contributorMenu() {
         console.log(dim('  Automating forking, syncing, and PR delivery'));
         line('═');
 
-        // Auto-check for updates if in a repo
-        if (getOwner() && getRepo()) {
-            await contribute.syncBranch();
-        }
-
         const { action } = await inquirer.prompt([{
             type: 'list',
             name: 'action',
             message: bold('Contributor Action:'),
             choices: [
-                { name: `${cyan('🚀')}  ${bold('Start Contribution')}  ${dim('— fork, clone & branch')}`, value: 'start' },
-                { name: `${green('🔄')}  ${bold('Sync with Upstream')} ${dim('— pull latest changes')}`, value: 'sync' },
-                { name: `${yellow('📋')}  ${bold('View Action Logs')}   ${dim('— check PR/commit status')}`, value: 'logs' },
-                { name: `${magenta('🚀')}  ${bold('Submit PR')}          ${dim('— add, commit, push & PR')}`, value: 'submit' },
-                new inquirer.Separator(dim('  ─────────────────────────────')),
+                // ── Bounty Discovery ──────────────────────────────────
+                new inquirer.Separator(dim('  ── Bounty Discovery ─────────────────────')),
+                { name: `${green('🎯')}  ${bold('Bounty Hunter')}       ${dim('— auto-apply Drips Wave & GrantFox')}`, value: 'hunt' },
+                { name: `${yellow('🙋')}  ${bold('Apply for Issue')}     ${dim('— browse a repo & request to work')}`, value: 'apply' },
+                { name: `${cyan('🔍')}  ${bold('My Applications')}     ${dim('— see issues you applied for')}`, value: 'my-apps' },
+                // ── Contribution Flow ─────────────────────────────────
+                new inquirer.Separator(dim('  ── Contribution Flow ────────────────────')),
+                { name: `${cyan('🚀')}  ${bold('Start Contribution')}   ${dim('— fork, clone & branch from URL')}`, value: 'start' },
+                { name: `${green('🔄')}  ${bold('Sync with Upstream')}  ${dim('— pull latest from original repo')}`, value: 'sync' },
+                { name: `${magenta('🚀')}  ${bold('Submit PR')}           ${dim('— stage, commit, push & open PR')}`, value: 'submit' },
+                { name: `${red('🔧')}  ${bold('Fix & Re-push')}       ${dim('— fix CI failures & force-push')}`, value: 'fix' },
+                { name: `${cyan('💬')}  ${bold('Reply to Comments')}   ${dim('— respond to reviewer feedback')}`, value: 'reply' },
+                // ── Visibility ────────────────────────────────────────
+                new inquirer.Separator(dim('  ── Visibility ───────────────────────────')),
+                { name: `${yellow('📋')}  ${bold('View Action Logs')}    ${dim('— check CI status on latest commit')}`, value: 'logs' },
+                { name: `${green('📝')}  ${bold('My Open PRs')}         ${dim('— list your open PRs in this repo')}`, value: 'my-prs' },
+                { name: `${magenta('📊')}  ${bold('My Score')}            ${dim('— see your contributor tier & breakdown')}`, value: 'my-score' },
+                // ── Back ──────────────────────────────────────────────
+                new inquirer.Separator(dim('  ─────────────────────────────────────────')),
                 { name: `${dim('⬅')}   ${dim('Back to Mode Selector')}`, value: 'back' },
             ],
             loop: false,
+            pageSize: 18,
         }]);
 
         if (action === 'back') break;
 
-        if (action === 'start') {
+        if (action === 'hunt') {
+            await runBountyHunter({ platform: 'all', maxApplications: 3, dryRun: false });
+        } else if (action === 'apply') {
+            await applyForIssue.browseAndApply();
+        } else if (action === 'my-apps') {
+            await myApplicationsMenu();
+        } else if (action === 'my-prs') {
+            await ensureTargetRepo();
+            await myOpenPRsMenu();
+        } else if (action === 'my-score') {
+            await myScoreMenu();
+        } else if (action === 'start') {
             const { url } = await ask([{ type: 'input', name: 'url', message: 'Enter Repo or Issue URL:' }]);
             await contribute.forkAndClone(url);
         } else {
@@ -316,8 +1041,12 @@ async function contributorMenu() {
                 await contribute.syncBranch();
             } else if (action === 'logs') {
                 await contribute.viewLogs();
+            } else if (action === 'fix') {
+                await contribute.fixAndRepush();
+            } else if (action === 'reply') {
+                await contribute.replyToComments();
             } else if (action === 'submit') {
-                const branch = execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf-8' }).trim();
+                const branch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { encoding: 'utf-8' }).trim();
                 const match = branch.match(/issue-(\d+)/);
                 const detectedIssue = match ? parseInt(match[1]) : undefined;
 
@@ -380,16 +1109,19 @@ async function maintainerMenu() {
             name: 'category',
             message: bold('Select operation:'),
             choices: [
-                { name: `${magenta('📋')}  ${bold('Issues')}        ${dim('— create, close, delete, assign, search')}`, value: 'issues' },
-                { name: `${cyan('🔀')}  ${bold('Pull Requests')} ${dim('— merge, review, approve, diff')}`, value: 'prs' },
-                { name: `${green('📦')}  ${bold('Repositories')}  ${dim('— create, delete, clone, info')}`, value: 'repos' },
-                { name: `${yellow('🏆')}  ${bold('Contributors')}  ${dim('— score, rank, auto-assign best')}`, value: 'contributors' },
-                { name: `${red('🚀')}  ${bold('Releases')}      ${dim('— create, list, manage')}`, value: 'releases' },
-                new inquirer.Separator(dim('  ─────────────────────────────')),
+                { name: `${magenta('📋')}  ${bold('Issues')}           ${dim('— create, close, assign, bulk-create')}`, value: 'issues' },
+                { name: `${cyan('🔀')}  ${bold('Pull Requests')}    ${dim('— list, merge, review, approve, diff')}`, value: 'prs' },
+                { name: `${green('✅')}  ${bold('Review & Merge')}   ${dim('— review a PR, check CI, squash merge')}`, value: 'review-merge' },
+                { name: `${yellow('🏆')}  ${bold('Contributors')}     ${dim('— score applicants, rank, auto-assign')}`, value: 'contributors' },
+                { name: `${green('📦')}  ${bold('Repositories')}     ${dim('— create, delete, clone, topics, info')}`, value: 'repos' },
+                { name: `${red('🚀')}  ${bold('Releases')}          ${dim('— create, list, tag releases')}`, value: 'releases' },
+                { name: `${green('🎯')}  ${bold('Bounty Hunter')}    ${dim('— auto-apply to Drips Wave & GrantFox')}`, value: 'hunt' },
+                new inquirer.Separator(dim('  ─────────────────────────────────────────')),
                 { name: `${dim('⚙️')}   ${dim('Switch Repo')}`, value: 'switch' },
                 { name: `${dim('⬅')}   ${dim('Back to Mode Selector')}`, value: 'back' },
             ],
             loop: false,
+            pageSize: 12,
         }]);
 
         if (category === 'back') break;
@@ -404,11 +1136,342 @@ async function maintainerMenu() {
         else if (category === 'repos') await safeMenu(repoMenu);
         else if (category === 'contributors') await safeMenu(contributorScoringMenu);
         else if (category === 'releases') await safeMenu(releaseMenu);
+        else if (category === 'hunt') await runBountyHunter({ platform: 'all', maxApplications: 3, dryRun: false });
+        else if (category === 'review-merge') {
+            await ensureTargetRepo();
+            const { prNum } = await ask([{ type: 'input', name: 'prNum', message: cyan('PR number to review:') }]);
+            if (!prNum || isNaN(Number(prNum))) continue;
+
+            const ora = (await import('ora')).default;
+            const spinner = ora('Reviewing PR...').start();
+            try {
+                const octokit = getOctokit();
+                const owner = getOwner();
+                const repo = getRepo();
+                const prNumber = parseInt(prNum);
+
+                const { data: pr } = await octokit.pulls.get({ owner, repo, pull_number: prNumber });
+                const { data: files } = await octokit.pulls.listFiles({ owner, repo, pull_number: prNumber });
+                const totalChanges = files.reduce((sum: number, f: any) => sum + f.additions + f.deletions, 0);
+
+                // CI Check
+                const sha = pr.head.sha;
+                const { data: ciChecks } = await octokit.checks.listForRef({ owner, repo, ref: sha });
+                const { data: statuses } = await octokit.repos.getCombinedStatusForRef({ owner, repo, ref: sha });
+
+                const ciPassed = statuses.state === 'success' || (ciChecks.total_count > 0 && ciChecks.check_runs.every((c: any) => c.conclusion === 'success'));
+                const ciFailed = statuses.state === 'failure' || ciChecks.check_runs.some((c: any) => c.conclusion === 'failure');
+
+                spinner.stop();
+
+                console.log(bold(`\n  📋 PR #${prNumber}: "${pr.title}"\n`));
+                console.log(`  ${dim('Author:')}   @${pr.user?.login}`);
+                console.log(`  ${dim('Changes:')}  ${totalChanges} lines across ${files.length} files`);
+                console.log(`  ${dim('CI:')}       ${ciPassed ? green('✅ Passed') : ciFailed ? red('❌ Failed') : yellow('⏳ Pending')}\n`);
+
+                if (ciFailed) {
+                    // Notify contributor
+                    const failMsg = `❌ **CI Failed.** Please fix the failing checks and re-push.\n\nUse \`npx gitpadi\` → \`Fix & Re-push\` for a guided workflow.\n\n---\n_Review by [GitPadi](https://github.com/Netwalls/contributor-agent) 🤖_`;
+                    await octokit.issues.createComment({ owner, repo, issue_number: prNumber, body: failMsg });
+                    console.log(red('  ❌ CI failed. Contributor notified.'));
+                } else if (ciPassed) {
+                    const { mergeAction } = await inquirer.prompt([{
+                        type: 'list', name: 'mergeAction', message: green('CI passed! Merge this PR?'),
+                        choices: [
+                            { name: `${green('✅')}  Squash & Merge`, value: 'squash' },
+                            { name: `${cyan('🔀')}  Merge Commit`, value: 'merge' },
+                            { name: `${dim('⬅')}   Skip`, value: 'skip' },
+                        ]
+                    }]);
+
+                    if (mergeAction !== 'skip') {
+                        const mergeSpinner = ora('Merging...').start();
+                        await octokit.pulls.merge({
+                            owner, repo, pull_number: prNumber,
+                            merge_method: mergeAction as 'squash' | 'merge',
+                            commit_title: `${pr.title} (#${prNumber})`,
+                        });
+                        mergeSpinner.succeed(green(`PR #${prNumber} merged successfully! 🎉`));
+                    }
+                } else {
+                    console.log(yellow('  ⏳ CI is still running. Try again later.'));
+                }
+            } catch (e: any) {
+                spinner.fail(e.message);
+            }
+        }
 
         console.log('');
     }
 }
 
+// ── CI Actions Menu ────────────────────────────────────────────────────
+// Triggers GitHub Actions workflow_dispatch events from the terminal.
+// This makes npx gitpadi the primary interface for all CI operations.
+async function ciActionsMenu() {
+    const WORKFLOW_FILE = 'gitpadi.yml';
+    const owner = getOwner();
+    const repo = getRepo();
+    const octokit = getOctokit();
+
+    // Detect default branch
+    let ref = 'main';
+    try {
+        const { data: repoData } = await octokit.repos.get({ owner, repo });
+        ref = repoData.default_branch || 'main';
+    } catch { /* use main */ }
+
+    while (true) {
+        line('─');
+        console.log(green(`  🤖 CI ACTIONS — ${owner}/${repo}`));
+        console.log(dim(`  Triggers .github/workflows/${WORKFLOW_FILE} via GitHub Actions API`));
+        line('─');
+
+        const { action } = await inquirer.prompt([{
+            type: 'list',
+            name: 'action',
+            message: bold('Select CI action to trigger:'),
+            choices: [
+                { name: `${green('✅')}  ${bold('Review & Merge PR')}       ${dim('— review + auto-merge a specific PR')}`, value: 'review-and-merge' },
+                { name: `${magenta('📊')}  ${bold('Grade Assignment PR')}    ${dim('— grade a student submission PR')}`, value: 'grade-assignment' },
+                { name: `${yellow('🏆')}  ${bold('Score Applicants')}        ${dim('— score contributors on an issue')}`, value: 'score-applicant' },
+                { name: `${cyan('🔔')}  ${bold('Remind Contributors')}     ${dim('— send escalating reminders now')}`, value: 'remind-contributors' },
+                { name: `${green('📋')}  ${bold('Create Issues from File')} ${dim('— bulk-create from JSON/MD file')}`, value: 'create-issues' },
+                new inquirer.Separator(dim('  ─────────────────────────────────────────')),
+                { name: `${dim('⬅')}   ${dim('Back')}`, value: 'back' },
+            ],
+            loop: false,
+        }]);
+
+        if (action === 'back') break;
+
+        let inputs: Record<string, string> = { action };
+
+        if (action === 'review-and-merge') {
+            const { prNum } = await ask([{ type: 'input', name: 'prNum', message: cyan('PR number:'), validate: (v: string) => /^\d+$/.test(v) || 'Enter a number' }]);
+            inputs.pr_number = prNum;
+        }
+
+        if (action === 'create-issues') {
+            const { file } = await ask([{ type: 'input', name: 'file', message: cyan('Issues file path:'), default: 'issues.json' }]);
+            inputs.issues_file = file;
+        }
+
+        await triggerWorkflow(action, inputs, ref, WORKFLOW_FILE);
+    }
+}
+
+async function triggerWorkflow(action: string, extraInputs: Record<string, string> = {}, ref?: string, workflowFile = 'gitpadi.yml') {
+    const owner = getOwner();
+    const repo = getRepo();
+    const octokit = getOctokit();
+    const ora = (await import('ora')).default;
+
+    if (!ref) {
+        try {
+            const { data } = await octokit.repos.get({ owner, repo });
+            ref = data.default_branch || 'main';
+        } catch { ref = 'main'; }
+    }
+
+    const spinner = ora(`  Triggering ${bold(action)} on ${cyan(`${owner}/${repo}`)}…`).start();
+    try {
+        await octokit.actions.createWorkflowDispatch({
+            owner, repo,
+            workflow_id: workflowFile,
+            ref,
+            inputs: { action, ...extraInputs },
+        });
+        spinner.succeed(`  ✅ ${bold(action)} triggered on branch ${cyan(ref)}`);
+        console.log(dim(`  Monitor at: https://github.com/${owner}/${repo}/actions\n`));
+    } catch (e: any) {
+        spinner.fail(`  Failed to trigger workflow: ${e.message}`);
+        console.log(dim(`  Make sure ${workflowFile} exists in .github/workflows/ and has workflow_dispatch enabled.\n`));
+    }
+}
+
+// ── My Score Menu ──────────────────────────────────────────────────────
+async function myScoreMenu() {
+    const ora = (await import('ora')).default;
+    const { fetchProfile, scoreApplicant, TIER_EMOJI } = await import('./core/scorer.js');
+
+    const spinner = ora('  Fetching your GitHub profile…').start();
+    try {
+        const me = await getAuthenticatedUser();
+        const profile = await fetchProfile(me, '');
+        const scored = scoreApplicant(profile, []);
+        spinner.succeed(`  @${me}  ${TIER_EMOJI[scored.tier]} Tier ${scored.tier}  ${scored.score}/100`);
+
+        console.log();
+        console.log(bold('  📊 Score Breakdown'));
+        console.log(`  ${'─'.repeat(40)}`);
+        console.log(`  Account Maturity    ${magenta(`${scored.breakdown.accountMaturity}/15`)}`);
+        console.log(`  Repo Experience     ${cyan(`${scored.breakdown.repoExperience}/30`)}`);
+        console.log(`  GitHub Presence     ${green(`${scored.breakdown.githubPresence}/15`)}`);
+        console.log(`  Activity Level      ${yellow(`${scored.breakdown.activityLevel}/15`)}`);
+        console.log(`  Language Relevance  ${magenta(`${scored.breakdown.languageRelevance}/10`)}`);
+        console.log(`  ${'─'.repeat(40)}`);
+        console.log(`  ${bold('Total')}               ${bold(`${scored.score}/100`)}  ${TIER_EMOJI[scored.tier]} ${bold(`Tier ${scored.tier}`)}`);
+        console.log();
+
+        const tierMsg: Record<string, string> = {
+            S: green('Exceptional — you qualify for auto-assign on Drips/GrantFox issues.'),
+            A: green('Strong — most maintainers will assign you on application.'),
+            B: yellow('Decent — you\'ll get considered. Keep contributing to improve.'),
+            C: yellow('Building up — contribute more to boost your score.'),
+            D: red('Early stage — focus on getting PRs merged to level up.'),
+        };
+        console.log(`  ${tierMsg[scored.tier]}`);
+        console.log();
+    } catch (e: any) {
+        spinner.fail(`  Could not load profile: ${e.message}`);
+    }
+}
+
+// ── My Applications Menu ───────────────────────────────────────────────
+async function myApplicationsMenu() {
+    const ora = (await import('ora')).default;
+    const { APPLICATION_PATTERNS } = await import('./core/scorer.js');
+    const octokit = getOctokit();
+
+    const { target } = await inquirer.prompt([{
+        type: 'input',
+        name: 'target',
+        message: bold('Repo to check (owner/repo or leave blank for current):'),
+        default: getOwner() && getRepo() ? `${getOwner()}/${getRepo()}` : '',
+    }]);
+
+    const [owner, repo] = (target || `${getOwner()}/${getRepo()}`).split('/');
+    if (!owner || !repo) { console.log(yellow('  No repo selected.')); return; }
+
+    const spinner = ora(`  Fetching your applications in ${cyan(`${owner}/${repo}`)}…`).start();
+    const me = await getAuthenticatedUser();
+
+    try {
+        // Search issues where you commented with an application-style comment
+        const { data: comments } = await octokit.search.issuesAndPullRequests({
+            q: `commenter:${me} type:issue state:open repo:${owner}/${repo}`,
+            per_page: 50, sort: 'updated',
+        });
+
+        const applied: Array<{ number: number; title: string; url: string; assignees: string[]; status: string }> = [];
+
+        for (const item of comments.items) {
+            const { data: issueComments } = await octokit.issues.listComments({
+                owner, repo, issue_number: item.number, per_page: 100,
+            });
+
+            const myComments = issueComments.filter((c: any) =>
+                c.user?.login === me &&
+                APPLICATION_PATTERNS.some(p => p.test(c.body || ''))
+            );
+
+            if (myComments.length > 0) {
+                const assignees: string[] = (item as any).assignees?.map((a: any) => a.login) || [];
+                const isAssignedToMe = assignees.includes(me);
+                applied.push({
+                    number: item.number,
+                    title: item.title,
+                    url: item.html_url,
+                    assignees,
+                    status: isAssignedToMe ? green('✅ Assigned to you') : assignees.length > 0 ? yellow(`⚠  Assigned to @${assignees[0]}`) : cyan('⏳ Pending'),
+                });
+            }
+        }
+
+        spinner.succeed(`  ${applied.length} application(s) found in ${owner}/${repo}`);
+        console.log();
+
+        if (applied.length === 0) {
+            console.log(dim('  You haven\'t applied for any open issues in this repo yet.'));
+            console.log(dim('  Use "Bounty Hunter" or "Apply for Issue" to get started.'));
+        } else {
+            applied.forEach(a => {
+                console.log(`  ${cyan(`#${a.number}`)} ${bold(a.title)}`);
+                console.log(`  ${a.status}   ${dim(a.url)}`);
+                console.log();
+            });
+        }
+    } catch (e: any) {
+        spinner.fail(e.message);
+    }
+}
+
+// ── My Open PRs Menu ───────────────────────────────────────────────────
+async function myOpenPRsMenu() {
+    const ora = (await import('ora')).default;
+    const octokit = getOctokit();
+    const owner = getOwner();
+    const repo = getRepo();
+    const me = await getAuthenticatedUser();
+
+    const spinner = ora(`  Fetching your open PRs in ${cyan(`${owner}/${repo}`)}…`).start();
+    try {
+        const { data: prs } = await octokit.pulls.list({ owner, repo, state: 'open', per_page: 50 });
+        const mine = prs.filter((p: any) => p.user?.login === me);
+        spinner.succeed(`  ${mine.length} open PR(s) as @${me}`);
+        console.log();
+
+        if (mine.length === 0) {
+            console.log(dim('  No open PRs. Use "Submit PR" to open one.'));
+        } else {
+            mine.forEach((p: any) => {
+                const age = Math.floor((Date.now() - new Date(p.updated_at).getTime()) / 86_400_000);
+                const draft = p.draft ? yellow(' [draft]') : '';
+                console.log(`  ${cyan(`#${p.number}`)}${draft} ${bold(p.title)}`);
+                console.log(`  ${dim(`branch: ${p.head.ref}`)}  ${dim(`updated ${age}d ago`)}  ${dim(p.html_url)}`);
+                console.log();
+            });
+        }
+    } catch (e: any) {
+        spinner.fail(e.message);
+    }
+}
+
+// ── Repo Stats Menu ────────────────────────────────────────────────────
+async function repoStatsMenu() {
+    const ora = (await import('ora')).default;
+    const octokit = getOctokit();
+    const owner = getOwner();
+    const repo = getRepo();
+
+    const spinner = ora(`  Loading stats for ${cyan(`${owner}/${repo}`)}…`).start();
+    try {
+        const [repoData, openIssues, openPRs, closedPRs, contributors] = await Promise.all([
+            octokit.repos.get({ owner, repo }),
+            octokit.issues.listForRepo({ owner, repo, state: 'open', per_page: 1 }),
+            octokit.pulls.list({ owner, repo, state: 'open', per_page: 1 }),
+            octokit.pulls.list({ owner, repo, state: 'closed', per_page: 50 }),
+            octokit.repos.listContributors({ owner, repo, per_page: 10 }),
+        ]);
+
+        const merged = closedPRs.data.filter((p: any) => p.merged_at).length;
+        const mergeRate = closedPRs.data.length > 0
+            ? Math.round((merged / closedPRs.data.length) * 100) : 0;
+
+        spinner.succeed();
+        console.log();
+        console.log(bold(`  📊 ${owner}/${repo}`));
+        console.log(`  ${'─'.repeat(42)}`);
+        console.log(`  ⭐ Stars           ${yellow(String(repoData.data.stargazers_count))}`);
+        console.log(`  🍴 Forks           ${cyan(String(repoData.data.forks_count))}`);
+        console.log(`  📋 Open Issues     ${magenta(String(repoData.data.open_issues_count))}`);
+        console.log(`  🔀 Open PRs        ${cyan(String(openPRs.data.length ? '1+' : '0'))}`);
+        console.log(`  ✅ Merge Rate      ${mergeRate >= 70 ? green(`${mergeRate}%`) : yellow(`${mergeRate}%`)} (last 50 closed PRs)`);
+        console.log(`  🌿 Default Branch  ${dim(repoData.data.default_branch)}`);
+        console.log(`  📝 Language        ${dim(repoData.data.language || 'mixed')}`);
+        console.log();
+        console.log(`  Top Contributors:`);
+        contributors.data.slice(0, 5).forEach((c: any, i: number) => {
+            const medal = i === 0 ? '🥇' : i === 1 ? '🥈' : i === 2 ? '🥉' : '  ';
+            console.log(`  ${medal} @${c.login}  ${dim(`${c.contributions} commits`)}`);
+        });
+        console.log();
+    } catch (e: any) {
+        spinner.fail(e.message);
+    }
+}
+
 // ── Issue Menu ─────────────────────────────────────────────────────────
 async function issueMenu() {
     const { action } = await inquirer.prompt([{
@@ -846,6 +1909,27 @@ function setupCommander(): Command {
         });
     program.command('logs').description('📋 View Action logs').action(async () => { await contribute.viewLogs(); });
 
+    program.command('hunt')
+        .description('🎯 Bounty Hunter — auto-apply to Drips Wave & GrantFox issues')
+        .option('-p, --platform <p>', 'Platform: drips | grantfox | all (default: all)', 'all')
+        .option('-m, --max <n>', 'Max applications to post (default: 3)', '3')
+        .option('-s, --skills <langs>', 'Comma-separated languages to filter by (e.g. typescript,rust)', '')
+        .option('--min-points <n>', 'Minimum Drips points (e.g. 150)', '0')
+        .option('--dry-run', 'Show what would be applied for without posting', false)
+        .option('--include-assigned', 'Include already-assigned issues', false)
+        .action(async (o) => {
+            const platform = (['drips', 'grantfox', 'all'].includes(o.platform) ? o.platform : 'all') as 'drips' | 'grantfox' | 'all';
+            await runBountyHunter({
+                platform,
+                maxApplications: parseInt(o.max) || 3,
+                skills: o.skills ? o.skills.split(',').map((s: string) => s.trim()).filter(Boolean) : [],
+                minPoints: parseInt(o.minPoints) || 0,
+                dryRun: !!o.dryRun,
+                skipAssigned: !o.includeAssigned,
+                verbose: false,
+            });
+        });
+
     return program;
 }