gitpadi 2.0.0

package/src/commands/contributors.ts

@@ -0,0 +1,114 @@
+// commands/contributors.ts — Contributor management commands for GitPadi
+
+import chalk from 'chalk';
+import ora from 'ora';
+import Table from 'cli-table3';
+import { getOctokit, getOwner, getRepo, getFullRepo, requireRepo } from '../core/github.js';
+import { fetchProfile, scoreApplicant, TIER_EMOJI, type ScoredApplicant } from '../core/scorer.js';
+
+export async function scoreUser(username: string) {
+    requireRepo();
+    const spinner = ora(`Scoring @${username}...`).start();
+
+    try {
+        const profile = await fetchProfile(username);
+        const scored = scoreApplicant(profile);
+        spinner.stop();
+
+        console.log(`\n${chalk.bold(`🏆 Score: @${username}`)} — ${TIER_EMOJI[scored.tier]} Tier ${scored.tier} (${scored.score}/100)\n`);
+
+        const table = new Table({ style: { head: [], border: [] } });
+        table.push(
+            { [chalk.cyan('🏛️ Account Maturity')]: `${scored.breakdown.accountMaturity}/15` },
+            { [chalk.cyan('🔧 Repo Experience')]: `${scored.breakdown.repoExperience}/30` },
+            { [chalk.cyan('🌐 GitHub Presence')]: `${scored.breakdown.githubPresence}/15` },
+            { [chalk.cyan('⚡ Activity Level')]: `${scored.breakdown.activityLevel}/15` },
+            { [chalk.cyan('📝 Application')]: `${scored.breakdown.applicationQuality}/15` },
+            { [chalk.cyan('💻 Languages')]: `${scored.breakdown.languageRelevance}/10` },
+            { [chalk.bold('Total')]: chalk.bold(`${scored.score}/100`) },
+        );
+
+        console.log(table.toString());
+        console.log(`\n  ${chalk.dim('Account age:')} ${Math.round(scored.accountAge / 30)} months`);
+        console.log(`  ${chalk.dim('Public repos:')} ${scored.publicRepos}`);
+        console.log(`  ${chalk.dim('Followers:')} ${scored.followers}`);
+        console.log(`  ${chalk.dim('Languages:')} ${scored.relevantLanguages.slice(0, 8).join(', ') || 'None detected'}`);
+        console.log(`  ${chalk.dim('Repo PRs:')} ${scored.prsMerged} merged, ${scored.prsOpen} open`);
+        console.log('');
+    } catch (e: any) { spinner.fail(e.message); }
+}
+
+export async function rankApplicants(issueNumber: number) {
+    requireRepo();
+    const octokit = getOctokit();
+    const spinner = ora(`Finding applicants for #${issueNumber}...`).start();
+
+    try {
+        const { data: issue } = await octokit.issues.get({ owner: getOwner(), repo: getRepo(), issue_number: issueNumber });
+        const { data: comments } = await octokit.issues.listComments({ owner: getOwner(), repo: getRepo(), issue_number: issueNumber, per_page: 100 });
+        const labels = issue.labels.map((l) => typeof l === 'string' ? l : l.name || '').filter(Boolean);
+
+        const { isApplicationComment } = await import('../core/scorer.js');
+        const apps = comments.filter((c) => c.body && isApplicationComment(c.body) && c.user?.login !== 'github-actions[bot]');
+        const byUser = new Map<string, string>();
+        apps.forEach((c) => { if (c.user?.login) byUser.set(c.user.login, c.body || ''); });
+
+        if (byUser.size === 0) { spinner.warn('No applicants found.'); return; }
+
+        spinner.text = `Scoring ${byUser.size} applicant(s)...`;
+        const scored: ScoredApplicant[] = [];
+        for (const [user, body] of byUser) {
+            const profile = await fetchProfile(user, body);
+            scored.push(scoreApplicant(profile, labels));
+        }
+
+        scored.sort((a, b) => b.score - a.score);
+        spinner.stop();
+
+        const table = new Table({
+            head: ['Rank', 'User', 'Tier', 'Score', 'PRs', 'Activity', 'Languages'].map((h) => chalk.cyan(h)),
+            style: { head: [], border: [] },
+        });
+
+        scored.forEach((s, i) => {
+            const medal = i === 0 ? '🥇' : i === 1 ? '🥈' : i === 2 ? '🥉' : `${i + 1}.`;
+            table.push([medal, `@${s.username}`, `${TIER_EMOJI[s.tier]} ${s.tier}`, `${s.score}/100`, `${s.prsMerged}m/${s.prsOpen}o`, `${s.totalContributions}`, s.relevantLanguages.slice(0, 3).join(', ') || '-']);
+        });
+
+        console.log(`\n${chalk.bold(`🏆 Applicant Rankings — Issue #${issueNumber}`)}\n`);
+        console.log(table.toString());
+
+        if (scored.length >= 2) {
+            const gap = scored[0].score - scored[1].score;
+            if (gap >= 20) console.log(chalk.green(`\n  → Clear winner: @${scored[0].username} (+${gap} pts)`));
+            else if (gap >= 5) console.log(chalk.green(`\n  → Top pick: @${scored[0].username} (+${gap} pts)`));
+            else console.log(chalk.yellow(`\n  → Close match — review manually`));
+        }
+        console.log('');
+    } catch (e: any) { spinner.fail(e.message); }
+}
+
+export async function listContributors(opts: { limit?: number }) {
+    requireRepo();
+    const spinner = ora('Fetching contributors...').start();
+
+    try {
+        const { data } = await getOctokit().repos.listContributors({
+            owner: getOwner(), repo: getRepo(), per_page: opts.limit || 25,
+        });
+        spinner.stop();
+
+        const table = new Table({
+            head: ['#', 'User', 'Contributions'].map((h) => chalk.cyan(h)),
+            style: { head: [], border: [] },
+        });
+
+        data.forEach((c, i) => {
+            table.push([`${i + 1}.`, `@${c.login || '?'}`, `${c.contributions}`]);
+        });
+
+        console.log(`\n${chalk.bold(`👥 Contributors — ${getFullRepo()}`)} (${data.length})\n`);
+        console.log(table.toString());
+        console.log('');
+    } catch (e: any) { spinner.fail(e.message); }
+}

package/src/commands/issues.ts

@@ -0,0 +1,267 @@
+// commands/issues.ts — Issue management commands for GitPadi
+
+import chalk from 'chalk';
+import ora from 'ora';
+import Table from 'cli-table3';
+import { getOctokit, getOwner, getRepo, getFullRepo, requireRepo } from '../core/github.js';
+import { fetchProfile, scoreApplicant, isApplicationComment, TIER_EMOJI, type ScoredApplicant } from '../core/scorer.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+export async function listIssues(opts: { state?: string; labels?: string; limit?: number }) {
+    requireRepo();
+    const octokit = getOctokit();
+    const spinner = ora(`Fetching issues from ${chalk.cyan(getFullRepo())}...`).start();
+
+    try {
+        const { data: issues } = await octokit.issues.listForRepo({
+            owner: getOwner(), repo: getRepo(),
+            state: (opts.state as 'open' | 'closed' | 'all') || 'open',
+            labels: opts.labels || undefined,
+            per_page: opts.limit || 25,
+        });
+
+        // Filter out PRs (GitHub API returns PRs in issues endpoint)
+        const realIssues = issues.filter((i) => !i.pull_request);
+        spinner.stop();
+
+        if (realIssues.length === 0) {
+            console.log(chalk.yellow('\n  No issues found.\n'));
+            return;
+        }
+
+        const table = new Table({
+            head: ['#', 'Title', 'Labels', 'Assignee', 'State'].map((h) => chalk.cyan(h)),
+            style: { head: [], border: [] },
+        });
+
+        realIssues.forEach((i) => {
+            const labels = i.labels.map((l) => typeof l === 'string' ? l : l.name || '').join(', ');
+            const assignee = i.assignee?.login || chalk.dim('unassigned');
+            const state = i.state === 'open' ? chalk.green('open') : chalk.red('closed');
+            table.push([`#${i.number}`, i.title.substring(0, 60), labels.substring(0, 30), assignee, state]);
+        });
+
+        console.log(`\n${chalk.bold(`📋 Issues — ${getFullRepo()}`)} (${realIssues.length})\n`);
+        console.log(table.toString());
+        console.log('');
+    } catch (e: any) {
+        spinner.fail(`Failed: ${e.message}`);
+    }
+}
+
+export async function createIssue(opts: { title: string; body?: string; labels?: string; milestone?: string }) {
+    requireRepo();
+    const octokit = getOctokit();
+    const spinner = ora('Creating issue...').start();
+
+    try {
+        const { data } = await octokit.issues.create({
+            owner: getOwner(), repo: getRepo(),
+            title: opts.title,
+            body: opts.body || '',
+            labels: opts.labels ? opts.labels.split(',').map((l) => l.trim()) : undefined,
+        });
+
+        spinner.succeed(`Created issue ${chalk.green(`#${data.number}`)}: ${data.title}`);
+        console.log(chalk.dim(`  → ${data.html_url}\n`));
+    } catch (e: any) {
+        spinner.fail(`Failed: ${e.message}`);
+    }
+}
+
+export async function createIssuesFromFile(filePath: string, opts: { dryRun?: boolean; start?: number; end?: number }) {
+    requireRepo();
+    const resolved = path.resolve(filePath);
+    if (!fs.existsSync(resolved)) {
+        console.error(chalk.red(`\n❌ File not found: ${resolved}\n`));
+        return;
+    }
+
+    const config = JSON.parse(fs.readFileSync(resolved, 'utf-8'));
+    const issues = config.issues || [];
+    const start = opts.start || 1;
+    const end = opts.end || 999;
+    const filtered = issues.filter((i: any) => i.number >= start && i.number <= end);
+
+    console.log(`\n${chalk.bold('📋 GitPadi Issue Creator')}`);
+    console.log(chalk.dim(`  Repo:  ${getFullRepo()}`));
+    console.log(chalk.dim(`  File:  ${filePath}`));
+    console.log(chalk.dim(`  Range: #${start}-#${end} (${filtered.length} issues)`));
+    console.log(chalk.dim(`  Mode:  ${opts.dryRun ? 'DRY RUN' : 'LIVE'}\n`));
+
+    if (opts.dryRun) {
+        filtered.forEach((i: any) => {
+            console.log(`  ${chalk.dim(`#${String(i.number).padStart(2, '0')}`)}  ${i.title}`);
+            console.log(chalk.dim(`       [${i.labels.join(', ')}]`));
+        });
+        console.log(chalk.green(`\n✅ Dry run: ${filtered.length} issues would be created.\n`));
+        return;
+    }
+
+    const octokit = getOctokit();
+    let created = 0, failed = 0;
+
+    // Create labels if defined
+    if (config.labels) {
+        const spinner = ora('Setting up labels...').start();
+        try {
+            for (const [name, color] of Object.entries(config.labels)) {
+                try { await octokit.issues.createLabel({ owner: getOwner(), repo: getRepo(), name, color: color as string }); } catch { /* exists */ }
+            }
+            spinner.succeed('Labels ready');
+        } catch { spinner.warn('Labels skipped (permission)'); }
+    }
+
+    for (const issue of filtered) {
+        try {
+            const { data } = await octokit.issues.create({
+                owner: getOwner(), repo: getRepo(), title: issue.title, body: issue.body, labels: issue.labels,
+            });
+            created++;
+            console.log(`  ${chalk.green('✅')} #${String(issue.number).padStart(2, '0')} → GitHub #${data.number}`);
+            await new Promise((r) => setTimeout(r, 1200));
+        } catch (e: any) {
+            failed++;
+            console.log(`  ${chalk.red('❌')} #${String(issue.number).padStart(2, '0')}: ${e.message}`);
+        }
+    }
+
+    console.log(`\n  ${chalk.green(`✅ ${created}`)} created  ${chalk.red(`❌ ${failed}`)} failed\n`);
+}
+
+export async function closeIssue(number: number) {
+    requireRepo();
+    const spinner = ora(`Closing issue #${number}...`).start();
+    try {
+        await getOctokit().issues.update({ owner: getOwner(), repo: getRepo(), issue_number: number, state: 'closed' });
+        spinner.succeed(`Closed issue ${chalk.red(`#${number}`)}`);
+    } catch (e: any) { spinner.fail(e.message); }
+}
+
+export async function reopenIssue(number: number) {
+    requireRepo();
+    const spinner = ora(`Reopening issue #${number}...`).start();
+    try {
+        await getOctokit().issues.update({ owner: getOwner(), repo: getRepo(), issue_number: number, state: 'open' });
+        spinner.succeed(`Reopened issue ${chalk.green(`#${number}`)}`);
+    } catch (e: any) { spinner.fail(e.message); }
+}
+
+export async function deleteIssue(number: number) {
+    requireRepo();
+    const spinner = ora(`Deleting issue #${number}...`).start();
+    try {
+        // GitHub doesn't have a direct delete API for issues — close + lock as workaround
+        const octokit = getOctokit();
+        await octokit.issues.update({ owner: getOwner(), repo: getRepo(), issue_number: number, state: 'closed' });
+        await octokit.issues.lock({ owner: getOwner(), repo: getRepo(), issue_number: number, lock_reason: 'off-topic' });
+        spinner.succeed(`Closed & locked issue ${chalk.red(`#${number}`)} ${chalk.dim('(GitHub API does not support true deletion)')}`);
+    } catch (e: any) { spinner.fail(e.message); }
+}
+
+export async function assignIssue(number: number, assignees: string[]) {
+    requireRepo();
+    const spinner = ora(`Assigning #${number} to ${assignees.join(', ')}...`).start();
+    try {
+        await getOctokit().issues.addAssignees({ owner: getOwner(), repo: getRepo(), issue_number: number, assignees });
+        spinner.succeed(`Assigned ${chalk.cyan(assignees.join(', '))} to #${number}`);
+    } catch (e: any) { spinner.fail(e.message); }
+}
+
+export async function assignBest(number: number) {
+    requireRepo();
+    const octokit = getOctokit();
+    const spinner = ora(`Analyzing applicants for #${number}...`).start();
+
+    try {
+        const { data: comments } = await octokit.issues.listComments({
+            owner: getOwner(), repo: getRepo(), issue_number: number, per_page: 100,
+        });
+
+        const { data: issue } = await octokit.issues.get({ owner: getOwner(), repo: getRepo(), issue_number: number });
+        const labels = issue.labels.map((l) => typeof l === 'string' ? l : l.name || '').filter(Boolean);
+
+        const apps = comments.filter((c) => c.body && isApplicationComment(c.body) && c.user?.login !== 'github-actions[bot]');
+        const byUser = new Map<string, typeof apps[0]>();
+        apps.forEach((c) => { if (c.user?.login) byUser.set(c.user.login, c); });
+
+        if (byUser.size === 0) {
+            spinner.warn('No applicants found for this issue.');
+            return;
+        }
+
+        spinner.text = `Scoring ${byUser.size} applicant(s)...`;
+        const scored: ScoredApplicant[] = [];
+        for (const [user, comment] of byUser) {
+            const profile = await fetchProfile(user, comment.body || '');
+            scored.push(scoreApplicant(profile, labels));
+        }
+
+        scored.sort((a, b) => b.score - a.score);
+        spinner.stop();
+
+        const table = new Table({
+            head: ['Rank', 'User', 'Tier', 'Score', 'Merged PRs', 'Languages'].map((h) => chalk.cyan(h)),
+            style: { head: [], border: [] },
+        });
+
+        scored.forEach((s, i) => {
+            const medal = i === 0 ? '🥇' : i === 1 ? '🥈' : i === 2 ? '🥉' : `${i + 1}.`;
+            table.push([medal, `@${s.username}`, `${TIER_EMOJI[s.tier]} ${s.tier}`, `${s.score}/100`, String(s.prsMerged), s.relevantLanguages.slice(0, 3).join(', ') || '-']);
+        });
+
+        console.log(`\n${chalk.bold(`🏆 Applicant Rankings — Issue #${number}`)}\n`);
+        console.log(table.toString());
+
+        const best = scored[0];
+        console.log(`\n  ${chalk.green('→')} Best candidate: ${chalk.bold(`@${best.username}`)} (${TIER_EMOJI[best.tier]} Tier ${best.tier}, ${best.score}/100)`);
+
+        // Auto-assign the best
+        const assignSpinner = ora(`Assigning @${best.username}...`).start();
+        await octokit.issues.addAssignees({ owner: getOwner(), repo: getRepo(), issue_number: number, assignees: [best.username] });
+        assignSpinner.succeed(`Assigned ${chalk.cyan(`@${best.username}`)} to #${number}`);
+        console.log('');
+    } catch (e: any) {
+        spinner.fail(e.message);
+    }
+}
+
+export async function searchIssues(query: string) {
+    requireRepo();
+    const spinner = ora('Searching...').start();
+    try {
+        const { data } = await getOctokit().search.issuesAndPullRequests({
+            q: `repo:${getOwner()}/${getRepo()} is:issue ${query}`,
+            per_page: 20,
+        });
+        spinner.stop();
+
+        if (data.total_count === 0) {
+            console.log(chalk.yellow(`\n  No issues matching "${query}"\n`));
+            return;
+        }
+
+        const table = new Table({
+            head: ['#', 'Title', 'State'].map((h) => chalk.cyan(h)),
+            style: { head: [], border: [] },
+        });
+
+        data.items.forEach((i) => {
+            table.push([`#${i.number}`, i.title.substring(0, 65), i.state === 'open' ? chalk.green('open') : chalk.red('closed')]);
+        });
+
+        console.log(`\n${chalk.bold(`🔍 Search: "${query}"`)} (${data.total_count} results)\n`);
+        console.log(table.toString());
+        console.log('');
+    } catch (e: any) { spinner.fail(e.message); }
+}
+
+export async function labelIssue(number: number, labels: string[]) {
+    requireRepo();
+    const spinner = ora(`Adding labels to #${number}...`).start();
+    try {
+        await getOctokit().issues.addLabels({ owner: getOwner(), repo: getRepo(), issue_number: number, labels });
+        spinner.succeed(`Added ${chalk.cyan(labels.join(', '))} to #${number}`);
+    } catch (e: any) { spinner.fail(e.message); }
+}

package/src/commands/prs.ts

@@ -0,0 +1,243 @@
+// commands/prs.ts — Pull Request management commands for GitPadi
+
+import chalk from 'chalk';
+import ora from 'ora';
+import Table from 'cli-table3';
+import { getOctokit, getOwner, getRepo, getFullRepo, requireRepo } from '../core/github.js';
+
+export async function listPRs(opts: { state?: string; limit?: number }) {
+    requireRepo();
+    const spinner = ora(`Fetching PRs from ${chalk.cyan(getFullRepo())}...`).start();
+
+    try {
+        const { data: prs } = await getOctokit().pulls.list({
+            owner: getOwner(), repo: getRepo(),
+            state: (opts.state as 'open' | 'closed' | 'all') || 'open',
+            per_page: opts.limit || 25,
+        });
+
+        spinner.stop();
+        if (prs.length === 0) { console.log(chalk.yellow('\n  No pull requests found.\n')); return; }
+
+        const table = new Table({
+            head: ['#', 'Title', 'Author', 'Branch', 'State'].map((h) => chalk.cyan(h)),
+            style: { head: [], border: [] },
+        });
+
+        prs.forEach((pr) => {
+            const state = pr.state === 'open' ? chalk.green('open') : pr.merged_at ? chalk.magenta('merged') : chalk.red('closed');
+            table.push([`#${pr.number}`, pr.title.substring(0, 50), `@${pr.user?.login || '?'}`, pr.head.ref.substring(0, 25), state]);
+        });
+
+        console.log(`\n${chalk.bold(`🔀 Pull Requests — ${getFullRepo()}`)} (${prs.length})\n`);
+        console.log(table.toString());
+        console.log('');
+    } catch (e: any) { spinner.fail(e.message); }
+}
+
+export async function mergePR(number: number, opts: { method?: string; message?: string; force?: boolean }) {
+    requireRepo();
+    const octokit = getOctokit();
+    const method = (opts.method || 'squash') as 'merge' | 'squash' | 'rebase';
+
+    try {
+        // Force merge — skip CI
+        if (opts.force) {
+            const spinner = ora(`Force merging PR #${number} via ${method}...`).start();
+            const { data } = await octokit.pulls.merge({
+                owner: getOwner(), repo: getRepo(), pull_number: number,
+                merge_method: method, commit_message: opts.message,
+            });
+            if (data.merged) {
+                spinner.succeed(`Force merged PR ${chalk.green(`#${number}`)} via ${chalk.cyan(method)} ${chalk.yellow('(CI skipped)')}`);
+                console.log(chalk.dim(`  SHA: ${data.sha}\n`));
+            } else { spinner.fail(`Could not merge: ${data.message}`); }
+            return;
+        }
+
+        // Step 1: Get PR head SHA
+        const spinner = ora(`Checking CI status for PR #${number}...`).start();
+        const { data: pr } = await octokit.pulls.get({ owner: getOwner(), repo: getRepo(), pull_number: number });
+        const sha = pr.head.sha;
+
+        // Step 2: Poll until all checks complete (max 5 min)
+        let attempts = 0;
+        const maxAttempts = 30;
+        let allComplete = false;
+        let ciChecks: Array<{ name: string; status: string; conclusion: string | null }> = [];
+
+        while (!allComplete && attempts < maxAttempts) {
+            const { data: checkRuns } = await octokit.checks.listForRef({
+                owner: getOwner(), repo: getRepo(), ref: sha, per_page: 100,
+            });
+            const { data: statusData } = await octokit.repos.getCombinedStatusForRef({
+                owner: getOwner(), repo: getRepo(), ref: sha,
+            });
+
+            ciChecks = checkRuns.check_runs.map((c) => ({
+                name: c.name, status: c.status, conclusion: c.conclusion,
+            }));
+            statusData.statuses.forEach((s) => {
+                if (!ciChecks.find((c) => c.name === s.context)) {
+                    ciChecks.push({ name: s.context, status: s.state === 'pending' ? 'in_progress' : 'completed', conclusion: s.state === 'pending' ? null : s.state });
+                }
+            });
+
+            if (ciChecks.length === 0) break;
+
+            allComplete = ciChecks.every((c) => c.status === 'completed');
+            if (!allComplete) {
+                const running = ciChecks.filter((c) => c.status !== 'completed').length;
+                spinner.text = chalk.dim(`Waiting for ${running} check(s)... (${attempts * 10}s)`);
+                await new Promise((r) => setTimeout(r, 10000));
+                attempts++;
+            }
+        }
+        spinner.stop();
+
+        // Step 3: Show CI results
+        if (ciChecks.length > 0) {
+            console.log(`\n${chalk.bold(`🔍 CI Status — PR #${number}`)}\n`);
+
+            const ciTable = new Table({
+                head: ['Check', 'Result'].map((h) => chalk.cyan(h)),
+                style: { head: [], border: [] },
+            });
+
+            let allPassed = true;
+            ciChecks.forEach((c) => {
+                const result = c.conclusion === 'success' ? chalk.green('✅ pass')
+                    : c.conclusion === 'failure' ? chalk.red('❌ fail')
+                        : c.conclusion === 'neutral' || c.conclusion === 'skipped' ? chalk.dim('⏭️  skip')
+                            : c.status !== 'completed' ? chalk.yellow('⏳ running')
+                                : chalk.red('❌ ' + (c.conclusion || 'unknown'));
+
+                if (c.status === 'completed' && c.conclusion !== 'success' && c.conclusion !== 'neutral' && c.conclusion !== 'skipped') {
+                    allPassed = false;
+                }
+                ciTable.push([c.name, result]);
+            });
+
+            console.log(ciTable.toString());
+            console.log('');
+
+            if (!allComplete) {
+                console.log(chalk.yellow(`  ⚠️  Checks still running after 5 min. Try again later.\n`));
+                return;
+            }
+            if (!allPassed) {
+                console.log(chalk.red(`  ❌ CI failed — merge blocked. Fix the checks and retry.\n`));
+                return;
+            }
+            console.log(chalk.green(`  ✅ All checks passed!\n`));
+        } else {
+            console.log(chalk.dim(`\n  ℹ️  No CI checks found — proceeding.\n`));
+        }
+
+        // Step 4: Merge
+        const mergeSpinner = ora(`Merging PR #${number} via ${method}...`).start();
+        const { data } = await octokit.pulls.merge({
+            owner: getOwner(), repo: getRepo(), pull_number: number,
+            merge_method: method,
+            commit_message: opts.message,
+        });
+
+        if (data.merged) {
+            mergeSpinner.succeed(`Merged PR ${chalk.green(`#${number}`)} via ${chalk.cyan(method)}`);
+            console.log(chalk.dim(`  SHA: ${data.sha}\n`));
+        } else {
+            mergeSpinner.fail(`PR #${number} could not be merged: ${data.message}`);
+        }
+    } catch (e: any) { console.error(chalk.red(`  ❌ ${e.message}`)); }
+}
+
+
+export async function closePR(number: number) {
+    requireRepo();
+    const spinner = ora(`Closing PR #${number}...`).start();
+    try {
+        await getOctokit().pulls.update({ owner: getOwner(), repo: getRepo(), pull_number: number, state: 'closed' });
+        spinner.succeed(`Closed PR ${chalk.red(`#${number}`)}`);
+    } catch (e: any) { spinner.fail(e.message); }
+}
+
+export async function reviewPR(number: number) {
+    requireRepo();
+    const octokit = getOctokit();
+    const spinner = ora(`Reviewing PR #${number}...`).start();
+
+    try {
+        const { data: pr } = await octokit.pulls.get({ owner: getOwner(), repo: getRepo(), pull_number: number });
+        const { data: files } = await octokit.pulls.listFiles({ owner: getOwner(), repo: getRepo(), pull_number: number, per_page: 100 });
+        const { data: commits } = await octokit.pulls.listCommits({ owner: getOwner(), repo: getRepo(), pull_number: number, per_page: 100 });
+        spinner.stop();
+
+        console.log(`\n${chalk.bold(`🔍 PR Review — #${number}: ${pr.title}`)}`);
+        console.log(chalk.dim(`  Author: @${pr.user?.login}  Branch: ${pr.head.ref} → ${pr.base.ref}\n`));
+
+        const checks: Array<{ name: string; icon: string; detail: string }> = [];
+
+        // Linked issues
+        const linked = pr.body?.match(/(fix(es|ed)?|clos(e[sd]?)|resolv(e[sd]?))\s+#\d+/gi) || [];
+        checks.push({ name: 'Linked Issues', icon: linked.length > 0 ? '✅' : '⚠️', detail: linked.length > 0 ? linked.join(', ') : 'None found — use "Fixes #N"' });
+
+        // Size
+        const total = files.reduce((s, f) => s + f.additions + f.deletions, 0);
+        checks.push({ name: 'PR Size', icon: total > 1000 ? '❌' : total > 500 ? '⚠️' : '✅', detail: `${total} lines changed (${files.length} files)` });
+
+        // Tests
+        const srcFiles = files.filter((f) => !f.filename.includes('test') && !f.filename.includes('spec') && /\.(ts|rs|js)$/.test(f.filename));
+        const testFiles = files.filter((f) => f.filename.includes('test') || f.filename.includes('spec'));
+        checks.push({ name: 'Tests', icon: srcFiles.length > 0 && testFiles.length === 0 ? '⚠️' : '✅', detail: `${testFiles.length} test file(s), ${srcFiles.length} source file(s)` });
+
+        // Commits
+        const conventionalRegex = /^(feat|fix|docs|style|refactor|test|chore|ci|perf|build|revert)(\(.+\))?!?:\s/;
+        const bad = commits.filter((c) => !conventionalRegex.test(c.commit.message));
+        checks.push({ name: 'Commits', icon: bad.length > 0 ? '⚠️' : '✅', detail: bad.length > 0 ? `${bad.length} non-conventional` : 'All conventional' });
+
+        // Sensitive files
+        const sensitive = files.filter((f) => /(\.env|secret|credential|password|\.key|\.pem)/i.test(f.filename));
+        checks.push({ name: 'Security', icon: sensitive.length > 0 ? '❌' : '✅', detail: sensitive.length > 0 ? `Flagged: ${sensitive.map((f) => f.filename).join(', ')}` : 'Clean' });
+
+        checks.forEach((c) => console.log(`  ${c.icon}  ${chalk.bold(c.name)}: ${c.detail}`));
+        console.log('');
+    } catch (e: any) { spinner.fail(e.message); }
+}
+
+export async function approvePR(number: number) {
+    requireRepo();
+    const spinner = ora(`Approving PR #${number}...`).start();
+    try {
+        await getOctokit().pulls.createReview({
+            owner: getOwner(), repo: getRepo(), pull_number: number,
+            event: 'APPROVE', body: '✅ Approved via GitPadi',
+        });
+        spinner.succeed(`Approved PR ${chalk.green(`#${number}`)}`);
+    } catch (e: any) { spinner.fail(e.message); }
+}
+
+export async function diffPR(number: number) {
+    requireRepo();
+    const spinner = ora(`Fetching diff for PR #${number}...`).start();
+    try {
+        const { data: files } = await getOctokit().pulls.listFiles({
+            owner: getOwner(), repo: getRepo(), pull_number: number, per_page: 100,
+        });
+        spinner.stop();
+
+        console.log(`\n${chalk.bold(`📄 PR #${number} — Changed Files`)} (${files.length})\n`);
+
+        const table = new Table({
+            head: ['File', '+', '-', 'Status'].map((h) => chalk.cyan(h)),
+            style: { head: [], border: [] },
+        });
+
+        files.forEach((f) => {
+            const statusColor = f.status === 'added' ? chalk.green : f.status === 'removed' ? chalk.red : chalk.yellow;
+            table.push([f.filename.substring(0, 60), chalk.green(`+${f.additions}`), chalk.red(`-${f.deletions}`), statusColor(f.status)]);
+        });
+
+        console.log(table.toString());
+        console.log('');
+    } catch (e: any) { spinner.fail(e.message); }
+}

package/src/commands/releases.ts

@@ -0,0 +1,54 @@
+// commands/releases.ts — Release management commands for GitPadi
+
+import chalk from 'chalk';
+import ora from 'ora';
+import Table from 'cli-table3';
+import { getOctokit, getOwner, getRepo, getFullRepo, requireRepo } from '../core/github.js';
+
+export async function createRelease(tag: string, opts: { name?: string; body?: string; draft?: boolean; prerelease?: boolean; generate?: boolean }) {
+    requireRepo();
+    const spinner = ora(`Creating release ${chalk.cyan(tag)}...`).start();
+
+    try {
+        const { data } = await getOctokit().repos.createRelease({
+            owner: getOwner(), repo: getRepo(),
+            tag_name: tag,
+            name: opts.name || tag,
+            body: opts.body || '',
+            draft: opts.draft || false,
+            prerelease: opts.prerelease || false,
+            generate_release_notes: opts.generate !== false,
+        });
+
+        spinner.succeed(`Created release ${chalk.green(data.tag_name)}`);
+        console.log(chalk.dim(`  → ${data.html_url}\n`));
+    } catch (e: any) { spinner.fail(e.message); }
+}
+
+export async function listReleases(opts: { limit?: number }) {
+    requireRepo();
+    const spinner = ora('Fetching releases...').start();
+
+    try {
+        const { data } = await getOctokit().repos.listReleases({
+            owner: getOwner(), repo: getRepo(), per_page: opts.limit || 10,
+        });
+        spinner.stop();
+
+        if (data.length === 0) { console.log(chalk.yellow('\n  No releases found.\n')); return; }
+
+        const table = new Table({
+            head: ['Tag', 'Name', 'Date', 'Type'].map((h) => chalk.cyan(h)),
+            style: { head: [], border: [] },
+        });
+
+        data.forEach((r) => {
+            const type = r.draft ? chalk.yellow('draft') : r.prerelease ? chalk.magenta('pre-release') : chalk.green('release');
+            table.push([r.tag_name, (r.name || '-').substring(0, 40), new Date(r.published_at || r.created_at).toLocaleDateString(), type]);
+        });
+
+        console.log(`\n${chalk.bold(`🚀 Releases — ${getFullRepo()}`)} (${data.length})\n`);
+        console.log(table.toString());
+        console.log('');
+    } catch (e: any) { spinner.fail(e.message); }
+}