gitpadi 2.0.0

package/src/cli.ts

@@ -0,0 +1,648 @@
+#!/usr/bin/env npx tsx
+// ═══════════════════════════════════════════════════════════════════════
+//  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 { initGitHub, setRepo, getOwner, getRepo, getOctokit } 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';
+
+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: number) => new Promise((r) => setTimeout(r, ms));
+
+async function typewriter(text: string, speed: number = 20) {
+    for (const char of text) {
+        process.stdout.write(char);
+        await sleep(speed);
+    }
+    console.log('');
+}
+
+function line(char: string = '─', len: number = 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: any): void {
+    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: any[]): Promise<any> {
+    const answers: any = {};
+    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: () => Promise<void>) {
+    try {
+        await fn();
+    } catch (e: any) {
+        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 ─────────────────────────────────────────────────────────
+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('');
+        return;
+    }
+
+    console.log(neon('  ⚡ First-time setup — let\'s connect you to GitHub.\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 || '',
+            validate: (v: string) => v.length > 0 || 'Required',
+            when: !savedOwner,
+        },
+        {
+            type: 'input',
+            name: 'repo',
+            message: cyan('📦 Repository name:'),
+            default: savedRepo || '',
+            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}`)}`) });
+
+    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' }
+    ));
+    console.log('');
+}
+
+// ── Main Menu ──────────────────────────────────────────────────────────
+async function mainMenu() {
+    while (true) {
+        line('═');
+        console.log(cyber('  ⟨ GITPADI COMMAND CENTER ⟩'));
+        console.log(dim('  Select ⬅ Back on lists  •  Type q on text prompts'));
+        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;
+        }
+
+        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;
+        }
+
+        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);
+        if (category === 'prs') await safeMenu(prMenu);
+        if (category === 'repos') await safeMenu(repoMenu);
+        if (category === 'contributors') await safeMenu(contributorMenu);
+        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 to main menu')}`, 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: `  ${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: '' },
+        ]);
+        await issues.listIssues({ state: opts.state, labels: opts.labels || undefined });
+    } 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: '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: '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();
+
+        const { data: allIssues } = await octokit.issues.listForRepo({
+            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 issuesWithApplicants: Array<{ number: number; title: string; applicants: string[]; labels: string[] }> = [];
+
+        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<string>();
+            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`);
+
+        // Let user pick an issue
+        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,
+            })) as any),
+        }]);
+
+        if (picked === -1) return;
+
+        // Run the scoring
+        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 to main menu')}`, 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 { state } = await inquirer.prompt([{ type: 'list', name: 'state', message: 'State:', choices: ['open', 'closed', 'all'] }]);
+        await prs.listPRs({ state });
+    } 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 to main menu')}`, 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 { org } = await ask([{ type: 'input', name: 'org', message: cyan('Org (blank for yours, q=back):'), default: '' }]);
+        await repos.listRepos({ org: org || undefined });
+    } 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 repoName = await ask([
+            { type: 'input', name: 'name', message: red('📦 Repo to DELETE') + dim(' (q=back):') },
+            { type: 'input', name: 'org', message: 'Org:', default: getOwner() },
+        ]);
+        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' },
+        ]);
+        if (confirm === repoName.name) await repos.deleteRepo(repoName.name, { org: repoName.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() },
+        ]);
+        await repos.cloneRepo(a.name, { org: a.org });
+    } 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() },
+        ]);
+        await repos.repoInfo(a.name, { org: a.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 Menu ───────────────────────────────────────────────────
+async function contributorMenu() {
+    const { action } = await inquirer.prompt([{
+        type: 'list', name: 'action', message: yellow('🏆 Contributor Operation:'),
+        choices: [
+            { name: `  ${dim('⬅  Back to main menu')}`, 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 {
+        await contributors.listContributors({});
+    }
+}
+
+// ── Release Menu ───────────────────────────────────────────────────────
+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' },
+            new inquirer.Separator(dim('  ─────────────────────────────')),
+            { name: `  ${red('▸')} Create release`, value: 'create' },
+            { name: `  ${cyan('▸')} List releases`, value: 'list' },
+        ],
+    }]);
+
+    if (action === 'back') return;
+
+    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: 'confirm', name: 'draft', message: 'Draft?', default: false },
+            { type: 'confirm', name: 'prerelease', message: 'Pre-release?', default: false },
+        ]);
+        await releases.createRelease(a.tag, { name: a.name || a.tag, draft: a.draft, prerelease: a.prerelease });
+    } else {
+        await releases.listReleases({});
+    }
+}
+
+// ── Commander (direct commands) ────────────────────────────────────────
+function setupCommander(): Command {
+    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>', '', '25')
+        .action((o) => 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));
+    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));
+
+    // 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('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)));
+
+    // 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('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));
+
+    // 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) }));
+
+    // 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) }));
+
+    return program;
+}
+
+// ── Entry Point ────────────────────────────────────────────────────────
+async function main() {
+    if (process.argv.length <= 2) {
+        await bootSequence();
+        await onboarding();
+        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);
+});