gitpadi 2.0.0 → 2.0.2

package/src/cli.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env npx tsx
+#!/usr/bin/env node
 // ═══════════════════════════════════════════════════════════════════════
 //  GitPadi v2.0 — Your AI-Powered GitHub Management Terminal
 //  "Built different. Run different."
@@ -9,15 +9,20 @@ import chalk from 'chalk';
 import inquirer from 'inquirer';
 import gradient from 'gradient-string';
 import figlet from 'figlet';
+import os from 'node:os';
+import { execSync } from 'child_process';
+
 import boxen from 'boxen';
 import { createSpinner } from 'nanospinner';
-import { initGitHub, setRepo, getOwner, getRepo, getOctokit } from './core/github.js';
+import { Octokit } from '@octokit/rest';
+import { initGitHub, setRepo, getOwner, getRepo, getOctokit, loadConfig, saveConfig, getToken } from './core/github.js';
 
 import * as issues from './commands/issues.js';
 import * as prs from './commands/prs.js';
 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';
 
 const VERSION = '2.0.0';
 
@@ -123,116 +128,207 @@ async function bootSequence() {
 }
 
 // ── Onboarding ─────────────────────────────────────────────────────────
-async function onboarding() {
-    const savedToken = process.env.GITHUB_TOKEN || process.env.GITPADI_TOKEN;
-    const savedOwner = process.env.GITHUB_OWNER;
-    const savedRepo = process.env.GITHUB_REPO;
-
-    if (savedToken && savedOwner && savedRepo) {
-        initGitHub(savedToken, savedOwner, savedRepo);
-        const spinner = createSpinner(dim('Authenticating...')).start();
-        await sleep(600);
-        spinner.success({ text: green(`Connected to ${cyan(`${savedOwner}/${savedRepo}`)}`) });
-        console.log('');
+/**
+ * Ensures we have a valid GitHub token
+ */
+async function ensureAuthenticated() {
+    initGitHub();
+    let token = getToken();
+
+    if (token) {
+        try {
+            const octokit = getOctokit();
+            await octokit.users.getAuthenticated();
+            // Silent success if token is valid
+            return;
+        } catch {
+            console.log(red('  ❌ Saved session invalid. Re-authenticating...'));
+            token = '';
+        }
+    }
+
+    console.log(neon('  ⚡ Authentication — let\'s connect you to GitHub.\n'));
+
+    const { t } = await inquirer.prompt([{
+        type: 'password',
+        name: 't',
+        message: magenta('🔑 GitHub Token') + dim(' (ghp_xxx):'),
+        mask: '•',
+        validate: async (v: string) => {
+            if (!v.startsWith('ghp_') && !v.startsWith('github_pat_')) {
+                return 'Token should start with ghp_ or github_pat_';
+            }
+            const spinner = createSpinner(dim('Validating token...')).start();
+            try {
+                const tempOctokit = new Octokit({ auth: v });
+                await tempOctokit.users.getAuthenticated();
+                spinner.success({ text: green('Token valid!') });
+                return true;
+            } catch {
+                spinner.error({ text: red('Invalid token - GitHub rejected it.') });
+                return 'Invalid token';
+            }
+        },
+    }]);
+
+    initGitHub(t);
+    saveConfig({ token: t, owner: getOwner() || '', repo: getRepo() || '' });
+}
+
+/**
+ * Ensures we have a target repository (Owner/Repo)
+ */
+async function ensureTargetRepo() {
+    let owner = getOwner();
+    let repo = getRepo();
+
+    if (owner && repo) {
         return;
     }
 
-    console.log(neon('  ⚡ First-time setup — let\'s connect you to GitHub.\n'));
+    console.log(neon('\n  📦 Project Targeting — which repo are we working on?\n'));
 
     const answers = await inquirer.prompt([
-        {
-            type: 'password',
-            name: 'token',
-            message: magenta('🔑 GitHub Token') + dim(' (ghp_xxx):'),
-            mask: '•',
-            validate: (v: string) => v.startsWith('ghp_') || v.startsWith('github_pat_') ? true : 'Token should start with ghp_ or github_pat_',
-            when: !savedToken,
-        },
         {
             type: 'input',
             name: 'owner',
             message: cyan('👤 GitHub Owner/Org:'),
-            default: savedOwner || '',
+            default: owner || '',
             validate: (v: string) => v.length > 0 || 'Required',
-            when: !savedOwner,
         },
         {
             type: 'input',
             name: 'repo',
             message: cyan('📦 Repository name:'),
-            default: savedRepo || '',
+            default: repo || '',
             validate: (v: string) => v.length > 0 || 'Required',
-            when: !savedRepo,
         },
     ]);
 
-    const token = answers.token || savedToken;
-    const owner = answers.owner || savedOwner;
-    const repo = answers.repo || savedRepo;
-
-    initGitHub(token, owner, repo);
-
-    const spinner = createSpinner(dim('Connecting to GitHub...')).start();
-    await sleep(800);
-    spinner.success({ text: green(`Locked in → ${cyan(`${owner}/${repo}`)}`) });
+    setRepo(answers.owner, answers.repo);
+    saveConfig({ token: getToken(), owner: answers.owner, repo: answers.repo });
 
-    console.log('');
-    console.log(boxen(
-        dim('💡 Pro tip: Set these to skip setup next time:\n\n') +
-        yellow('  export GITHUB_TOKEN=ghp_xxx\n') +
-        yellow('  export GITHUB_OWNER=' + owner + '\n') +
-        yellow('  export GITHUB_REPO=' + repo),
-        { padding: 1, borderColor: 'yellow', dimBorder: true, borderStyle: 'round' }
-    ));
+    const spinner = createSpinner(dim('Connecting...')).start();
+    await sleep(400);
+    spinner.success({ text: green(`Locked in → ${cyan(`${answers.owner}/${answers.repo}`)}`) });
     console.log('');
 }
 
-// ── Main Menu ──────────────────────────────────────────────────────────
+// ── Mode Selector ──────────────────────────────────────────────────────
 async function mainMenu() {
     while (true) {
         line('═');
-        console.log(cyber('  ⟨ GITPADI COMMAND CENTER ⟩'));
-        console.log(dim('  Select ⬅ Back on lists  •  Type q on text prompts'));
+        console.log(cyber('  ⟨ GITPADI MODE SELECTOR ⟩'));
+        console.log(dim('  Select your workflow persona to continue'));
         line('═');
         console.log('');
 
-        let category: string;
-        try {
-            const ans = await inquirer.prompt([{
-                type: 'list',
-                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: `${dim('⚙️')}   ${dim('Switch Repo')}`, value: 'switch' },
-                    { name: `${dim('👋')}  ${dim('Exit')}`, value: 'exit' },
-                ],
-                loop: false,
-            }]);
-            category = ans.category;
-        } catch {
-            // Ctrl+C on main menu = exit
-            console.log('');
-            console.log(dim('  ▸ Saving session...'));
-            console.log(dim('  ▸ Disconnecting from GitHub...'));
-            console.log('');
-            console.log(fire('  🤖 GitPadi is shutting down now. See you soon, pal :)\n'));
-            break;
+        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' },
+                new inquirer.Separator(dim('  ─────────────────────────────')),
+                { name: `${dim('👋')}  ${dim('Exit')}`, value: 'exit' },
+            ],
+            loop: false,
+        }]);
+
+        if (mode === 'contributor') await safeMenu(contributorMenu);
+        else if (mode === 'maintainer') {
+            await ensureTargetRepo();
+            await safeMenu(maintainerMenu);
+        }
+        else break;
+    }
+}
+
+// ── Contributor Menu ───────────────────────────────────────────────────
+async function contributorMenu() {
+    while (true) {
+        line('═');
+        console.log(cyan('  ✨ GITPADI CONTRIBUTOR WORKSPACE'));
+        console.log(dim('  Automating forking, syncing, and PR delivery'));
+        line('═');
+
+        // Auto-check for updates if in a repo
+        if (getOwner() && getRepo()) {
+            await contribute.syncBranch();
         }
 
-        if (category === 'exit') {
-            console.log('');
-            console.log(dim('  ▸ Saving session...'));
-            console.log(dim('  ▸ Disconnecting from GitHub...'));
-            console.log('');
-            console.log(fire('  🤖 GitPadi is shutting down now. See you soon, pal :)\n'));
-            break;
+        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('  ─────────────────────────────')),
+                { name: `${dim('⬅')}   ${dim('Back to Mode Selector')}`, value: 'back' },
+            ],
+            loop: false,
+        }]);
+
+        if (action === 'back') break;
+
+        if (action === 'start') {
+            const { url } = await ask([{ type: 'input', name: 'url', message: 'Enter Repo or Issue URL:' }]);
+            await contribute.forkAndClone(url);
+        } else {
+            // These actions require a target repo
+            await ensureTargetRepo();
+
+            if (action === 'sync') {
+                await contribute.syncBranch();
+            } else if (action === 'logs') {
+                await contribute.viewLogs();
+            } else if (action === 'submit') {
+                const { title, message, issue } = await ask([
+                    { type: 'input', name: 'title', message: 'PR Title:' },
+                    { type: 'input', name: 'message', message: 'Commit message (optional):' },
+                    { type: 'input', name: 'issue', message: 'Related Issue # (optional):' }
+                ]);
+                await contribute.submitPR({
+                    title,
+                    message: message || title,
+                    issue: issue ? parseInt(issue) : undefined
+                });
+            }
         }
+    }
+}
+
+// ── Maintainer Menu ────────────────────────────────────────────────────
+async function maintainerMenu() {
+    while (true) {
+        line('═');
+        console.log(magenta('  🛠️  GITPADI MAINTAINER PANEL'));
+        console.log(dim('  Managing repository health and contributor intake'));
+        line('═');
+        console.log('');
+
+        const { category } = await inquirer.prompt([{
+            type: 'list',
+            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: `${dim('⚙️')}   ${dim('Switch Repo')}`, value: 'switch' },
+                { name: `${dim('⬅')}   ${dim('Back to Mode Selector')}`, value: 'back' },
+            ],
+            loop: false,
+        }]);
+
+        if (category === 'back') break;
 
         if (category === 'switch') {
             await safeMenu(async () => {
@@ -249,10 +345,10 @@ async function mainMenu() {
         }
 
         if (category === 'issues') await safeMenu(issueMenu);
-        if (category === 'prs') await safeMenu(prMenu);
-        if (category === 'repos') await safeMenu(repoMenu);
-        if (category === 'contributors') await safeMenu(contributorMenu);
-        if (category === 'releases') await safeMenu(releaseMenu);
+        else if (category === 'prs') await safeMenu(prMenu);
+        else if (category === 'repos') await safeMenu(repoMenu);
+        else if (category === 'contributors') await safeMenu(contributorScoringMenu);
+        else if (category === 'releases') await safeMenu(releaseMenu);
 
         console.log('');
     }
@@ -263,11 +359,11 @@ async function issueMenu() {
     const { action } = await inquirer.prompt([{
         type: 'list', name: 'action', message: magenta('📋 Issue Operation:'),
         choices: [
-            { name: `  ${dim('⬅  Back to main menu')}`, value: 'back' },
+            { name: `  ${dim('⬅  Back')}`, value: 'back' },
             new inquirer.Separator(dim('  ─────────────────────────────')),
             { name: `  ${green('▸')} List open issues`, value: 'list' },
             { name: `  ${green('▸')} Create single issue`, value: 'create' },
-            { name: `  ${green('▸')} Bulk create from JSON`, value: 'bulk' },
+            { name: `  ${magenta('▸')} Bulk create from file (JSON/MD)`, value: 'bulk' },
             { name: `  ${red('▸')} Close issue`, value: 'close' },
             { name: `  ${green('▸')} Reopen issue`, value: 'reopen' },
             { name: `  ${red('▸')} Delete (close & lock)`, value: 'delete' },
@@ -284,30 +380,25 @@ async function issueMenu() {
         const opts = await ask([
             { type: 'list', name: 'state', message: 'State:', choices: ['open', 'closed', 'all'], default: 'open' },
             { type: 'input', name: 'labels', message: dim('Filter by labels (optional, q=back):'), default: '' },
+            { type: 'input', name: 'limit', message: dim('Max results:'), default: '50' },
         ]);
-        await issues.listIssues({ state: opts.state, labels: opts.labels || undefined });
+        await issues.listIssues({ state: opts.state, labels: opts.labels || undefined, limit: parseInt(opts.limit) });
     } else if (action === 'create') {
         const a = await ask([
-            { type: 'input', name: 'title', message: yellow('Issue title') + dim(' (q=back):') },
-            { type: 'editor', name: 'body', message: 'Issue body (opens editor):' },
+            { type: 'input', name: 'title', message: yellow('Issue title'), validate: (v: string) => v.length > 0 || 'Required' },
+            { type: 'input', name: 'body', message: dim('Issue body (optional):'), default: '' },
             { type: 'input', name: 'labels', message: dim('Labels (comma-separated):'), default: '' },
         ]);
         await issues.createIssue(a);
     } else if (action === 'bulk') {
         const a = await ask([
-            { type: 'input', name: 'file', message: yellow('📁 Path to issues JSON') + dim(' (q=back):') },
+            { type: 'input', name: 'file', message: yellow('📁 Path to issues file (JSON or MD)') + dim(' (q=back):') },
             { type: 'confirm', name: 'dryRun', message: 'Dry run first?', default: true },
             { type: 'number', name: 'start', message: dim('Start index:'), default: 1 },
             { type: 'number', name: 'end', message: dim('End index:'), default: 999 },
         ]);
         await issues.createIssuesFromFile(a.file, { dryRun: a.dryRun, start: a.start, end: a.end });
     } else if (action === 'assign-best') {
-        // ── Smart Auto-Assign Flow ──
-        // 1. Fetch all open issues with comments
-        // 2. Filter to ones with applicant comments
-        // 3. Let user pick from a list
-        // 4. Show applicants + scores, then assign best
-
         const spinner = createSpinner(dim('Finding issues with applicants...')).start();
         const octokit = getOctokit();
 
@@ -315,10 +406,7 @@ async function issueMenu() {
             owner: getOwner(), repo: getRepo(), state: 'open', per_page: 50,
         });
 
-        // Filter to real issues (not PRs) with comments
-        const realIssues = allIssues.filter((i) => !i.pull_request && i.comments > 0);
-
-        // Check each issue for applicant comments
+        const realIssues = allIssues.filter((i: any) => !i.pull_request && i.comments > 0);
         const issuesWithApplicants: Array<{ number: number; title: string; applicants: string[]; labels: string[] }> = [];
 
         for (const issue of realIssues) {
@@ -327,7 +415,7 @@ async function issueMenu() {
             });
 
             const applicantUsers = new Set<string>();
-            comments.forEach((c) => {
+            comments.forEach((c: any) => {
                 if (c.user?.login && c.user.login !== 'github-actions[bot]') {
                     applicantUsers.add(c.user.login);
                 }
@@ -338,7 +426,7 @@ async function issueMenu() {
                     number: issue.number,
                     title: issue.title.substring(0, 45),
                     applicants: Array.from(applicantUsers),
-                    labels: issue.labels.map((l) => typeof l === 'string' ? l : l.name || '').filter(Boolean),
+                    labels: issue.labels.map((l: any) => typeof l === 'string' ? l : l.name || '').filter(Boolean),
                 });
             }
         }
@@ -352,7 +440,6 @@ async function issueMenu() {
 
         console.log(`\n${bold(`🏆 Issues with Applicants`)} (${issuesWithApplicants.length})\n`);
 
-        // Let user pick an issue
         const { picked } = await inquirer.prompt([{
             type: 'list', name: 'picked', message: yellow('Select an issue:'),
             choices: [
@@ -365,8 +452,6 @@ async function issueMenu() {
         }]);
 
         if (picked === -1) return;
-
-        // Run the scoring
         await issues.assignBest(picked);
 
     } else if (action === 'close' || action === 'reopen' || action === 'delete') {
@@ -401,7 +486,7 @@ async function prMenu() {
     const { action } = await inquirer.prompt([{
         type: 'list', name: 'action', message: cyan('🔀 PR Operation:'),
         choices: [
-            { name: `  ${dim('⬅  Back to main menu')}`, value: 'back' },
+            { name: `  ${dim('⬅  Back')}`, value: 'back' },
             new inquirer.Separator(dim('  ─────────────────────────────')),
             { name: `  ${green('▸')} List pull requests`, value: 'list' },
             { name: `  ${green('▸')} Merge PR ${dim('(checks CI first)')}`, value: 'merge' },
@@ -416,8 +501,11 @@ async function prMenu() {
     if (action === 'back') return;
 
     if (action === 'list') {
-        const { state } = await inquirer.prompt([{ type: 'list', name: 'state', message: 'State:', choices: ['open', 'closed', 'all'] }]);
-        await prs.listPRs({ state });
+        const a = await ask([
+            { type: 'list', name: 'state', message: 'State:', choices: ['open', 'closed', 'all'], default: 'open' },
+            { type: 'input', name: 'limit', message: dim('Max results:'), default: '50' },
+        ]);
+        await prs.listPRs({ state: a.state, limit: parseInt(a.limit) });
     } else if (action === 'merge' || action === 'force-merge') {
         const a = await ask([
             { type: 'input', name: 'n', message: yellow('PR #') + dim(' (q=back):') },
@@ -445,7 +533,7 @@ async function repoMenu() {
     const { action } = await inquirer.prompt([{
         type: 'list', name: 'action', message: green('📦 Repo Operation:'),
         choices: [
-            { name: `  ${dim('⬅  Back to main menu')}`, value: 'back' },
+            { name: `  ${dim('⬅  Back')}`, value: 'back' },
             new inquirer.Separator(dim('  ─────────────────────────────')),
             { name: `  ${green('▸')} List repositories`, value: 'list' },
             { name: `  ${green('▸')} Create repo`, value: 'create' },
@@ -459,8 +547,11 @@ async function repoMenu() {
     if (action === 'back') return;
 
     if (action === 'list') {
-        const { org } = await ask([{ type: 'input', name: 'org', message: cyan('Org (blank for yours, q=back):'), default: '' }]);
-        await repos.listRepos({ org: org || undefined });
+        const a = await ask([
+            { type: 'input', name: 'org', message: cyan('Org (blank for yours, q=back):'), default: '' },
+            { type: 'input', name: 'limit', message: dim('Max results:'), default: '50' },
+        ]);
+        await repos.listRepos({ org: a.org || undefined, limit: parseInt(a.limit) });
     } else if (action === 'create') {
         const a = await ask([
             { type: 'input', name: 'name', message: yellow('📦 Repo name') + dim(' (q=back):') },
@@ -470,26 +561,88 @@ async function repoMenu() {
         ]);
         await repos.createRepo(a.name, { org: a.org || undefined, description: a.description, private: a.isPrivate });
     } else if (action === 'delete') {
-        const repoName = await ask([
-            { type: 'input', name: 'name', message: red('📦 Repo to DELETE') + dim(' (q=back):') },
-            { type: 'input', name: 'org', message: 'Org:', default: getOwner() },
+        const { org } = await ask([
+            { type: 'input', name: 'org', message: cyan('👤 Org/Owner name') + dim(' (q=back):'), default: getOwner() },
         ]);
+
+        const fetchedRepos = await repos.listRepos({ org, silent: true });
+        let repoToDelete: string;
+
+        if (fetchedRepos.length > 0) {
+            const { selection } = await inquirer.prompt([{
+                type: 'list',
+                name: 'selection',
+                message: red('📦 Select Repo to DELETE:'),
+                choices: [
+                    { name: dim('⬅  Back'), value: 'back' },
+                    ...fetchedRepos.map((r: any) => ({ name: r.name, value: r.name }))
+                ]
+            }]);
+            if (selection === 'back') return;
+            repoToDelete = selection;
+        } else {
+            const { name } = await ask([{ type: 'input', name: 'name', message: red('📦 Repo name to DELETE:') }]);
+            repoToDelete = name;
+        }
+
         const { confirm } = await ask([
-            { type: 'input', name: 'confirm', message: red(`⚠️  Type "${repoName.name}" to confirm deletion:`), validate: (v: string) => v === repoName.name || 'Name doesn\'t match' },
+            { type: 'input', name: 'confirm', message: red(`⚠️  Type "${repoToDelete}" to confirm deletion:`), validate: (v: string) => v === repoToDelete || 'Name doesn\'t match' },
         ]);
-        if (confirm === repoName.name) await repos.deleteRepo(repoName.name, { org: repoName.org });
+        if (confirm === repoToDelete) await repos.deleteRepo(repoToDelete, { org });
     } else if (action === 'clone') {
-        const a = await ask([
-            { type: 'input', name: 'name', message: cyan('Repo name') + dim(' (q=back):') },
-            { type: 'input', name: 'org', message: dim('Org:'), default: getOwner() },
+        const { org } = await ask([
+            { type: 'input', name: 'org', message: cyan('👤 Org/Owner name') + dim(' (q=back):'), default: getOwner() },
         ]);
-        await repos.cloneRepo(a.name, { org: a.org });
+
+        const fetchedRepos = await repos.listRepos({ org, silent: true });
+        let repoToClone: string;
+
+        if (fetchedRepos.length > 0) {
+            const { selection } = await inquirer.prompt([{
+                type: 'list',
+                name: 'selection',
+                message: cyan('📦 Select Repo to Clone:'),
+                choices: [
+                    { name: dim('⬅  Back'), value: 'back' },
+                    ...fetchedRepos.map((r: any) => ({ name: r.name, value: r.name }))
+                ]
+            }]);
+            if (selection === 'back') return;
+            repoToClone = selection;
+        } else {
+            const { name } = await ask([{ type: 'input', name: 'name', message: cyan('📦 Repo name to Clone:') }]);
+            repoToClone = name;
+        }
+
+        const { dir } = await ask([
+            { type: 'input', name: 'dir', message: dim('Destination path (leave blank for default):'), default: '' },
+        ]);
+        await repos.cloneRepo(repoToClone, { org, dir: dir || undefined });
     } else if (action === 'info') {
-        const a = await ask([
-            { type: 'input', name: 'name', message: cyan('Repo name:'), default: getRepo() },
-            { type: 'input', name: 'org', message: dim('Org:'), default: getOwner() },
+        const { org } = await ask([
+            { type: 'input', name: 'org', message: cyan('👤 Org/Owner name') + dim(' (q=back):'), default: getOwner() },
         ]);
-        await repos.repoInfo(a.name, { org: a.org });
+
+        const fetchedRepos = await repos.listRepos({ org, silent: true });
+        let repoToInfo: string;
+
+        if (fetchedRepos.length > 0) {
+            const { selection } = await inquirer.prompt([{
+                type: 'list',
+                name: 'selection',
+                message: cyan('📦 Select Repo for Info:'),
+                choices: [
+                    { name: dim('⬅  Back'), value: 'back' },
+                    ...fetchedRepos.map((r: any) => ({ name: r.name, value: r.name }))
+                ]
+            }]);
+            if (selection === 'back') return;
+            repoToInfo = selection;
+        } else {
+            const { name } = await ask([{ type: 'input', name: 'name', message: cyan('📦 Repo name:') }]);
+            repoToInfo = name;
+        }
+        await repos.repoInfo(repoToInfo, { org });
     } else if (action === 'topics') {
         const a = await ask([
             { type: 'input', name: 'name', message: cyan('Repo name:'), default: getRepo() },
@@ -499,12 +652,12 @@ async function repoMenu() {
     }
 }
 
-// ── Contributor Menu ───────────────────────────────────────────────────
-async function contributorMenu() {
+// ── Contributor Scoring Menu (Maintainer Tool) ─────────────────────────
+async function contributorScoringMenu() {
     const { action } = await inquirer.prompt([{
         type: 'list', name: 'action', message: yellow('🏆 Contributor Operation:'),
         choices: [
-            { name: `  ${dim('⬅  Back to main menu')}`, value: 'back' },
+            { name: `  ${dim('⬅  Back')}`, value: 'back' },
             new inquirer.Separator(dim('  ─────────────────────────────')),
             { name: `  ${yellow('▸')} Score a user`, value: 'score' },
             { name: `  ${yellow('▸')} Rank applicants for issue`, value: 'rank' },
@@ -520,8 +673,9 @@ async function contributorMenu() {
     } else if (action === 'rank') {
         const { n } = await ask([{ type: 'input', name: 'n', message: yellow('Issue #') + dim(' (q=back):') }]);
         await contributors.rankApplicants(parseInt(n));
-    } else {
-        await contributors.listContributors({});
+    } else if (action === 'list') {
+        const a = await ask([{ type: 'input', name: 'limit', message: dim('Max results (q=back):'), default: '50' }]);
+        await contributors.listContributors({ limit: parseInt(a.limit) });
     }
 }
 
@@ -530,25 +684,27 @@ async function releaseMenu() {
     const { action } = await inquirer.prompt([{
         type: 'list', name: 'action', message: red('🚀 Release Operation:'),
         choices: [
-            { name: `  ${dim('⬅  Back to main menu')}`, value: 'back' },
+            { name: `  ${dim('⬅  Back')}`, value: 'back' },
             new inquirer.Separator(dim('  ─────────────────────────────')),
-            { name: `  ${red('▸')} Create release`, value: 'create' },
-            { name: `  ${cyan('▸')} List releases`, value: 'list' },
+            { name: `  ${green('▸')} List releases`, value: 'list' },
+            { name: `  ${green('▸')} Create release`, value: 'create' },
         ],
     }]);
 
     if (action === 'back') return;
 
-    if (action === 'create') {
+    if (action === 'list') {
+        const a = await ask([{ type: 'input', name: 'limit', message: dim('Max results:'), default: '50' }]);
+        await releases.listReleases({ limit: parseInt(a.limit) });
+    } else if (action === 'create') {
         const a = await ask([
-            { type: 'input', name: 'tag', message: yellow('Tag (e.g., v1.0.0)') + dim(' (q=back):') },
-            { type: 'input', name: 'name', message: dim('Release name:'), default: '' },
+            { type: 'input', name: 'tag', message: yellow('Tag (e.g. v1.0.0):') },
+            { type: 'input', name: 'name', message: dim('Release name (optional):'), default: '' },
+            { type: 'input', name: 'body', message: dim('Release body (optional):'), default: '' },
             { type: 'confirm', name: 'draft', message: 'Draft?', default: false },
-            { type: 'confirm', name: 'prerelease', message: 'Pre-release?', default: false },
+            { type: 'confirm', name: 'prerelease', message: 'Prerelease?', default: false },
         ]);
-        await releases.createRelease(a.tag, { name: a.name || a.tag, draft: a.draft, prerelease: a.prerelease });
-    } else {
-        await releases.listReleases({});
+        await releases.createRelease(a.tag, { name: a.name, body: a.body, draft: a.draft, prerelease: a.prerelease });
     }
 }
 
@@ -569,53 +725,72 @@ function setupCommander(): Command {
 
     // Issues
     const i = program.command('issues').description('📋 Manage issues');
-    i.command('list').option('-s, --state <s>', '', 'open').option('-l, --labels <l>').option('-n, --limit <n>', '', '25')
-        .action((o) => issues.listIssues({ state: o.state, labels: o.labels, limit: parseInt(o.limit) }));
+    i.command('list').option('-s, --state <s>', '', 'open').option('-l, --labels <l>').option('-n, --limit <n>', '', '50')
+        .action(async (o) => { await issues.listIssues({ state: o.state, labels: o.labels, limit: parseInt(o.limit) }); });
     i.command('create').requiredOption('-t, --title <t>').option('-b, --body <b>').option('-l, --labels <l>')
-        .action((o) => issues.createIssue(o));
+        .action(async (o) => { await issues.createIssue(o); });
     i.command('bulk').requiredOption('-f, --file <f>').option('-d, --dry-run').option('--start <n>', '', '1').option('--end <n>', '', '999')
-        .action((o) => issues.createIssuesFromFile(o.file, { dryRun: o.dryRun, start: parseInt(o.start), end: parseInt(o.end) }));
-    i.command('close <n>').action((n) => issues.closeIssue(parseInt(n)));
-    i.command('reopen <n>').action((n) => issues.reopenIssue(parseInt(n)));
-    i.command('delete <n>').action((n) => issues.deleteIssue(parseInt(n)));
-    i.command('assign <n> <users...>').action((n, u) => issues.assignIssue(parseInt(n), u));
-    i.command('assign-best <n>').action((n) => issues.assignBest(parseInt(n)));
-    i.command('search <q>').action((q) => issues.searchIssues(q));
-    i.command('label <n> <labels...>').action((n, l) => issues.labelIssue(parseInt(n), l));
+        .action(async (o) => { await issues.createIssuesFromFile(o.file, { dryRun: o.dryRun, start: parseInt(o.start), end: parseInt(o.end) }); });
+    i.command('close <n>').action(async (n) => { await issues.closeIssue(parseInt(n)); });
+    i.command('reopen <n>').action(async (n) => { await issues.reopenIssue(parseInt(n)); });
+    i.command('delete <n>').action(async (n) => { await issues.deleteIssue(parseInt(n)); });
+    i.command('assign <n> <users...>').action(async (n, u) => { await issues.assignIssue(parseInt(n), u); });
+    i.command('assign-best <n>').action(async (n) => { await issues.assignBest(parseInt(n)); });
+    i.command('search <q>').action(async (q) => { await issues.searchIssues(q); });
+    i.command('label <n> <labels...>').action(async (n, l) => { await issues.labelIssue(parseInt(n), l); });
 
     // PRs
     const p = program.command('prs').description('🔀 Manage pull requests');
-    p.command('list').option('-s, --state <s>', '', 'open').option('-n, --limit <n>', '', '25')
-        .action((o) => prs.listPRs({ state: o.state, limit: parseInt(o.limit) }));
+    p.command('list').option('-s, --state <s>', '', 'open').option('-n, --limit <n>', '', '50')
+        .action(async (o) => { await prs.listPRs({ state: o.state, limit: parseInt(o.limit) }); });
     p.command('merge <n>').option('-m, --method <m>', '', 'squash').option('--message <msg>').option('-f, --force', 'Skip CI checks')
-        .action((n, o) => prs.mergePR(parseInt(n), o));
-    p.command('close <n>').action((n) => prs.closePR(parseInt(n)));
-    p.command('review <n>').action((n) => prs.reviewPR(parseInt(n)));
-    p.command('approve <n>').action((n) => prs.approvePR(parseInt(n)));
-    p.command('diff <n>').action((n) => prs.diffPR(parseInt(n)));
+        .action(async (n, o) => { await prs.mergePR(parseInt(n), o); });
+    p.command('close <n>').action(async (n) => { await prs.closePR(parseInt(n)); });
+    p.command('review <n>').action(async (n) => { await prs.reviewPR(parseInt(n)); });
+    p.command('approve <n>').action(async (n) => { await prs.approvePR(parseInt(n)); });
+    p.command('diff <n>').action(async (n) => { await prs.diffPR(parseInt(n)); });
 
     // Repos
     const r = program.command('repo').description('📦 Manage repositories');
-    r.command('list').option('-o, --org <o>').option('-n, --limit <n>', '', '25')
-        .action((o) => repos.listRepos({ org: o.org, limit: parseInt(o.limit) }));
+    r.command('list').option('-o, --org <o>').option('-n, --limit <n>', '', '50')
+        .action(async (o) => { await repos.listRepos({ org: o.org, limit: parseInt(o.limit) }); });
     r.command('create <name>').option('-o, --org <o>').option('-p, --private').option('-d, --description <d>')
-        .action((n, o) => repos.createRepo(n, o));
-    r.command('delete <name>').option('-o, --org <o>').action((n, o) => repos.deleteRepo(n, o));
-    r.command('clone <name>').option('-o, --org <o>').option('-d, --dir <d>').action((n, o) => repos.cloneRepo(n, o));
-    r.command('info <name>').option('-o, --org <o>').action((n, o) => repos.repoInfo(n, o));
-    r.command('topics <name> <topics...>').option('-o, --org <o>').action((n, t, o) => repos.setTopics(n, t, o));
+        .action(async (n, o) => { await repos.createRepo(n, o); });
+    r.command('delete <name>').option('-o, --org <o>').action(async (n, o) => { await repos.deleteRepo(n, o); });
+    r.command('clone <name>').option('-o, --org <o>').option('-d, --dir <d>').action(async (n, o) => { await repos.cloneRepo(n, o); });
+    r.command('info <name>').option('-o, --org <o>').action(async (n, o) => { await repos.repoInfo(n, o); });
+    r.command('topics <name> <topics...>').option('-o, --org <o>').action(async (n, t, o) => { await repos.setTopics(n, t, o); });
 
     // Contributors
     const c = program.command('contributors').description('🏆 Manage contributors');
-    c.command('score <user>').action((u) => contributors.scoreUser(u));
-    c.command('rank <issue>').action((n) => contributors.rankApplicants(parseInt(n)));
-    c.command('list').option('-n, --limit <n>', '', '25').action((o) => contributors.listContributors({ limit: parseInt(o.limit) }));
+    c.command('score <user>').action(async (u) => { await contributors.scoreUser(u); });
+    c.command('rank <issue>').action(async (n) => { await contributors.rankApplicants(parseInt(n)); });
+    c.command('list').option('-n, --limit <n>', '', '50').action(async (o) => { await contributors.listContributors({ limit: parseInt(o.limit) }); });
 
     // Releases
     const rel = program.command('release').description('🚀 Manage releases');
     rel.command('create <tag>').option('-n, --name <n>').option('-b, --body <b>').option('-d, --draft').option('-p, --prerelease').option('--no-generate')
-        .action((t, o) => releases.createRelease(t, o));
-    rel.command('list').option('-n, --limit <n>', '', '10').action((o) => releases.listReleases({ limit: parseInt(o.limit) }));
+        .action(async (t, o) => { await releases.createRelease(t, o); });
+    rel.command('list').option('-n, --limit <n>', '', '50').action(async (o) => { await releases.listReleases({ limit: parseInt(o.limit) }); });
+
+    // Contributor Commands
+    // ILLUSTRATION: How to start? 
+    // Option A: `gitpadi start https://github.com/owner/repo`
+    // Option B: Interactive Menu -> Contributor Mode -> Start Contribution
+    program.command('start <url>').description('🚀 Start contribution (fork, clone & branch)').action(async (u) => { await contribute.forkAndClone(u); });
+    program.command('sync').description('🔄 Sync with upstream').action(async () => { await contribute.syncBranch(); });
+    program.command('submit').description('🚀 Submit PR (add, commit, push & PR)')
+        .option('-t, --title <t>', 'PR title')
+        .option('-m, --message <m>', 'Commit message')
+        .option('-i, --issue <n>', 'Issue number')
+        .action(async (o) => {
+            await contribute.submitPR({
+                title: o.title || 'Automated PR',
+                message: o.message || o.title,
+                issue: o.issue ? parseInt(o.issue) : undefined
+            });
+        });
+    program.command('logs').description('📋 View Action logs').action(async () => { await contribute.viewLogs(); });
 
     return program;
 }
@@ -624,7 +799,7 @@ function setupCommander(): Command {
 async function main() {
     if (process.argv.length <= 2) {
         await bootSequence();
-        await onboarding();
+        await ensureAuthenticated();
         await mainMenu();
     } else {
         const program = setupCommander();