gitpadi 2.0.7 → 2.1.2

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

@@ -119,6 +119,30 @@ export async function getRepoPermissions(owner: string, repo: string) {
     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 });

package/src/core/gitlab.ts

@@ -0,0 +1,397 @@
+// 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: string = '';
+let _host: string = 'https://gitlab.com';
+let _namespace: string = '';   // equivalent of "owner"
+let _project: string = '';     // equivalent of "repo"
+
+// ── Config (shared file with github.ts) ───────────────────────────────
+interface GitPadiFullConfig {
+    token?: string;
+    owner?: string;
+    repo?: string;
+    gitlabToken?: string;
+    gitlabHost?: string;
+    gitlabNamespace?: string;
+    gitlabProject?: string;
+    platform?: 'github' | 'gitlab';
+}
+
+function loadFullConfig(): GitPadiFullConfig {
+    if (!fs.existsSync(CONFIG_FILE)) return {};
+    try { return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8')); } catch { return {}; }
+}
+
+function saveFullConfig(patch: Partial<GitPadiFullConfig>): void {
+    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(): { namespace: string; project: string } | null {
+    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?: string, namespace?: string, project?: string, host?: string): void {
+    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(): string { return _token; }
+export function getGitLabHost(): string { return _host; }
+export function getNamespace(): string { return _namespace; }
+export function getProject(): string { return _project; }
+export function getFullProject(): string { return `${_namespace}/${_project}`; }
+
+export function setGitLabProject(namespace: string, project: string): void {
+    _namespace = namespace;
+    _project = project;
+    if (_token) saveFullConfig({ gitlabNamespace: namespace, gitlabProject: project });
+}
+
+export function saveGitLabConfig(token: string, host: string, namespace: string, project: string): void {
+    _token = token;
+    _host = host;
+    _namespace = namespace;
+    _project = project;
+    saveFullConfig({ gitlabToken: token, gitlabHost: host, gitlabNamespace: namespace, gitlabProject: project, platform: 'gitlab' });
+}
+
+export function savePlatformPreference(platform: 'github' | 'gitlab'): void {
+    saveFullConfig({ platform });
+}
+
+export function loadPlatformPreference(): 'github' | 'gitlab' | undefined {
+    return loadFullConfig().platform;
+}
+
+export function requireGitLabProject(): void {
+    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: string): string {
+    const base = _host.replace(/\/$/, '');
+    return `${base}/api/v4${path}`;
+}
+
+async function glFetch<T>(method: string, path: string, body?: unknown): Promise<T> {
+    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) as T : ({} as T);
+}
+
+const gl = {
+    get: <T>(path: string) => glFetch<T>('GET', path),
+    post: <T>(path: string, body: unknown) => glFetch<T>('POST', path, body),
+    put: <T>(path: string, body: unknown) => glFetch<T>('PUT', path, body),
+    delete: <T>(path: string) => glFetch<T>('DELETE', path),
+};
+
+// Encode "namespace/project" → "namespace%2Fproject" for URL path segments
+function encodeProject(ns: string, proj: string): string {
+    return encodeURIComponent(`${ns}/${proj}`);
+}
+
+// ── Rate-limit retry ───────────────────────────────────────────────────
+export async function withGitLabRetry<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) {
+                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');
+}
+
+// ── User ───────────────────────────────────────────────────────────────
+export interface GitLabUser {
+    id: number;
+    username: string;
+    name: string;
+    avatar_url: string;
+    web_url: string;
+    created_at: string;
+    public_repos?: number;
+}
+
+export async function getAuthenticatedGitLabUser(): Promise<GitLabUser> {
+    return gl.get<GitLabUser>('/user');
+}
+
+// ── Project ────────────────────────────────────────────────────────────
+export interface GitLabProject {
+    id: number;
+    name: string;
+    path_with_namespace: string;
+    description: string | null;
+    web_url: string;
+    default_branch: string;
+    visibility: string;
+    star_count: number;
+    forks_count: number;
+    open_issues_count: number;
+    permissions?: { project_access?: { access_level: number } };
+}
+
+export async function getGitLabProject(namespace: string, project: string): Promise<GitLabProject> {
+    return gl.get<GitLabProject>(`/projects/${encodeProject(namespace, project)}`);
+}
+
+export async function forkGitLabProject(namespace: string, project: string): Promise<GitLabProject> {
+    return gl.post<GitLabProject>(`/projects/${encodeProject(namespace, project)}/fork`, {});
+}
+
+// ── Issues ─────────────────────────────────────────────────────────────
+export interface GitLabIssue {
+    id: number;
+    iid: number;            // project-scoped issue number (equivalent to GitHub issue number)
+    title: string;
+    description: string | null;
+    state: 'opened' | 'closed';
+    author: { username: string };
+    assignees: Array<{ username: string }>;
+    labels: string[];
+    created_at: string;
+    updated_at: string;
+    web_url: string;
+}
+
+export async function listGitLabIssues(namespace: string, project: string, opts: {
+    state?: 'opened' | 'closed' | 'all';
+    per_page?: number;
+    labels?: string;
+} = {}): Promise<GitLabIssue[]> {
+    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<GitLabIssue[]>(`/projects/${encodeProject(namespace, project)}/issues?${params}`);
+}
+
+export async function createGitLabIssue(namespace: string, project: string, data: {
+    title: string;
+    description?: string;
+    labels?: string;
+    assignee_ids?: number[];
+}): Promise<GitLabIssue> {
+    return gl.post<GitLabIssue>(`/projects/${encodeProject(namespace, project)}/issues`, data);
+}
+
+export async function updateGitLabIssue(namespace: string, project: string, iid: number, data: {
+    state_event?: 'close' | 'reopen';
+    title?: string;
+    description?: string;
+}): Promise<GitLabIssue> {
+    return gl.put<GitLabIssue>(`/projects/${encodeProject(namespace, project)}/issues/${iid}`, data);
+}
+
+export async function createGitLabIssueNote(namespace: string, project: string, iid: number, body: string): Promise<void> {
+    await gl.post(`/projects/${encodeProject(namespace, project)}/issues/${iid}/notes`, { body });
+}
+
+// ── Merge Requests ─────────────────────────────────────────────────────
+export interface GitLabMR {
+    id: number;
+    iid: number;
+    title: string;
+    description: string | null;
+    state: 'opened' | 'closed' | 'locked' | 'merged';
+    author: { username: string };
+    source_branch: string;
+    target_branch: string;
+    web_url: string;
+    sha: string;
+    draft: boolean;
+    has_conflicts: boolean;
+    created_at: string;
+    updated_at: string;
+    merge_status: string;
+}
+
+export async function listGitLabMRs(namespace: string, project: string, opts: {
+    state?: 'opened' | 'closed' | 'locked' | 'merged' | 'all';
+    per_page?: number;
+} = {}): Promise<GitLabMR[]> {
+    const params = new URLSearchParams({
+        state: opts.state || 'opened',
+        per_page: String(opts.per_page || 50),
+    });
+    return gl.get<GitLabMR[]>(`/projects/${encodeProject(namespace, project)}/merge_requests?${params}`);
+}
+
+export async function getGitLabMR(namespace: string, project: string, iid: number): Promise<GitLabMR> {
+    return gl.get<GitLabMR>(`/projects/${encodeProject(namespace, project)}/merge_requests/${iid}`);
+}
+
+export async function createGitLabMR(namespace: string, project: string, data: {
+    title: string;
+    description?: string;
+    source_branch: string;
+    target_branch: string;
+    remove_source_branch?: boolean;
+    squash?: boolean;
+}): Promise<GitLabMR> {
+    return gl.post<GitLabMR>(`/projects/${encodeProject(namespace, project)}/merge_requests`, {
+        remove_source_branch: true,
+        ...data,
+    });
+}
+
+export async function mergeGitLabMR(namespace: string, project: string, iid: number, opts: {
+    squash?: boolean;
+    message?: string;
+} = {}): Promise<GitLabMR> {
+    return gl.put<GitLabMR>(`/projects/${encodeProject(namespace, project)}/merge_requests/${iid}/merge`, {
+        squash: opts.squash ?? true,
+        squash_commit_message: opts.message,
+    });
+}
+
+export async function updateGitLabMR(namespace: string, project: string, iid: number, data: {
+    state_event?: 'close' | 'reopen';
+    title?: string;
+}): Promise<GitLabMR> {
+    return gl.put<GitLabMR>(`/projects/${encodeProject(namespace, project)}/merge_requests/${iid}`, data);
+}
+
+export async function listGitLabMRNotes(namespace: string, project: string, iid: number): Promise<Array<{
+    id: number; body: string; author: { username: string }; created_at: string;
+}>> {
+    return gl.get(`/projects/${encodeProject(namespace, project)}/merge_requests/${iid}/notes?per_page=100`);
+}
+
+export async function createGitLabMRNote(namespace: string, project: string, iid: number, body: string): Promise<void> {
+    await gl.post(`/projects/${encodeProject(namespace, project)}/merge_requests/${iid}/notes`, { body });
+}
+
+export async function updateGitLabMRNote(namespace: string, project: string, iid: number, noteId: number, body: string): Promise<void> {
+    await gl.put(`/projects/${encodeProject(namespace, project)}/merge_requests/${iid}/notes/${noteId}`, { body });
+}
+
+export async function listGitLabMRChanges(namespace: string, project: string, iid: number): Promise<Array<{
+    old_path: string; new_path: string; new_file: boolean; deleted_file: boolean; diff: string;
+}>> {
+    const data = await gl.get<{ changes: any[] }>(`/projects/${encodeProject(namespace, project)}/merge_requests/${iid}/changes`);
+    return data.changes || [];
+}
+
+// ── Pipelines ──────────────────────────────────────────────────────────
+export interface GitLabPipeline {
+    id: number;
+    iid: number;
+    status: 'created' | 'waiting_for_resource' | 'preparing' | 'pending' | 'running' | 'success' | 'failed' | 'canceled' | 'skipped' | 'manual' | 'scheduled';
+    source: string;
+    ref: string;
+    sha: string;
+    web_url: string;
+    created_at: string;
+    updated_at: string;
+}
+
+export interface GitLabJob {
+    id: number;
+    name: string;
+    stage: string;
+    status: string;
+    web_url: string;
+    created_at: string;
+    started_at: string | null;
+    finished_at: string | null;
+    duration: number | null;
+}
+
+export async function listGitLabPipelines(namespace: string, project: string, opts: {
+    per_page?: number;
+    ref?: string;
+    status?: string;
+} = {}): Promise<GitLabPipeline[]> {
+    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<GitLabPipeline[]>(`/projects/${encodeProject(namespace, project)}/pipelines?${params}`);
+}
+
+export async function getGitLabPipeline(namespace: string, project: string, pipelineId: number): Promise<GitLabPipeline> {
+    return gl.get<GitLabPipeline>(`/projects/${encodeProject(namespace, project)}/pipelines/${pipelineId}`);
+}
+
+export async function listGitLabPipelineJobs(namespace: string, project: string, pipelineId: number): Promise<GitLabJob[]> {
+    return gl.get<GitLabJob[]>(`/projects/${encodeProject(namespace, project)}/pipelines/${pipelineId}/jobs?per_page=100`);
+}
+
+export async function getGitLabJobLog(namespace: string, project: string, jobId: number): Promise<string> {
+    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: string, project: string, mrIid: number): Promise<{
+    status: string;
+    web_url: string;
+} | null> {
+    try {
+        const pipelines = await gl.get<GitLabPipeline[]>(
+            `/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;
+    }
+}