gitpadi 2.0.0 → 2.0.2

package/dist/cli.js

@@ -0,0 +1,789 @@
+#!/usr/bin/env node
+// ═══════════════════════════════════════════════════════════════════════
+//  GitPadi v2.0 — Your AI-Powered GitHub Management Terminal
+//  "Built different. Run different."
+// ═══════════════════════════════════════════════════════════════════════
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import gradient from 'gradient-string';
+import figlet from 'figlet';
+import boxen from 'boxen';
+import { createSpinner } from 'nanospinner';
+import { Octokit } from '@octokit/rest';
+import { initGitHub, setRepo, getOwner, getRepo, getOctokit, 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';
+// ── Styling ────────────────────────────────────────────────────────────
+const cyber = gradient(['#ff00ff', '#00ffff', '#ff00ff']);
+const neon = gradient(['#00ff87', '#60efff']);
+const fire = gradient(['#ff6b35', '#f7c948', '#ff6b35']);
+const dim = chalk.dim;
+const bold = chalk.bold;
+const green = chalk.greenBright;
+const cyan = chalk.cyanBright;
+const magenta = chalk.magentaBright;
+const yellow = chalk.yellowBright;
+const red = chalk.redBright;
+// ── Utilities ──────────────────────────────────────────────────────────
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function typewriter(text, speed = 20) {
+    for (const char of text) {
+        process.stdout.write(char);
+        await sleep(speed);
+    }
+    console.log('');
+}
+function line(char = '─', len = 60) {
+    console.log(dim(char.repeat(len)));
+}
+// ── Back Navigation ────────────────────────────────────────────────────
+// Type 'q' at any text/number prompt to go back to the menu
+class BackToMenu extends Error {
+    constructor() { super('back'); }
+}
+function checkForBack(value) {
+    if (typeof value === 'string' && value.trim().toLowerCase() === 'q') {
+        throw new BackToMenu();
+    }
+}
+// Wraps inquirer.prompt — runs prompts one at a time, checks for 'q' after each
+async function ask(questions) {
+    const answers = {};
+    for (const question of questions) {
+        const ans = await inquirer.prompt([question]);
+        answers[question.name] = ans[question.name];
+        // Check for 'q' immediately after each text/number input
+        if ((question.type === 'input' || question.type === 'number' || question.type === 'password')) {
+            const val = String(answers[question.name] ?? '');
+            if (val.trim().toLowerCase() === 'q')
+                throw new BackToMenu();
+        }
+    }
+    return answers;
+}
+async function safeMenu(fn) {
+    try {
+        await fn();
+    }
+    catch (e) {
+        if (e instanceof BackToMenu) {
+            console.log(dim('\n  ↩  Back to main menu\n'));
+            return;
+        }
+        throw e; // Ctrl+C and other errors bubble up to trigger shutdown
+    }
+}
+// ── Boot Sequence ──────────────────────────────────────────────────────
+async function bootSequence() {
+    console.clear();
+    const banner = figlet.textSync('GitPadi', {
+        font: 'ANSI Shadow',
+        horizontalLayout: 'fitted',
+    });
+    console.log(cyber(banner));
+    console.log(boxen(`${bold('v' + VERSION)}  ${dim('|')}  ${dim('AI-Powered GitHub Management')}  ${dim('|')}  ${dim('by')} ${magenta('Netwalls')}`, {
+        padding: { left: 2, right: 2, top: 0, bottom: 0 },
+        borderStyle: 'double',
+        borderColor: 'magenta',
+        dimBorder: true,
+    }));
+    console.log('');
+    const bootSteps = [
+        '▸ Initializing GitPadi engine',
+        '▸ Loading command modules',
+        '▸ Establishing GitHub connection',
+        '▸ Systems online',
+    ];
+    for (const step of bootSteps) {
+        process.stdout.write(dim(step));
+        await sleep(150);
+        process.stdout.write(green(' ✓\n'));
+        await sleep(80);
+    }
+    console.log('');
+}
+// ── Onboarding ─────────────────────────────────────────────────────────
+/**
+ * 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) => {
+                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('\n  📦 Project Targeting — which repo are we working on?\n'));
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'owner',
+            message: cyan('👤 GitHub Owner/Org:'),
+            default: owner || '',
+            validate: (v) => v.length > 0 || 'Required',
+        },
+        {
+            type: 'input',
+            name: 'repo',
+            message: cyan('📦 Repository name:'),
+            default: repo || '',
+            validate: (v) => v.length > 0 || 'Required',
+        },
+    ]);
+    setRepo(answers.owner, answers.repo);
+    saveConfig({ token: getToken(), owner: answers.owner, repo: answers.repo });
+    const spinner = createSpinner(dim('Connecting...')).start();
+    await sleep(400);
+    spinner.success({ text: green(`Locked in → ${cyan(`${answers.owner}/${answers.repo}`)}`) });
+    console.log('');
+}
+// ── Mode Selector ──────────────────────────────────────────────────────
+async function mainMenu() {
+    while (true) {
+        line('═');
+        console.log(cyber('  ⟨ GITPADI MODE SELECTOR ⟩'));
+        console.log(dim('  Select your workflow persona to continue'));
+        line('═');
+        console.log('');
+        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();
+        }
+        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 () => {
+                const a = await inquirer.prompt([
+                    { type: 'input', name: 'owner', message: cyan('👤 New Owner/Org:'), default: getOwner() },
+                    { type: 'input', name: 'repo', message: cyan('📦 New Repo:'), default: getRepo() },
+                ]);
+                setRepo(a.owner, a.repo);
+                const s = createSpinner(dim('Switching...')).start();
+                await sleep(400);
+                s.success({ text: green(`Now targeting ${cyan(`${a.owner}/${a.repo}`)}`) });
+            });
+            continue;
+        }
+        if (category === 'issues')
+            await safeMenu(issueMenu);
+        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('');
+    }
+}
+// ── Issue Menu ─────────────────────────────────────────────────────────
+async function issueMenu() {
+    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 open issues`, value: 'list' },
+                { name: `  ${green('▸')} Create single issue`, value: 'create' },
+                { 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' },
+                { name: `  ${cyan('▸')} Assign user`, value: 'assign' },
+                { name: `  ${yellow('▸')} Auto-assign best applicant`, value: 'assign-best' },
+                { name: `  ${cyan('▸')} Search issues`, value: 'search' },
+                { name: `  ${cyan('▸')} Add labels`, value: 'label' },
+            ],
+        }]);
+    if (action === 'back')
+        return;
+    if (action === 'list') {
+        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, limit: parseInt(opts.limit) });
+    }
+    else if (action === 'create') {
+        const a = await ask([
+            { type: 'input', name: 'title', message: yellow('Issue title'), validate: (v) => 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 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') {
+        const spinner = createSpinner(dim('Finding issues with applicants...')).start();
+        const octokit = getOctokit();
+        const { data: allIssues } = await octokit.issues.listForRepo({
+            owner: getOwner(), repo: getRepo(), state: 'open', per_page: 50,
+        });
+        const realIssues = allIssues.filter((i) => !i.pull_request && i.comments > 0);
+        const issuesWithApplicants = [];
+        for (const issue of realIssues) {
+            const { data: comments } = await octokit.issues.listComments({
+                owner: getOwner(), repo: getRepo(), issue_number: issue.number, per_page: 100,
+            });
+            const applicantUsers = new Set();
+            comments.forEach((c) => {
+                if (c.user?.login && c.user.login !== 'github-actions[bot]') {
+                    applicantUsers.add(c.user.login);
+                }
+            });
+            if (applicantUsers.size > 0) {
+                issuesWithApplicants.push({
+                    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),
+                });
+            }
+        }
+        spinner.stop();
+        if (issuesWithApplicants.length === 0) {
+            console.log(yellow('\n  ⚠️  No open issues with comments found.\n'));
+            return;
+        }
+        console.log(`\n${bold(`🏆 Issues with Applicants`)} (${issuesWithApplicants.length})\n`);
+        const { picked } = await inquirer.prompt([{
+                type: 'list', name: 'picked', message: yellow('Select an issue:'),
+                choices: [
+                    { name: `  ${dim('⬅  Back')}`, value: -1 },
+                    new inquirer.Separator(dim('  ─────────────────────────────')),
+                ].concat(issuesWithApplicants.map((i) => ({
+                    name: `  #${i.number}  ${bold(i.title)}  ${dim('—')} ${cyan(`${i.applicants.length} applicant(s):`)} ${i.applicants.map((u) => `@${u}`).join(', ')}`,
+                    value: i.number,
+                }))),
+            }]);
+        if (picked === -1)
+            return;
+        await issues.assignBest(picked);
+    }
+    else if (action === 'close' || action === 'reopen' || action === 'delete') {
+        const { n } = await ask([{ type: 'input', name: 'n', message: yellow('Issue #') + dim(' (q=back):') }]);
+        if (!n || isNaN(Number(n)))
+            return;
+        if (action === 'close')
+            await issues.closeIssue(n);
+        else if (action === 'reopen')
+            await issues.reopenIssue(n);
+        else if (action === 'delete') {
+            const { confirm } = await inquirer.prompt([{ type: 'confirm', name: 'confirm', message: red('⚠️  This will close & lock the issue. Proceed?'), default: false }]);
+            if (confirm)
+                await issues.deleteIssue(n);
+        }
+    }
+    else if (action === 'assign') {
+        const a = await ask([
+            { type: 'input', name: 'n', message: yellow('Issue #') + dim(' (q=back):') },
+            { type: 'input', name: 'users', message: cyan('Username(s) (space-separated):') },
+        ]);
+        await issues.assignIssue(a.n, a.users.split(/\s+/));
+    }
+    else if (action === 'search') {
+        const { q } = await ask([{ type: 'input', name: 'q', message: cyan('🔍 Search query') + dim(' (q=back):') }]);
+        await issues.searchIssues(q);
+    }
+    else if (action === 'label') {
+        const a = await ask([
+            { type: 'input', name: 'n', message: yellow('Issue #') + dim(' (q=back):') },
+            { type: 'input', name: 'labels', message: cyan('Labels (space-separated):') },
+        ]);
+        await issues.labelIssue(a.n, a.labels.split(/\s+/));
+    }
+}
+// ── PR Menu ────────────────────────────────────────────────────────────
+async function prMenu() {
+    const { action } = await inquirer.prompt([{
+            type: 'list', name: 'action', message: cyan('🔀 PR Operation:'),
+            choices: [
+                { 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' },
+                { name: `  ${yellow('▸')} Force merge ${dim('(skip CI checks)')}`, value: 'force-merge' },
+                { name: `  ${red('▸')} Close PR`, value: 'close' },
+                { name: `  ${yellow('▸')} Auto-review PR`, value: 'review' },
+                { name: `  ${green('▸')} Approve PR`, value: 'approve' },
+                { name: `  ${cyan('▸')} View diff`, value: 'diff' },
+            ],
+        }]);
+    if (action === 'back')
+        return;
+    if (action === 'list') {
+        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):') },
+            {
+                type: 'list', name: 'method', message: 'Merge method:', choices: [
+                    { name: `${green('squash')} ${dim('— clean single commit')}`, value: 'squash' },
+                    { name: `${cyan('merge')}  ${dim('— preserve all commits')}`, value: 'merge' },
+                    { name: `${yellow('rebase')} ${dim('— linear history')}`, value: 'rebase' },
+                ]
+            },
+            { type: 'confirm', name: 'confirm', message: action === 'force-merge' ? yellow('⚠️  Force merge (skip CI)?') : red('⚠️  Merge this PR?'), default: false },
+        ]);
+        if (a.confirm)
+            await prs.mergePR(a.n, { method: a.method, force: action === 'force-merge' });
+    }
+    else {
+        const { n } = await ask([{ type: 'input', name: 'n', message: yellow('PR #') + dim(' (q=back):') }]);
+        if (action === 'close')
+            await prs.closePR(n);
+        else if (action === 'review')
+            await prs.reviewPR(n);
+        else if (action === 'approve')
+            await prs.approvePR(n);
+        else
+            await prs.diffPR(n);
+    }
+}
+// ── Repo Menu ──────────────────────────────────────────────────────────
+async function repoMenu() {
+    const { action } = await inquirer.prompt([{
+            type: 'list', name: 'action', message: green('📦 Repo Operation:'),
+            choices: [
+                { name: `  ${dim('⬅  Back')}`, value: 'back' },
+                new inquirer.Separator(dim('  ─────────────────────────────')),
+                { name: `  ${green('▸')} List repositories`, value: 'list' },
+                { name: `  ${green('▸')} Create repo`, value: 'create' },
+                { name: `  ${red('▸')} Delete repo`, value: 'delete' },
+                { name: `  ${cyan('▸')} Clone repo`, value: 'clone' },
+                { name: `  ${cyan('▸')} Repo info`, value: 'info' },
+                { name: `  ${cyan('▸')} Set topics`, value: 'topics' },
+            ],
+        }]);
+    if (action === 'back')
+        return;
+    if (action === 'list') {
+        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):') },
+            { type: 'input', name: 'org', message: dim('Org (blank for personal):'), default: '' },
+            { type: 'input', name: 'description', message: dim('Description:'), default: '' },
+            { type: 'confirm', name: 'isPrivate', message: 'Private?', default: false },
+        ]);
+        await repos.createRepo(a.name, { org: a.org || undefined, description: a.description, private: a.isPrivate });
+    }
+    else if (action === 'delete') {
+        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;
+        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) => ({ 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 "${repoToDelete}" to confirm deletion:`), validate: (v) => v === repoToDelete || 'Name doesn\'t match' },
+        ]);
+        if (confirm === repoToDelete)
+            await repos.deleteRepo(repoToDelete, { org });
+    }
+    else if (action === 'clone') {
+        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 repoToClone;
+        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) => ({ 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 { 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 repoToInfo;
+        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) => ({ 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() },
+            { type: 'input', name: 'topics', message: yellow('Topics (space-separated):') },
+        ]);
+        await repos.setTopics(a.name, a.topics.split(/\s+/), { org: getOwner() });
+    }
+}
+// ── 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')}`, value: 'back' },
+                new inquirer.Separator(dim('  ─────────────────────────────')),
+                { name: `  ${yellow('▸')} Score a user`, value: 'score' },
+                { name: `  ${yellow('▸')} Rank applicants for issue`, value: 'rank' },
+                { name: `  ${cyan('▸')} List contributors`, value: 'list' },
+            ],
+        }]);
+    if (action === 'back')
+        return;
+    if (action === 'score') {
+        const { u } = await ask([{ type: 'input', name: 'u', message: yellow('GitHub username') + dim(' (q=back):') }]);
+        await contributors.scoreUser(u);
+    }
+    else if (action === 'rank') {
+        const { n } = await ask([{ type: 'input', name: 'n', message: yellow('Issue #') + dim(' (q=back):') }]);
+        await contributors.rankApplicants(parseInt(n));
+    }
+    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) });
+    }
+}
+// ── Release Menu ───────────────────────────────────────────────────────
+async function releaseMenu() {
+    const { action } = await inquirer.prompt([{
+            type: 'list', name: 'action', message: red('🚀 Release Operation:'),
+            choices: [
+                { name: `  ${dim('⬅  Back')}`, value: 'back' },
+                new inquirer.Separator(dim('  ─────────────────────────────')),
+                { name: `  ${green('▸')} List releases`, value: 'list' },
+                { name: `  ${green('▸')} Create release`, value: 'create' },
+            ],
+        }]);
+    if (action === 'back')
+        return;
+    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):') },
+            { 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: 'Prerelease?', default: false },
+        ]);
+        await releases.createRelease(a.tag, { name: a.name, body: a.body, draft: a.draft, prerelease: a.prerelease });
+    }
+}
+// ── Commander (direct commands) ────────────────────────────────────────
+function setupCommander() {
+    const program = new Command();
+    program
+        .name('gitpadi')
+        .description(cyber('🤖 GitPadi — AI-powered GitHub management CLI'))
+        .version(VERSION)
+        .option('--owner <org>', 'GitHub owner/org')
+        .option('--repo <name>', 'GitHub repo name')
+        .option('--token <token>', 'GitHub token')
+        .hook('preAction', (cmd) => {
+        const o = cmd.opts();
+        initGitHub(o.token, o.owner, o.repo);
+    });
+    // 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>', '', '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(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(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>', '', '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(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>', '', '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(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(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(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;
+}
+// ── Entry Point ────────────────────────────────────────────────────────
+async function main() {
+    if (process.argv.length <= 2) {
+        await bootSequence();
+        await ensureAuthenticated();
+        await mainMenu();
+    }
+    else {
+        const program = setupCommander();
+        await program.parseAsync(process.argv);
+    }
+}
+main().catch(async (e) => {
+    // Ctrl+C / SIGINT — show nice shutdown
+    if (e?.name === 'ExitPromptError' || e?.message?.includes('force closed') || e?.message?.includes('SIGINT')) {
+        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 :)'));
+        console.log('');
+        process.exit(0);
+    }
+    console.error(red(`\n  ❌ Fatal: ${e.message}\n`));
+    process.exit(1);
+});