gitpadi 2.0.6 → 2.1.1

package/dist/commands/gitlab-mrs.js

@@ -0,0 +1,163 @@
+// 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, mergeGitLabMR, updateGitLabMR, listGitLabMRChanges, getGitLabMRPipelineStatus, withGitLabRetry, } from '../core/gitlab.js';
+export async function listMRs(opts = {}) {
+    requireGitLabProject();
+    const spinner = ora(`Fetching MRs from ${chalk.cyan(getFullProject())}...`).start();
+    try {
+        const state = (['opened', 'closed', 'merged', 'all'].includes(opts.state || '')
+            ? opts.state : 'opened');
+        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) {
+        spinner.fail(e.message);
+    }
+}
+export async function mergeMR(iid, opts = {}) {
+    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) {
+            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 = 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) {
+        spinner.fail(e.message);
+    }
+}
+export async function closeMR(iid) {
+    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) {
+        spinner.fail(e.message);
+    }
+}
+export async function reviewMR(iid) {
+    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 = [];
+        // 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) {
+        spinner.fail(e.message);
+    }
+}
+export async function diffMR(iid) {
+    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) {
+        spinner.fail(e.message);
+    }
+}

package/dist/commands/gitlab-pipelines.js

@@ -0,0 +1,95 @@
+// 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) {
+    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 = {}) {
+    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) {
+        spinner.fail(e.message);
+    }
+}
+export async function viewPipelineJobs(pipelineId) {
+    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) {
+        spinner.fail(e.message);
+    }
+}
+export async function viewJobLog(jobId) {
+    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) {
+        spinner.fail(e.message);
+    }
+}

package/dist/commands/prs.js

@@ -58,9 +58,9 @@ export async function mergePR(number, opts) {
         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)
+        // Step 2: Poll until all checks complete (max 15 min)
         let attempts = 0;
-        const maxAttempts = 30;
+        const maxAttempts = 90;
         let allComplete = false;
         let ciChecks = [];
         while (!allComplete && attempts < maxAttempts) {
@@ -111,7 +111,7 @@ export async function mergePR(number, opts) {
             console.log(ciTable.toString());
             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/dist/core/github.js

@@ -94,6 +94,34 @@ export async function getRepoDetails(owner, repo) {
     const { data } = await getOctokit().repos.get({ owner, repo });
     return data;
 }
+export async function getRepoPermissions(owner, repo) {
+    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(fn, maxRetries = 4) {
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (e) {
+            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, repo, ref) {
     const octokit = getOctokit();
     const { data: checks } = await octokit.checks.listForRef({ owner, repo, ref });

package/dist/core/gitlab.js

@@ -0,0 +1,233 @@
+// core/gitlab.ts — GitLab REST API client for GitPadi
+//
+// Mirrors the interface of github.ts so CLI commands can be
+// written once and routed to either platform.
+import chalk from 'chalk';
+import * as fs from 'fs';
+import * as path from 'path';
+import os from 'node:os';
+import { execFileSync } from 'child_process';
+const CONFIG_DIR = path.join(os.homedir(), '.gitpadi');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+// ── State ──────────────────────────────────────────────────────────────
+let _token = '';
+let _host = 'https://gitlab.com';
+let _namespace = ''; // equivalent of "owner"
+let _project = ''; // equivalent of "repo"
+function loadFullConfig() {
+    if (!fs.existsSync(CONFIG_FILE))
+        return {};
+    try {
+        return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+function saveFullConfig(patch) {
+    const current = loadFullConfig();
+    const updated = { ...current, ...patch };
+    if (!fs.existsSync(CONFIG_DIR))
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(updated, null, 2));
+}
+// ── Local repo detection ───────────────────────────────────────────────
+export function detectLocalGitLabRepo() {
+    try {
+        const remotes = execFileSync('git', ['remote', '-v'], { encoding: 'utf-8', stdio: 'pipe' });
+        // Match both gitlab.com/ns/proj and self-hosted instances
+        const match = remotes.match(/gitlab[^/]*[:/]([^/]+)\/([^/.]+)(?:\.git)?/);
+        if (match)
+            return { namespace: match[1], project: match[2] };
+    }
+    catch { /* not a git repo */ }
+    return null;
+}
+// ── Init ───────────────────────────────────────────────────────────────
+export function initGitLab(token, namespace, project, host) {
+    const config = loadFullConfig();
+    const detected = detectLocalGitLabRepo();
+    _token = token || process.env.GITLAB_TOKEN || process.env.GITPADI_GITLAB_TOKEN || config.gitlabToken || '';
+    _host = host || process.env.GITLAB_HOST || config.gitlabHost || 'https://gitlab.com';
+    _namespace = namespace || process.env.GITLAB_NAMESPACE || config.gitlabNamespace || detected?.namespace || '';
+    _project = project || process.env.GITLAB_PROJECT || config.gitlabProject || detected?.project || '';
+}
+export function getGitLabToken() { return _token; }
+export function getGitLabHost() { return _host; }
+export function getNamespace() { return _namespace; }
+export function getProject() { return _project; }
+export function getFullProject() { return `${_namespace}/${_project}`; }
+export function setGitLabProject(namespace, project) {
+    _namespace = namespace;
+    _project = project;
+    if (_token)
+        saveFullConfig({ gitlabNamespace: namespace, gitlabProject: project });
+}
+export function saveGitLabConfig(token, host, namespace, project) {
+    _token = token;
+    _host = host;
+    _namespace = namespace;
+    _project = project;
+    saveFullConfig({ gitlabToken: token, gitlabHost: host, gitlabNamespace: namespace, gitlabProject: project, platform: 'gitlab' });
+}
+export function savePlatformPreference(platform) {
+    saveFullConfig({ platform });
+}
+export function loadPlatformPreference() {
+    return loadFullConfig().platform;
+}
+export function requireGitLabProject() {
+    if (!_namespace || !_project) {
+        console.error(chalk.red('\n❌ GitLab project not set.'));
+        console.error(chalk.dim('   Set GITLAB_NAMESPACE and GITLAB_PROJECT env vars, or run gitpadi and select a project.\n'));
+        process.exit(1);
+    }
+}
+// ── HTTP helpers ───────────────────────────────────────────────────────
+function apiUrl(path) {
+    const base = _host.replace(/\/$/, '');
+    return `${base}/api/v4${path}`;
+}
+async function glFetch(method, path, body) {
+    const res = await fetch(apiUrl(path), {
+        method,
+        headers: {
+            'PRIVATE-TOKEN': _token,
+            'Content-Type': 'application/json',
+        },
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => '');
+        throw Object.assign(new Error(`GitLab API ${method} ${path} → ${res.status}: ${text}`), { status: res.status });
+    }
+    const text = await res.text();
+    return text ? JSON.parse(text) : {};
+}
+const gl = {
+    get: (path) => glFetch('GET', path),
+    post: (path, body) => glFetch('POST', path, body),
+    put: (path, body) => glFetch('PUT', path, body),
+    delete: (path) => glFetch('DELETE', path),
+};
+// Encode "namespace/project" → "namespace%2Fproject" for URL path segments
+function encodeProject(ns, proj) {
+    return encodeURIComponent(`${ns}/${proj}`);
+}
+// ── Rate-limit retry ───────────────────────────────────────────────────
+export async function withGitLabRetry(fn, maxRetries = 4) {
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (e) {
+            const isRateLimit = e.status === 429 || (e.status === 403 && /rate limit/i.test(e.message || ''));
+            if (isRateLimit && attempt < maxRetries) {
+                const delay = Math.pow(2, attempt) * 1000 + Math.random() * 500;
+                await new Promise(r => setTimeout(r, delay));
+                continue;
+            }
+            throw e;
+        }
+    }
+    throw new Error('withGitLabRetry: max retries exceeded');
+}
+export async function getAuthenticatedGitLabUser() {
+    return gl.get('/user');
+}
+export async function getGitLabProject(namespace, project) {
+    return gl.get(`/projects/${encodeProject(namespace, project)}`);
+}
+export async function forkGitLabProject(namespace, project) {
+    return gl.post(`/projects/${encodeProject(namespace, project)}/fork`, {});
+}
+export async function listGitLabIssues(namespace, project, opts = {}) {
+    const params = new URLSearchParams({
+        state: opts.state || 'opened',
+        per_page: String(opts.per_page || 50),
+    });
+    if (opts.labels)
+        params.set('labels', opts.labels);
+    return gl.get(`/projects/${encodeProject(namespace, project)}/issues?${params}`);
+}
+export async function createGitLabIssue(namespace, project, data) {
+    return gl.post(`/projects/${encodeProject(namespace, project)}/issues`, data);
+}
+export async function updateGitLabIssue(namespace, project, iid, data) {
+    return gl.put(`/projects/${encodeProject(namespace, project)}/issues/${iid}`, data);
+}
+export async function createGitLabIssueNote(namespace, project, iid, body) {
+    await gl.post(`/projects/${encodeProject(namespace, project)}/issues/${iid}/notes`, { body });
+}
+export async function listGitLabMRs(namespace, project, opts = {}) {
+    const params = new URLSearchParams({
+        state: opts.state || 'opened',
+        per_page: String(opts.per_page || 50),
+    });
+    return gl.get(`/projects/${encodeProject(namespace, project)}/merge_requests?${params}`);
+}
+export async function getGitLabMR(namespace, project, iid) {
+    return gl.get(`/projects/${encodeProject(namespace, project)}/merge_requests/${iid}`);
+}
+export async function createGitLabMR(namespace, project, data) {
+    return gl.post(`/projects/${encodeProject(namespace, project)}/merge_requests`, {
+        remove_source_branch: true,
+        ...data,
+    });
+}
+export async function mergeGitLabMR(namespace, project, iid, opts = {}) {
+    return gl.put(`/projects/${encodeProject(namespace, project)}/merge_requests/${iid}/merge`, {
+        squash: opts.squash ?? true,
+        squash_commit_message: opts.message,
+    });
+}
+export async function updateGitLabMR(namespace, project, iid, data) {
+    return gl.put(`/projects/${encodeProject(namespace, project)}/merge_requests/${iid}`, data);
+}
+export async function listGitLabMRNotes(namespace, project, iid) {
+    return gl.get(`/projects/${encodeProject(namespace, project)}/merge_requests/${iid}/notes?per_page=100`);
+}
+export async function createGitLabMRNote(namespace, project, iid, body) {
+    await gl.post(`/projects/${encodeProject(namespace, project)}/merge_requests/${iid}/notes`, { body });
+}
+export async function updateGitLabMRNote(namespace, project, iid, noteId, body) {
+    await gl.put(`/projects/${encodeProject(namespace, project)}/merge_requests/${iid}/notes/${noteId}`, { body });
+}
+export async function listGitLabMRChanges(namespace, project, iid) {
+    const data = await gl.get(`/projects/${encodeProject(namespace, project)}/merge_requests/${iid}/changes`);
+    return data.changes || [];
+}
+export async function listGitLabPipelines(namespace, project, opts = {}) {
+    const params = new URLSearchParams({ per_page: String(opts.per_page || 20) });
+    if (opts.ref)
+        params.set('ref', opts.ref);
+    if (opts.status)
+        params.set('status', opts.status);
+    return gl.get(`/projects/${encodeProject(namespace, project)}/pipelines?${params}`);
+}
+export async function getGitLabPipeline(namespace, project, pipelineId) {
+    return gl.get(`/projects/${encodeProject(namespace, project)}/pipelines/${pipelineId}`);
+}
+export async function listGitLabPipelineJobs(namespace, project, pipelineId) {
+    return gl.get(`/projects/${encodeProject(namespace, project)}/pipelines/${pipelineId}/jobs?per_page=100`);
+}
+export async function getGitLabJobLog(namespace, project, jobId) {
+    const res = await fetch(apiUrl(`/projects/${encodeProject(namespace, project)}/jobs/${jobId}/trace`), {
+        headers: { 'PRIVATE-TOKEN': _token },
+    });
+    if (!res.ok)
+        throw new Error(`Could not fetch job log: ${res.status}`);
+    return res.text();
+}
+// ── MR CI status (for polling) ─────────────────────────────────────────
+export async function getGitLabMRPipelineStatus(namespace, project, mrIid) {
+    try {
+        const pipelines = await gl.get(`/projects/${encodeProject(namespace, project)}/merge_requests/${mrIid}/pipelines?per_page=1`);
+        if (!pipelines.length)
+            return null;
+        return { status: pipelines[0].status, web_url: pipelines[0].web_url };
+    }
+    catch {
+        return null;
+    }
+}