gitpadi 2.0.7 → 2.1.2

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

@@ -98,6 +98,30 @@ 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;
+    }
+}

package/dist/gitlab-agents/ci-recovery-agent.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+// gitlab-agents/ci-recovery-agent.ts
+//
+// GitLab Duo External Agent — AI-powered CI Failure Recovery
+//
+// Triggered when a pipeline fails on an MR.
+// Claude reads the full failure logs, identifies root causes, and:
+//   1. Posts a diagnosis comment on the MR explaining what failed and why
+//   2. Suggests specific fixes with code snippets
+//   3. (Optional) Creates a fix commit if AUTO_FIX=true
+import Anthropic from '@anthropic-ai/sdk';
+const GITLAB_TOKEN = process.env.GITLAB_TOKEN || '';
+const GITLAB_HOST = (process.env.GITLAB_HOST || 'https://gitlab.com').replace(/\/$/, '');
+const GATEWAY_TOKEN = process.env.AI_FLOW_AI_GATEWAY_TOKEN || '';
+const anthropic = GATEWAY_TOKEN
+    ? new Anthropic({ apiKey: GATEWAY_TOKEN, baseURL: `${GITLAB_HOST}/api/v4/ai/llm/v1` })
+    : new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+const CI_RECOVERY_MARKER = '<!-- gitpadi-ci-recovery -->';
+async function glFetch(method, path, body) {
+    const res = await fetch(`${GITLAB_HOST}/api/v4${path}`, {
+        method,
+        headers: { 'PRIVATE-TOKEN': GITLAB_TOKEN, 'Content-Type': 'application/json' },
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    if (!res.ok)
+        throw new Error(`GitLab ${method} ${path} → ${res.status}`);
+    return res.json();
+}
+async function getJobLog(projectId, jobId) {
+    const res = await fetch(`${GITLAB_HOST}/api/v4/projects/${projectId}/jobs/${jobId}/trace`, {
+        headers: { 'PRIVATE-TOKEN': GITLAB_TOKEN },
+    });
+    if (!res.ok)
+        return 'Log unavailable';
+    const text = await res.text();
+    // Return last 3000 chars — most errors are at the end
+    return text.length > 3000 ? `...\n${text.slice(-3000)}` : text;
+}
+async function postOrUpdateMRNote(projectId, mrIid, body) {
+    const notes = await glFetch('GET', `/projects/${projectId}/merge_requests/${mrIid}/notes?per_page=100`);
+    const existing = notes.find(n => n.body?.includes(CI_RECOVERY_MARKER));
+    if (existing) {
+        await glFetch('PUT', `/projects/${projectId}/merge_requests/${mrIid}/notes/${existing.id}`, { body });
+    }
+    else {
+        await glFetch('POST', `/projects/${projectId}/merge_requests/${mrIid}/notes`, { body });
+    }
+}
+async function main() {
+    console.log('\n🤖 GitPadi CI Recovery Agent\n');
+    const contextRaw = process.env.AI_FLOW_CONTEXT || '{}';
+    let context;
+    try {
+        context = JSON.parse(contextRaw);
+    }
+    catch {
+        context = {};
+    }
+    const { project_id, project_path = '', mr_iid, pipeline_id, title = '', source_branch = '', author = '', failed_jobs = [], } = context;
+    if (!mr_iid || !pipeline_id) {
+        console.log('⏭️ No MR/pipeline context — skipping.');
+        return;
+    }
+    console.log(`  Project:  ${project_path}`);
+    console.log(`  MR:       !${mr_iid} — ${title}`);
+    console.log(`  Pipeline: #${pipeline_id}`);
+    console.log(`  Failed:   ${failed_jobs.length} job(s)\n`);
+    // Fetch all failed jobs if not in context
+    let jobs = failed_jobs;
+    if (!jobs.length) {
+        try {
+            const allJobs = await glFetch('GET', `/projects/${project_id}/pipelines/${pipeline_id}/jobs?per_page=100`);
+            jobs = allJobs.filter((j) => j.status === 'failed');
+        }
+        catch {
+            jobs = [];
+        }
+    }
+    if (!jobs.length) {
+        console.log('  No failed jobs found.');
+        return;
+    }
+    // Collect logs from failed jobs
+    console.log('  Fetching failure logs...');
+    const jobLogs = [];
+    for (const job of jobs.slice(0, 3)) { // max 3 jobs to avoid token overload
+        const log = await getJobLog(project_id, job.id);
+        jobLogs.push({ name: job.name, stage: job.stage || 'unknown', log });
+        console.log(`  ✓ Fetched log for: ${job.name}`);
+    }
+    // Ask Claude to diagnose
+    const prompt = `You are GitPadi, an AI DevOps assistant integrated with GitLab.
+
+A CI pipeline failed on this Merge Request:
+- MR: !${mr_iid} — "${title}"
+- Author: @${author}
+- Branch: ${source_branch}
+
+Failed job logs:
+${jobLogs.map(j => `\n### Job: ${j.name} (stage: ${j.stage})\n\`\`\`\n${j.log}\n\`\`\``).join('\n')}
+
+Analyze these failures and provide:
+1. Root cause diagnosis for each failure
+2. Specific fix recommendations with code snippets where possible
+3. Priority order of fixes
+
+Respond as JSON:
+{
+  "failures": [
+    {
+      "job": "job name",
+      "rootCause": "explanation",
+      "errorType": "lint|test|build|type|other",
+      "fix": {
+        "description": "what to change",
+        "codeSnippet": "code if applicable, null otherwise",
+        "commands": ["shell commands if applicable"]
+      },
+      "confidence": "high|medium|low"
+    }
+  ],
+  "quickFix": "single most impactful thing to fix first",
+  "estimatedFixTime": "e.g. 5 minutes",
+  "summary": "overall diagnosis in 2-3 sentences"
+}`;
+    let diagnosis;
+    try {
+        const response = await anthropic.messages.create({
+            model: 'claude-sonnet-4-20250514',
+            max_tokens: 2048,
+            messages: [{ role: 'user', content: prompt }],
+        });
+        const text = response.content[0].type === 'text' ? response.content[0].text : '';
+        const jsonMatch = text.match(/\{[\s\S]*\}/);
+        if (!jsonMatch)
+            throw new Error('No JSON');
+        diagnosis = JSON.parse(jsonMatch[0]);
+    }
+    catch (e) {
+        console.error(`❌ Claude diagnosis failed: ${e.message}`);
+        process.exit(1);
+    }
+    // Build the recovery comment
+    let comment = `## 🤖 GitPadi — CI Failure Recovery\n\n`;
+    comment += `**Pipeline:** #${pipeline_id} | **Failed jobs:** ${jobs.length}\n\n`;
+    comment += `### Diagnosis\n\n${diagnosis.summary}\n\n`;
+    if (diagnosis.quickFix) {
+        comment += `> 🚀 **Quick Fix:** ${diagnosis.quickFix}\n`;
+        comment += `> ⏱️ **Estimated fix time:** ${diagnosis.estimatedFixTime || 'a few minutes'}\n\n`;
+    }
+    diagnosis.failures?.forEach((f, i) => {
+        const confIcon = f.confidence === 'high' ? '🔴' : f.confidence === 'medium' ? '🟡' : '🟢';
+        comment += `### ${i + 1}. \`${f.job}\`\n\n`;
+        comment += `**Root Cause:** ${f.rootCause}\n\n`;
+        if (f.fix) {
+            comment += `**Fix:** ${f.fix.description}\n\n`;
+            if (f.fix.codeSnippet) {
+                comment += `\`\`\`\n${f.fix.codeSnippet}\n\`\`\`\n\n`;
+            }
+            if (f.fix.commands?.length) {
+                comment += `Run:\n\`\`\`bash\n${f.fix.commands.join('\n')}\n\`\`\`\n\n`;
+            }
+        }
+        comment += `${confIcon} Confidence: ${f.confidence}\n\n`;
+    });
+    comment += `---\n`;
+    comment += `_🤖 Diagnosed by [GitPadi](https://github.com/Netwalls/contributor-agent) using Claude — [Fix & Re-push](https://github.com/Netwalls/contributor-agent#fix--re-push) when ready_\n\n`;
+    comment += CI_RECOVERY_MARKER;
+    await postOrUpdateMRNote(project_id, mr_iid, comment);
+    console.log(`\n✅ Recovery guide posted to MR !${mr_iid}`);
+    console.log(`   ${diagnosis.failures?.length || 0} failure(s) diagnosed`);
+}
+main().catch(e => { console.error('Fatal:', e.message); process.exit(1); });