gitpadi 2.0.0 → 2.0.2

package/dist/commands/issues.js

@@ -0,0 +1,319 @@
+// 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 } from '../core/scorer.js';
+import * as fs from 'fs';
+import * as path from 'path';
+export async function listIssues(opts) {
+    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 || 'open',
+            labels: opts.labels || undefined,
+            per_page: opts.limit || 50,
+        });
+        // 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) {
+        spinner.fail(`Failed: ${e.message}`);
+    }
+}
+export async function createIssue(opts) {
+    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) {
+        spinner.fail(`Failed: ${e.message}`);
+    }
+}
+/**
+ * Parse a markdown file into issues.
+ * Format:
+ *   ## Issue Title
+ *   **Labels:** bug, frontend
+ *   Body text here...
+ */
+function parseMarkdownIssues(content) {
+    const issues = [];
+    const sections = content.split(/^## /m).filter(s => s.trim());
+    let num = 1;
+    for (const section of sections) {
+        const lines = section.split('\n');
+        const title = lines[0].trim();
+        if (!title)
+            continue;
+        let labels = [];
+        const bodyLines = [];
+        for (let i = 1; i < lines.length; i++) {
+            const labelsMatch = lines[i].match(/^\*\*Labels?:\*\*\s*(.+)/i);
+            if (labelsMatch) {
+                labels = labelsMatch[1].split(',').map(l => l.trim()).filter(Boolean);
+            }
+            else {
+                bodyLines.push(lines[i]);
+            }
+        }
+        issues.push({
+            number: num++,
+            title,
+            body: bodyLines.join('\n').trim(),
+            labels,
+        });
+    }
+    return { issues, labels: {} };
+}
+export async function createIssuesFromFile(filePath, opts) {
+    requireRepo();
+    const resolved = path.resolve(filePath);
+    if (!fs.existsSync(resolved)) {
+        console.error(chalk.red(`\n❌ File not found: ${resolved}\n`));
+        return;
+    }
+    const raw = fs.readFileSync(resolved, 'utf-8');
+    const ext = path.extname(resolved).toLowerCase();
+    let config;
+    let detectedFormat = 'JSON';
+    if (ext === '.md' || ext === '.markdown') {
+        config = parseMarkdownIssues(raw);
+        detectedFormat = 'Markdown';
+    }
+    else {
+        // Try JSON first, fallback to Markdown if it fails
+        try {
+            const parsed = JSON.parse(raw);
+            config = { issues: parsed.issues || [], labels: parsed.labels };
+        }
+        catch {
+            // Not valid JSON — try markdown parser
+            if (raw.trimStart().startsWith('#')) {
+                console.log(chalk.yellow(`\n  ⚠ File has .json extension but contains Markdown — parsing as Markdown.\n`));
+                config = parseMarkdownIssues(raw);
+                detectedFormat = 'Markdown (auto-detected)';
+            }
+            else {
+                console.error(chalk.red(`\n  ❌ Fatal: File is not valid JSON or Markdown.\n`));
+                return;
+            }
+        }
+    }
+    const issues = config.issues;
+    const start = opts.start || 1;
+    const end = opts.end || 999;
+    const filtered = issues.filter((i) => 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} (${detectedFormat})`));
+    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) => {
+            console.log(`  ${chalk.dim(`#${String(i.number).padStart(2, '0')}`)}  ${i.title}`);
+            console.log(chalk.dim(`       [${(i.labels || []).join(', ')}]`));
+            if (i.body)
+                console.log(chalk.dim(`       ${i.body.substring(0, 80)}...`));
+        });
+        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 && Object.keys(config.labels).length > 0) {
+        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 });
+                }
+                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) {
+            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) {
+    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) {
+        spinner.fail(e.message);
+    }
+}
+export async function reopenIssue(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) {
+        spinner.fail(e.message);
+    }
+}
+export async function deleteIssue(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) {
+        spinner.fail(e.message);
+    }
+}
+export async function assignIssue(number, assignees) {
+    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) {
+        spinner.fail(e.message);
+    }
+}
+export async function assignBest(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();
+        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 = [];
+        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) {
+        spinner.fail(e.message);
+    }
+}
+export async function searchIssues(query) {
+    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) {
+        spinner.fail(e.message);
+    }
+}
+export async function labelIssue(number, labels) {
+    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) {
+        spinner.fail(e.message);
+    }
+}

package/dist/commands/prs.js

@@ -0,0 +1,229 @@
+// 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) {
+    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 || 'open',
+            per_page: opts.limit || 50,
+        });
+        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) {
+        spinner.fail(e.message);
+    }
+}
+export async function mergePR(number, opts) {
+    requireRepo();
+    const octokit = getOctokit();
+    const method = (opts.method || 'squash');
+    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 = [];
+        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) {
+        console.error(chalk.red(`  ❌ ${e.message}`));
+    }
+}
+export async function closePR(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) {
+        spinner.fail(e.message);
+    }
+}
+export async function reviewPR(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 = [];
+        // 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) {
+        spinner.fail(e.message);
+    }
+}
+export async function approvePR(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) {
+        spinner.fail(e.message);
+    }
+}
+export async function diffPR(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) {
+        spinner.fail(e.message);
+    }
+}

package/dist/commands/releases.js

@@ -0,0 +1,53 @@
+// 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, opts) {
+    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) {
+        spinner.fail(e.message);
+    }
+}
+export async function listReleases(opts) {
+    requireRepo();
+    const spinner = ora('Fetching releases...').start();
+    try {
+        const { data } = await getOctokit().repos.listReleases({
+            owner: getOwner(), repo: getRepo(), per_page: opts.limit || 50,
+        });
+        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) {
+        spinner.fail(e.message);
+    }
+}