gitpadi 2.0.6 → 2.1.1

package/src/commands/gitlab-mrs.ts

@@ -0,0 +1,185 @@
+// commands/gitlab-mrs.ts — GitLab Merge Request management for GitPadi
+
+import chalk from 'chalk';
+import ora from 'ora';
+import Table from 'cli-table3';
+import {
+    getNamespace, getProject, getFullProject, requireGitLabProject,
+    listGitLabMRs, getGitLabMR, createGitLabMR, mergeGitLabMR, updateGitLabMR,
+    listGitLabMRChanges, listGitLabMRNotes, createGitLabMRNote, updateGitLabMRNote,
+    getGitLabMRPipelineStatus, withGitLabRetry,
+} from '../core/gitlab.js';
+
+export async function listMRs(opts: { state?: string; limit?: number } = {}) {
+    requireGitLabProject();
+    const spinner = ora(`Fetching MRs from ${chalk.cyan(getFullProject())}...`).start();
+    try {
+        const state = (['opened', 'closed', 'merged', 'all'].includes(opts.state || '')
+            ? opts.state : 'opened') as 'opened' | 'closed' | 'merged' | 'all';
+
+        const mrs = await withGitLabRetry(() =>
+            listGitLabMRs(getNamespace(), getProject(), { state, per_page: opts.limit || 50 })
+        );
+        spinner.stop();
+
+        if (!mrs.length) { console.log(chalk.yellow('\n  No merge requests found.\n')); return; }
+
+        const table = new Table({
+            head: ['#', 'Title', 'Author', 'Branch', 'State'].map(h => chalk.cyan(h)),
+            style: { head: [], border: [] },
+        });
+
+        mrs.forEach(mr => {
+            const stateLabel = mr.state === 'opened' ? chalk.green('open')
+                : mr.state === 'merged' ? chalk.magenta('merged') : chalk.red(mr.state);
+            table.push([
+                `!${mr.iid}`,
+                mr.title.substring(0, 50),
+                `@${mr.author.username}`,
+                mr.source_branch.substring(0, 25),
+                stateLabel,
+            ]);
+        });
+
+        console.log(`\n${chalk.bold(`🔀 Merge Requests — ${getFullProject()}`)} (${mrs.length})\n`);
+        console.log(table.toString());
+        console.log('');
+    } catch (e: any) { spinner.fail(e.message); }
+}
+
+export async function mergeMR(iid: number, opts: { squash?: boolean; message?: string; force?: boolean } = {}) {
+    requireGitLabProject();
+
+    if (opts.force) {
+        const spinner = ora(`Force merging MR !${iid}...`).start();
+        try {
+            const result = await withGitLabRetry(() =>
+                mergeGitLabMR(getNamespace(), getProject(), iid, { squash: opts.squash ?? true, message: opts.message })
+            );
+            spinner.succeed(`Force merged MR ${chalk.green(`!${iid}`)} ${chalk.yellow('(CI skipped)')}`);
+            console.log(chalk.dim(`  SHA: ${result.sha}\n`));
+        } catch (e: any) { spinner.fail(e.message); }
+        return;
+    }
+
+    const spinner = ora(`Checking CI status for MR !${iid}...`).start();
+    try {
+        // Poll up to 15 min (90 × 10s)
+        let attempts = 0;
+        const maxAttempts = 90;
+        let ciStatus: string | null = null;
+
+        while (attempts < maxAttempts) {
+            const pipeline = await withGitLabRetry(() => getGitLabMRPipelineStatus(getNamespace(), getProject(), iid));
+
+            if (!pipeline) {
+                spinner.info(chalk.dim('No CI pipeline found — proceeding without check.'));
+                break;
+            }
+
+            ciStatus = pipeline.status;
+
+            if (['success', 'failed', 'canceled', 'skipped'].includes(ciStatus)) break;
+
+            spinner.text = chalk.dim(`Pipeline ${ciStatus}... (${attempts * 10}s elapsed)`);
+            await new Promise(r => setTimeout(r, 10000));
+            attempts++;
+        }
+
+        spinner.stop();
+
+        if (ciStatus === 'failed' || ciStatus === 'canceled') {
+            console.log(chalk.red(`  ❌ Pipeline ${ciStatus} — merge blocked. Fix the pipeline and retry.\n`));
+            return;
+        }
+        if (attempts >= maxAttempts) {
+            console.log(chalk.yellow(`  ⚠️  Pipeline still running after 15 min. Try again later.\n`));
+            return;
+        }
+        if (ciStatus === 'success') {
+            console.log(chalk.green(`  ✅ Pipeline passed!\n`));
+        }
+
+        const mergeSpinner = ora(`Merging MR !${iid}...`).start();
+        const result = await withGitLabRetry(() =>
+            mergeGitLabMR(getNamespace(), getProject(), iid, { squash: opts.squash ?? true, message: opts.message })
+        );
+        mergeSpinner.succeed(`Merged MR ${chalk.green(`!${iid}`)}`);
+        console.log(chalk.dim(`  SHA: ${result.sha}\n`));
+    } catch (e: any) { spinner.fail(e.message); }
+}
+
+export async function closeMR(iid: number) {
+    requireGitLabProject();
+    const spinner = ora(`Closing MR !${iid}...`).start();
+    try {
+        await withGitLabRetry(() => updateGitLabMR(getNamespace(), getProject(), iid, { state_event: 'close' }));
+        spinner.succeed(`Closed MR ${chalk.red(`!${iid}`)}`);
+    } catch (e: any) { spinner.fail(e.message); }
+}
+
+export async function reviewMR(iid: number) {
+    requireGitLabProject();
+    const spinner = ora(`Reviewing MR !${iid}...`).start();
+    try {
+        const mr = await withGitLabRetry(() => getGitLabMR(getNamespace(), getProject(), iid));
+        const changes = await withGitLabRetry(() => listGitLabMRChanges(getNamespace(), getProject(), iid));
+        spinner.stop();
+
+        console.log(`\n${chalk.bold(`🔍 MR Review — !${iid}: ${mr.title}`)}`);
+        console.log(chalk.dim(`  Author: @${mr.author.username}  Branch: ${mr.source_branch} → ${mr.target_branch}\n`));
+
+        const checks: Array<{ name: string; icon: string; detail: string }> = [];
+
+        // Linked issues
+        const linked = mr.description?.match(/(fix(es|ed)?|clos(e[sd]?)|resolv(e[sd]?))\s+#\d+/gi) || [];
+        checks.push({ name: 'Linked Issues', icon: linked.length ? '✅' : '⚠️', detail: linked.length ? linked.join(', ') : 'None found — use "Fixes #N"' });
+
+        // Size
+        const totalLines = changes.reduce((sum, f) => {
+            const adds = (f.diff.match(/^\+/gm) || []).length;
+            const dels = (f.diff.match(/^-/gm) || []).length;
+            return sum + adds + dels;
+        }, 0);
+        checks.push({ name: 'MR Size', icon: totalLines > 1000 ? '❌' : totalLines > 500 ? '⚠️' : '✅', detail: `~${totalLines} lines changed (${changes.length} files)` });
+
+        // Tests
+        const srcFiles = changes.filter(f => !f.new_path.includes('test') && !f.new_path.includes('spec') && /\.(ts|rs|js|py)$/.test(f.new_path));
+        const testFiles = changes.filter(f => f.new_path.includes('test') || f.new_path.includes('spec'));
+        checks.push({ name: 'Tests', icon: srcFiles.length > 0 && testFiles.length === 0 ? '⚠️' : '✅', detail: `${testFiles.length} test file(s), ${srcFiles.length} source file(s)` });
+
+        // Sensitive files
+        const sensitive = changes.filter(f => /(\.env|secret|credential|password|\.key|\.pem)/i.test(f.new_path));
+        checks.push({ name: 'Security', icon: sensitive.length ? '❌' : '✅', detail: sensitive.length ? `Flagged: ${sensitive.map(f => f.new_path).join(', ')}` : 'Clean' });
+
+        // Draft
+        checks.push({ name: 'Draft Status', icon: mr.draft ? '⚠️' : '✅', detail: mr.draft ? 'MR is a draft — not ready to merge' : 'Ready for review' });
+
+        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 diffMR(iid: number) {
+    requireGitLabProject();
+    const spinner = ora(`Fetching diff for MR !${iid}...`).start();
+    try {
+        const changes = await withGitLabRetry(() => listGitLabMRChanges(getNamespace(), getProject(), iid));
+        spinner.stop();
+
+        console.log(`\n${chalk.bold(`📄 MR !${iid} — Changed Files`)} (${changes.length})\n`);
+
+        const table = new Table({
+            head: ['File', 'Status'].map(h => chalk.cyan(h)),
+            style: { head: [], border: [] },
+        });
+
+        changes.forEach(f => {
+            const status = f.new_file ? chalk.green('added') : f.deleted_file ? chalk.red('removed') : chalk.yellow('modified');
+            table.push([f.new_path.substring(0, 70), status]);
+        });
+
+        console.log(table.toString());
+        console.log('');
+    } catch (e: any) { spinner.fail(e.message); }
+}

package/src/commands/gitlab-pipelines.ts

@@ -0,0 +1,104 @@
+// commands/gitlab-pipelines.ts — GitLab CI/CD pipeline management for GitPadi
+
+import chalk from 'chalk';
+import ora from 'ora';
+import Table from 'cli-table3';
+import {
+    getNamespace, getProject, getFullProject, requireGitLabProject,
+    listGitLabPipelines, getGitLabPipeline, listGitLabPipelineJobs, getGitLabJobLog,
+    withGitLabRetry,
+} from '../core/gitlab.js';
+
+function pipelineStatusColor(status: string): string {
+    switch (status) {
+        case 'success': return chalk.green(status);
+        case 'failed': return chalk.red(status);
+        case 'running': return chalk.yellow(status);
+        case 'canceled': return chalk.dim(status);
+        case 'pending': return chalk.blue(status);
+        default: return chalk.dim(status);
+    }
+}
+
+export async function listPipelines(opts: { ref?: string; limit?: number } = {}) {
+    requireGitLabProject();
+    const spinner = ora(`Fetching pipelines from ${chalk.cyan(getFullProject())}...`).start();
+    try {
+        const pipelines = await withGitLabRetry(() =>
+            listGitLabPipelines(getNamespace(), getProject(), { per_page: opts.limit || 20, ref: opts.ref })
+        );
+        spinner.stop();
+
+        if (!pipelines.length) { console.log(chalk.yellow('\n  No pipelines found.\n')); return; }
+
+        const table = new Table({
+            head: ['ID', 'Status', 'Ref', 'SHA', 'Created'].map(h => chalk.cyan(h)),
+            style: { head: [], border: [] },
+        });
+
+        pipelines.forEach(p => {
+            table.push([
+                `#${p.id}`,
+                pipelineStatusColor(p.status),
+                p.ref.substring(0, 25),
+                p.sha.substring(0, 8),
+                new Date(p.created_at).toLocaleDateString(),
+            ]);
+        });
+
+        console.log(`\n${chalk.bold(`🔧 Pipelines — ${getFullProject()}`)} (${pipelines.length})\n`);
+        console.log(table.toString());
+        console.log('');
+    } catch (e: any) { spinner.fail(e.message); }
+}
+
+export async function viewPipelineJobs(pipelineId: number) {
+    requireGitLabProject();
+    const spinner = ora(`Fetching jobs for pipeline #${pipelineId}...`).start();
+    try {
+        const [pipeline, jobs] = await Promise.all([
+            withGitLabRetry(() => getGitLabPipeline(getNamespace(), getProject(), pipelineId)),
+            withGitLabRetry(() => listGitLabPipelineJobs(getNamespace(), getProject(), pipelineId)),
+        ]);
+        spinner.stop();
+
+        console.log(`\n${chalk.bold(`🔧 Pipeline #${pipelineId}`)} — ${pipelineStatusColor(pipeline.status)} — ${pipeline.ref}\n`);
+
+        const table = new Table({
+            head: ['Job', 'Stage', 'Status', 'Duration'].map(h => chalk.cyan(h)),
+            style: { head: [], border: [] },
+        });
+
+        jobs.forEach(job => {
+            const duration = job.duration ? `${Math.round(job.duration)}s` : '-';
+            table.push([job.name, job.stage, pipelineStatusColor(job.status), duration]);
+        });
+
+        console.log(table.toString());
+        console.log('');
+
+        const failed = jobs.filter(j => j.status === 'failed');
+        if (failed.length) {
+            console.log(chalk.red(`  ❌ ${failed.length} failed job(s): ${failed.map(j => j.name).join(', ')}\n`));
+        }
+    } catch (e: any) { spinner.fail(e.message); }
+}
+
+export async function viewJobLog(jobId: number) {
+    requireGitLabProject();
+    const spinner = ora(`Fetching log for job #${jobId}...`).start();
+    try {
+        const log = await withGitLabRetry(() => getGitLabJobLog(getNamespace(), getProject(), jobId));
+        spinner.stop();
+
+        console.log(`\n${chalk.bold(`📋 Job #${jobId} Log`)}\n`);
+        // Show last 100 lines to avoid overwhelming the terminal
+        const lines = log.split('\n');
+        const tail = lines.slice(-100).join('\n');
+        if (lines.length > 100) {
+            console.log(chalk.dim(`  ... (showing last 100 of ${lines.length} lines)\n`));
+        }
+        console.log(chalk.dim(tail));
+        console.log('');
+    } catch (e: any) { spinner.fail(e.message); }
+}

package/src/commands/prs.ts

@@ -60,9 +60,9 @@ export async function mergePR(number: number, opts: { method?: string; message?:
         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)
+        // Step 2: Poll until all checks complete (max 15 min)
         let attempts = 0;
-        const maxAttempts = 30;
+        const maxAttempts = 90;
         let allComplete = false;
         let ciChecks: Array<{ name: string; status: string; conclusion: string | null }> = [];
 
@@ -122,7 +122,7 @@ export async function mergePR(number: number, opts: { method?: string; message?:
             console.log('');
 
             if (!allComplete) {
-                console.log(chalk.yellow(`  ⚠️  Checks still running after 5 min. Try again later.\n`));
+                console.log(chalk.yellow(`  ⚠️  Checks still running after 15 min. Try again later.\n`));
                 return;
             }
             if (!allPassed) {

package/src/core/github.ts

@@ -114,6 +114,35 @@ export async function getRepoDetails(owner: string, repo: string) {
     return data;
 }
 
+export async function getRepoPermissions(owner: string, repo: string) {
+    const data = await getRepoDetails(owner, repo);
+    return data.permissions || { admin: false, push: false, pull: true };
+}
+
+/**
+ * Retries an async operation on GitHub rate-limit (429) or secondary rate-limit (403)
+ * with exponential backoff. maxRetries defaults to 4 (covers ~30s total wait).
+ */
+export async function withRetry<T>(fn: () => Promise<T>, maxRetries = 4): Promise<T> {
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await fn();
+        } catch (e: any) {
+            const isRateLimit = e.status === 429 || (e.status === 403 && /rate limit/i.test(e.message || ''));
+            if (isRateLimit && attempt < maxRetries) {
+                // Honour Retry-After header when present, else exponential backoff
+                const retryAfter = parseInt(e.response?.headers?.['retry-after'] || '0', 10);
+                const delay = retryAfter > 0 ? retryAfter * 1000 : Math.pow(2, attempt) * 1000 + Math.random() * 500;
+                await new Promise(r => setTimeout(r, delay));
+                continue;
+            }
+            throw e;
+        }
+    }
+    // Unreachable — satisfies TS return type
+    throw new Error('withRetry: max retries exceeded');
+}
+
 export async function getLatestCheckRuns(owner: string, repo: string, ref: string) {
     const octokit = getOctokit();
     const { data: checks } = await octokit.checks.listForRef({ owner, repo, ref });