ci-triage 0.1.0 → 0.2.0

package/dist/flake-store.js

@@ -0,0 +1,106 @@
+import Database from 'better-sqlite3';
+import { mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+let _db = null;
+function dbPath() {
+    const dir = join(homedir(), '.ci-triage');
+    mkdirSync(dir, { recursive: true });
+    return join(dir, 'flake.db');
+}
+function getDb() {
+    if (_db)
+        return _db;
+    _db = new Database(dbPath());
+    bootstrap(_db);
+    return _db;
+}
+function bootstrap(db) {
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS runs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      repo TEXT NOT NULL,
+      run_id TEXT NOT NULL,
+      created_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS test_results (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      run_id INTEGER NOT NULL,
+      test_name TEXT NOT NULL,
+      status TEXT NOT NULL,
+      FOREIGN KEY (run_id) REFERENCES runs(id)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_runs_repo ON runs(repo);
+    CREATE INDEX IF NOT EXISTS idx_test_results_run_id ON test_results(run_id);
+    CREATE INDEX IF NOT EXISTS idx_test_results_test_name ON test_results(test_name);
+  `);
+}
+/** Persist a run and its test outcomes. */
+export function persistRun(repo, runId, createdAt, tests) {
+    const db = getDb();
+    // Deduplicate: skip if run already stored
+    const existing = db.prepare('SELECT id FROM runs WHERE repo = ? AND run_id = ?').get(repo, String(runId));
+    if (existing)
+        return;
+    const insertRun = db.prepare('INSERT INTO runs (repo, run_id, created_at) VALUES (?, ?, ?)');
+    const insertTest = db.prepare('INSERT INTO test_results (run_id, test_name, status) VALUES (?, ?, ?)');
+    const tx = db.transaction(() => {
+        const result = insertRun.run(repo, String(runId), createdAt);
+        const rowId = result.lastInsertRowid;
+        for (const [testName, status] of Object.entries(tests)) {
+            insertTest.run(rowId, testName, status);
+        }
+    });
+    tx();
+}
+/** Get flake stats for all known tests in a repo. */
+export function getFlakes(repo) {
+    const db = getDb();
+    const rows = db.prepare(`
+    SELECT
+      tr.test_name,
+      SUM(CASE WHEN tr.status IN ('fail', 'error') THEN 1 ELSE 0 END) AS fail_count,
+      SUM(CASE WHEN tr.status = 'pass' THEN 1 ELSE 0 END) AS pass_count,
+      COUNT(*) AS total_count,
+      MAX(r.created_at) AS last_seen
+    FROM test_results tr
+    JOIN runs r ON tr.run_id = r.id
+    WHERE r.repo = ?
+    GROUP BY tr.test_name
+    HAVING fail_count > 0 AND pass_count > 0
+    ORDER BY fail_count DESC
+  `).all(repo);
+    return rows.map((r) => ({
+        ...r,
+        repo,
+        flake_ratio: r.total_count > 0 ? r.fail_count / r.total_count : 0,
+    }));
+}
+/** Check if a specific test is flaky in a repo based on stored history. */
+export function isFlakySqlite(repo, testName) {
+    const db = getDb();
+    const row = db.prepare(`
+    SELECT
+      SUM(CASE WHEN tr.status IN ('fail', 'error') THEN 1 ELSE 0 END) AS fail_count,
+      SUM(CASE WHEN tr.status = 'pass' THEN 1 ELSE 0 END) AS pass_count,
+      COUNT(*) AS total_count
+    FROM test_results tr
+    JOIN runs r ON tr.run_id = r.id
+    WHERE r.repo = ? AND tr.test_name = ?
+  `).get(repo, testName);
+    if (!row || row.total_count === 0) {
+        return { is_flaky: false, fail_count: 0, pass_count: 0, flake_ratio: 0 };
+    }
+    const flake_ratio = row.fail_count / row.total_count;
+    const is_flaky = row.fail_count > 0 && row.pass_count > 0;
+    return { is_flaky, fail_count: row.fail_count, pass_count: row.pass_count, flake_ratio };
+}
+/** Close the DB (useful in tests). */
+export function closeDb() {
+    if (_db) {
+        _db.close();
+        _db = null;
+    }
+}

package/dist/index.js

@@ -1,66 +1,212 @@
 #!/usr/bin/env node
 import { writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import { classify } from './classifier.js';
-import { fetchFailedLog, fetchRunById, fetchRunMetadata, fetchRuns } from './fetcher.js';
 import { parseFailures } from './parser.js';
 import { buildJsonReport, toConsoleText, toJson, toMarkdown } from './reporter.js';
+import { getProvider, detectProvider } from './providers/index.js';
+import { getFlakes, persistRun } from './flake-store.js';
+import { analyzeLlm } from './llm-analyzer.js';
+// --version support
+const _require = createRequire(import.meta.url);
+let pkgVersion = 'unknown';
+try {
+    const pkg = _require('../package.json');
+    pkgVersion = pkg.version;
+}
+catch {
+    // ignore
+}
 function usage() {
-    console.error('Usage: ci-failure-triager owner/repo [limit] [--run <id>] [--md report.md] [--json]');
+    console.error([
+        `ci-triage v${pkgVersion}`,
+        '',
+        'Usage:',
+        '  ci-triage owner/repo [limit] [--run <id>] [--md report.md] [--json]',
+        '  ci-triage flakes owner/repo',
+        '',
+        'Options:',
+        '  --run <id>              Triage a specific run ID',
+        '  --md <path>             Write markdown report to file',
+        '  --json                  Output JSON instead of human text',
+        '  --provider <p>          Force CI provider: github | gitlab | circleci',
+        '  --llm                   Enable LLM root-cause analysis (requires OPENAI_API_KEY)',
+        '  --llm-model <model>     Override LLM model (default: gpt-4.1-mini)',
+        '  --version               Print version and exit',
+    ].join('\n'));
     process.exit(1);
 }
 function parseArgs(argv) {
-    const repo = argv[2];
-    const args = argv.slice(3);
-    if (!repo || !/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(repo)) {
+    const args = argv.slice(2);
+    // --version
+    if (args.includes('--version') || args.includes('-v')) {
+        process.stdout.write(`ci-triage v${pkgVersion}\n`);
+        process.exit(0);
+    }
+    // subcommand: ci-triage flakes owner/repo
+    if (args[0] === 'flakes') {
+        const repo = args[1];
+        if (!repo || !/^[A-Za-z0-9_./%-]+\/[A-Za-z0-9_./%-]+$/.test(repo)) {
+            console.error('Usage: ci-triage flakes owner/repo');
+            process.exit(1);
+        }
+        return { repo, limit: 0, outputJson: false, subcommand: 'flakes' };
+    }
+    const repo = args[0];
+    if (!repo || !/^[A-Za-z0-9_./%-]+\/[A-Za-z0-9_./%-]+$/.test(repo)) {
         usage();
     }
-    const firstPositional = args.find((arg) => !arg.startsWith('--'));
-    const parsedLimit = firstPositional ? Number(firstPositional) : 10;
+    const positionalArgs = args.slice(1).filter((arg) => !arg.startsWith('--'));
+    const parsedLimit = positionalArgs[0] ? Number(positionalArgs[0]) : 10;
     const limit = Math.min(Math.max(Number.isFinite(parsedLimit) ? parsedLimit : 10, 1), 100);
     const runIdx = args.indexOf('--run');
     const runIdRaw = runIdx >= 0 ? args[runIdx + 1] : undefined;
     const runId = runIdRaw ? Number(runIdRaw) : undefined;
     const mdIdx = args.indexOf('--md');
     const markdownPath = mdIdx >= 0 ? args[mdIdx + 1] ?? '' : undefined;
+    const providerIdx = args.indexOf('--provider');
+    const provider = providerIdx >= 0 ? args[providerIdx + 1] : undefined;
+    const llmModelIdx = args.indexOf('--llm-model');
+    const llmModel = llmModelIdx >= 0 ? args[llmModelIdx + 1] : undefined;
     return {
         repo,
         runId: Number.isFinite(runId) ? runId : undefined,
         limit,
         markdownPath,
         outputJson: args.includes('--json'),
+        provider,
+        llm: args.includes('--llm'),
+        llmModel,
     };
 }
-function pickRun(options) {
-    if (options.runId) {
-        return fetchRunById(options.repo, options.runId);
+async function runFlakesCommand(repo) {
+    const flakes = getFlakes(repo);
+    if (flakes.length === 0) {
+        console.log(`No flaky tests found for ${repo} in local history.`);
+        console.log('Run ci-triage a few times to build up history.');
+        return;
     }
-    const runs = fetchRuns(options.repo, options.limit);
-    return runs.find((r) => r.conclusion === 'failure') ?? null;
+    console.log(`\nKnown flaky tests in ${repo}:\n`);
+    console.log(`${'Test Name'.padEnd(60)} ${'Fails'.padStart(6)} ${'Passes'.padStart(7)} ${'Ratio'.padStart(7)} Last Seen`);
+    console.log('-'.repeat(110));
+    for (const f of flakes) {
+        const ratio = `${(f.flake_ratio * 100).toFixed(1)}%`;
+        const lastSeen = f.last_seen.slice(0, 10);
+        console.log(`${f.test_name.slice(0, 59).padEnd(60)} ${String(f.fail_count).padStart(6)} ${String(f.pass_count).padStart(7)} ${ratio.padStart(7)} ${lastSeen}`);
+    }
+    console.log(`\nTotal flaky tests: ${flakes.length}`);
 }
-function main() {
+async function main() {
     const options = parseArgs(process.argv);
-    const run = pickRun(options);
+    // Handle subcommands
+    if (options.subcommand === 'flakes') {
+        await runFlakesCommand(options.repo);
+        return;
+    }
+    // Resolve provider
+    const providerName = options.provider ?? detectProvider();
+    const provider = getProvider(providerName);
+    const canHandle = await provider.canHandle(options.repo);
+    if (!canHandle) {
+        process.exit(1);
+    }
+    // Resolve run
+    let run = null;
+    try {
+        run = await provider.resolveRun(options.repo, options.runId);
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(2);
+    }
     if (!run) {
         console.error('No failed runs found.');
         process.exit(2);
     }
-    const rawLog = fetchFailedLog(options.repo, run.databaseId);
+    // Fetch logs and metadata in parallel
+    const runRef = { provider: providerName, repo: options.repo, runId: run.id };
+    const [logBundle, metadata] = await Promise.all([
+        provider.fetchLogs(runRef),
+        provider.fetchMetadata(runRef),
+    ]);
+    const rawLog = logBundle.combined;
     const failures = parseFailures(rawLog);
     const classified = failures.map((failure) => ({
         ...failure,
         classification: classify(failure),
     }));
+    // Build compat RunInfo for reporter
+    const runInfo = {
+        databaseId: Number(run.id) || 0,
+        displayTitle: run.displayTitle,
+        workflowName: run.workflowName,
+        conclusion: run.conclusion,
+        url: run.url,
+    };
     const report = buildJsonReport({
         repo: options.repo,
-        run,
+        run: runInfo,
         failures: classified,
-        metadata: fetchRunMetadata(options.repo, run.databaseId),
+        metadata: {
+            headSha: metadata.headSha,
+            headBranch: metadata.headBranch,
+            event: metadata.event,
+        },
     });
+    // LLM analysis (gated)
+    const llmEnabled = options.llm || !!process.env['OPENAI_API_KEY'];
+    if (llmEnabled) {
+        const failureEntries = classified.map((f) => ({
+            type: f.classification?.type ?? 'unknown',
+            error: f.error,
+            stack: f.stack?.join('\n'),
+            category: f.classification?.category ?? 'unknown',
+            severity: f.classification?.severity ?? 'low',
+            suggested_fix: f.classification?.suggestedFix ?? '',
+            flaky: { is_flaky: false, confidence: 0, pass_rate_7d: 1, last_5_runs: [] },
+        }));
+        const analysis = await analyzeLlm(failureEntries, rawLog, {
+            model: options.llmModel,
+            enabled: true,
+        });
+        report.analysis = analysis;
+    }
+    // Persist to SQLite flake store (best-effort)
+    try {
+        const testMap = {};
+        for (const f of classified) {
+            if (f.stepName)
+                testMap[f.stepName] = 'fail';
+        }
+        persistRun(options.repo, String(run.id), new Date().toISOString(), testMap);
+    }
+    catch {
+        // non-fatal
+    }
     if (options.outputJson) {
         process.stdout.write(toJson(report));
     }
     else {
         process.stdout.write(toConsoleText(report));
+        // Print LLM analysis summary if available
+        if (report.analysis?.mode === 'llm') {
+            console.log('\n── LLM Root-Cause Analysis ─────────────────────────────');
+            console.log(`Model: ${report.analysis.model} (${report.analysis.provider})`);
+            if (report.analysis.root_cause) {
+                console.log(`Root Cause: ${report.analysis.root_cause}`);
+            }
+            if (report.analysis.fix_suggestions?.length) {
+                console.log('Fix Suggestions:');
+                for (const s of report.analysis.fix_suggestions) {
+                    console.log(`  • ${s}`);
+                }
+            }
+            if (report.analysis.llm?.usage) {
+                const u = report.analysis.llm.usage;
+                console.log(`Tokens: ${u.input_tokens} in / ${u.output_tokens} out — est. $${u.estimated_cost_usd.toFixed(4)}`);
+            }
+            console.log('─────────────────────────────────────────────────────────\n');
+        }
     }
     if (options.markdownPath) {
         writeFileSync(options.markdownPath, toMarkdown(report), 'utf8');
@@ -69,4 +215,7 @@ function main() {
         }
     }
 }
-main();
+main().catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/dist/llm-analyzer.js

@@ -0,0 +1,87 @@
+import OpenAI from 'openai';
+/** Pricing per 1M tokens (update as models change) */
+const PRICING_PER_1M = {
+    'gpt-4.1-mini': { input: 0.40, output: 1.60 },
+    'gpt-4.1': { input: 2.00, output: 8.00 },
+    'gpt-4o-mini': { input: 0.15, output: 0.60 },
+    'gpt-4o': { input: 2.50, output: 10.00 },
+};
+function estimateCost(model, inputTokens, outputTokens) {
+    const pricing = PRICING_PER_1M[model] ?? { input: 0.40, output: 1.60 };
+    return (inputTokens / 1_000_000) * pricing.input + (outputTokens / 1_000_000) * pricing.output;
+}
+function buildPrompt(failures, logExcerpt) {
+    const failureSummary = failures
+        .slice(0, 5)
+        .map((f) => `- [${f.category}] ${f.error}${f.stack ? `\n  Stack: ${f.stack.slice(0, 300)}` : ''}`)
+        .join('\n');
+    const logSnippet = logExcerpt.slice(-3000); // last 3k chars of log
+    return `You are a CI failure analyst. Given the following CI failures and log excerpt, provide:
+1. A concise root cause (1-2 sentences)
+2. Up to 3 specific fix suggestions
+
+Failures:
+${failureSummary}
+
+Log excerpt (last section):
+${logSnippet}
+
+Respond in JSON format:
+{
+  "root_cause": "...",
+  "fix_suggestions": ["...", "..."]
+}`;
+}
+export async function analyzeLlm(failures, logExcerpt, options = {}) {
+    const model = options.model ?? 'gpt-4.1-mini';
+    const enabled = options.enabled ?? (!!process.env['OPENAI_API_KEY']);
+    if (!enabled || !process.env['OPENAI_API_KEY']) {
+        return { mode: 'heuristic', fallback_reason: 'OPENAI_API_KEY not set or --llm not passed' };
+    }
+    const client = new OpenAI({ apiKey: process.env['OPENAI_API_KEY'] });
+    try {
+        const prompt = buildPrompt(failures, logExcerpt);
+        const response = await client.responses.create({
+            model,
+            input: prompt,
+        });
+        const inputTokens = response.usage?.input_tokens ?? 0;
+        const outputTokens = response.usage?.output_tokens ?? 0;
+        const estimatedCost = estimateCost(model, inputTokens, outputTokens);
+        const text = response.output_text ?? '';
+        let root_cause = '';
+        let fix_suggestions = [];
+        try {
+            // Strip markdown code fences if present
+            const cleaned = text.replace(/```(?:json)?\s*/g, '').replace(/```\s*$/g, '').trim();
+            const parsed = JSON.parse(cleaned);
+            root_cause = parsed.root_cause ?? '';
+            fix_suggestions = parsed.fix_suggestions ?? [];
+        }
+        catch {
+            root_cause = text.slice(0, 500);
+        }
+        return {
+            mode: 'llm',
+            provider: 'openai',
+            model,
+            root_cause,
+            fix_suggestions,
+            llm: {
+                usage: {
+                    input_tokens: inputTokens,
+                    output_tokens: outputTokens,
+                    estimated_cost_usd: estimatedCost,
+                },
+            },
+        };
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        console.error(`[ci-triage] LLM analysis failed, falling back to heuristic: ${reason}`);
+        return {
+            mode: 'heuristic',
+            fallback_reason: reason,
+        };
+    }
+}

package/dist/providers/circleci.js

@@ -0,0 +1,106 @@
+const CIRCLE_API = 'https://circleci.com/api/v2';
+function token() {
+    return process.env['CIRCLE_TOKEN'];
+}
+async function circleFetch(path) {
+    const tok = token();
+    if (!tok)
+        throw new Error('CIRCLE_TOKEN env var is required for CircleCI provider.');
+    const res = await fetch(`${CIRCLE_API}${path}`, {
+        headers: { 'Circle-Token': tok },
+    });
+    if (!res.ok)
+        throw new Error(`CircleCI API error ${res.status}: ${res.statusText} — ${path}`);
+    return res.json();
+}
+export class CircleCiProvider {
+    name = 'circleci';
+    async canHandle(_repo) {
+        if (!token()) {
+            console.error([
+                'Error: CircleCI provider requires CIRCLE_TOKEN environment variable.',
+                '  Create a personal API token at: https://app.circleci.com/settings/user/tokens',
+                '  Then set: export CIRCLE_TOKEN=<your-token>',
+            ].join('\n'));
+            return false;
+        }
+        return true;
+    }
+    /** repo format: gh/orgname/reponame or bb/org/repo */
+    async listRuns(repo, limit) {
+        const data = await circleFetch(`/project/${repo}/pipeline?page-token=&per_page=${Math.min(limit, 50)}`);
+        return data.items.map((p) => ({
+            id: p.id,
+            displayTitle: `Pipeline #${p.number}`,
+            workflowName: 'CircleCI',
+            conclusion: p.state === 'created' ? null : p.state,
+            url: `https://app.circleci.com/pipelines/${repo}/${p.number}`,
+        }));
+    }
+    async resolveRun(repo, runId) {
+        const runs = await this.listRuns(repo, 20);
+        if (runId !== undefined) {
+            const run = runs.find((r) => String(r.id) === String(runId));
+            if (!run)
+                throw new Error(`Pipeline ${runId} not found for ${repo}.`);
+            return run;
+        }
+        const failed = runs.find((r) => r.conclusion === 'errored' || r.conclusion === 'failed');
+        if (!failed)
+            throw new Error(`No failed pipelines found for ${repo} in recent history.`);
+        return failed;
+    }
+    async fetchLogs(ref) {
+        if (!ref.runId)
+            throw new Error('runId required for CircleCI provider');
+        const byJob = {};
+        try {
+            // Get workflows for this pipeline
+            const wfData = await circleFetch(`/pipeline/${ref.runId}/workflow`);
+            for (const wf of wfData.items) {
+                if (wf.status !== 'failed')
+                    continue;
+                const jobData = await circleFetch(`/workflow/${wf.id}/job`);
+                for (const job of jobData.items) {
+                    if (job.status !== 'failed' || !job.job_number)
+                        continue;
+                    try {
+                        const artifacts = await circleFetch(`/project/${ref.repo}/${job.job_number}/artifacts`);
+                        for (const artifact of artifacts.items) {
+                            if (artifact.path.endsWith('.log') || artifact.path.endsWith('output.txt')) {
+                                const logRes = await fetch(artifact.url, {
+                                    headers: { 'Circle-Token': token() },
+                                });
+                                if (logRes.ok)
+                                    byJob[job.name] = await logRes.text();
+                            }
+                        }
+                    }
+                    catch {
+                        // skip if artifact fetch fails
+                    }
+                }
+            }
+        }
+        catch {
+            // return empty on any error
+        }
+        return { combined: Object.values(byJob).join('\n'), byJob };
+    }
+    async fetchMetadata(ref) {
+        if (!ref.runId)
+            return { headSha: '', headBranch: '', event: '' };
+        try {
+            const pipeline = await circleFetch(`/pipeline/${ref.runId}`);
+            return {
+                headSha: pipeline.vcs?.revision ?? '',
+                headBranch: pipeline.vcs?.branch ?? '',
+                event: 'push',
+                url: `https://app.circleci.com/pipelines/${ref.repo}/${pipeline.number}`,
+            };
+        }
+        catch {
+            return { headSha: '', headBranch: '', event: '' };
+        }
+    }
+}

package/dist/providers/github.js

@@ -0,0 +1,103 @@
+import { execFileSync } from 'node:child_process';
+function runJson(args) {
+    const out = execFileSync('gh', args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+    return JSON.parse(out);
+}
+function runText(args) {
+    return execFileSync('gh', args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+}
+function checkGhAvailable() {
+    try {
+        execFileSync('gh', ['--version'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function checkGhAuth() {
+    try {
+        execFileSync('gh', ['auth', 'status'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export class GitHubProvider {
+    name = 'github';
+    async canHandle(_repo) {
+        if (!checkGhAvailable()) {
+            console.error([
+                'Error: `gh` CLI is required for GitHub mode but was not found.',
+                '  Install: https://cli.github.com/',
+                '  macOS:   brew install gh',
+                '  After installing, run: gh auth login',
+            ].join('\n'));
+            return false;
+        }
+        if (!checkGhAuth()) {
+            console.error([
+                'Error: `gh` CLI is installed but not authenticated.',
+                '  Run: gh auth login',
+                '  If you intended to use GitLab or CircleCI, pass --provider gitlab|circleci',
+            ].join('\n'));
+            return false;
+        }
+        return true;
+    }
+    async listRuns(repo, limit) {
+        const runs = runJson([
+            'run', 'list', '--repo', repo, '--limit', String(limit),
+            '--json', 'databaseId,displayTitle,workflowName,conclusion,url',
+        ]);
+        return runs.map((r) => ({
+            id: r.databaseId,
+            displayTitle: r.displayTitle,
+            workflowName: r.workflowName,
+            conclusion: r.conclusion,
+            url: r.url,
+        }));
+    }
+    async resolveRun(repo, runId) {
+        const runs = await this.listRuns(repo, 100);
+        if (runId !== undefined) {
+            const run = runs.find((r) => String(r.id) === String(runId));
+            if (!run)
+                throw new Error(`Run ${runId} not found in recent runs for ${repo}.`);
+            return run;
+        }
+        // Most recent failed run
+        const failed = runs.find((r) => r.conclusion === 'failure');
+        if (!failed)
+            throw new Error(`No failed runs found for ${repo} in recent history.`);
+        return failed;
+    }
+    async fetchLogs(ref) {
+        if (!ref.runId)
+            throw new Error('runId required for GitHub provider');
+        try {
+            const combined = runText([
+                'run', 'view', String(ref.runId), '--repo', ref.repo, '--log-failed',
+            ]);
+            return { combined };
+        }
+        catch {
+            return { combined: '' };
+        }
+    }
+    async fetchMetadata(ref) {
+        if (!ref.runId)
+            return { headSha: '', headBranch: '', event: '' };
+        try {
+            const result = runJson([
+                'run', 'view', String(ref.runId), '--repo', ref.repo,
+                '--json', 'headSha,headBranch,event',
+            ]);
+            return result;
+        }
+        catch {
+            return { headSha: '', headBranch: '', event: '' };
+        }
+    }
+}

package/dist/providers/gitlab.js

@@ -0,0 +1,96 @@
+const GITLAB_API = 'https://gitlab.com/api/v4';
+function token() {
+    return process.env['GITLAB_TOKEN'];
+}
+async function gitlabFetch(path) {
+    const tok = token();
+    if (!tok)
+        throw new Error('GITLAB_TOKEN env var is required for GitLab provider.');
+    const res = await fetch(`${GITLAB_API}${path}`, {
+        headers: { 'PRIVATE-TOKEN': tok },
+    });
+    if (!res.ok)
+        throw new Error(`GitLab API error ${res.status}: ${res.statusText} — ${path}`);
+    return res.json();
+}
+function encodedRepo(repo) {
+    // repo format: group/project — encode slashes for GitLab API
+    return encodeURIComponent(repo);
+}
+export class GitLabProvider {
+    name = 'gitlab';
+    async canHandle(_repo) {
+        if (!token()) {
+            console.error([
+                'Error: GitLab provider requires GITLAB_TOKEN environment variable.',
+                '  Create a personal access token at: https://gitlab.com/-/profile/personal_access_tokens',
+                '  Required scopes: read_api',
+                '  Then set: export GITLAB_TOKEN=<your-token>',
+            ].join('\n'));
+            return false;
+        }
+        return true;
+    }
+    async listRuns(repo, limit) {
+        const pipelines = await gitlabFetch(`/projects/${encodedRepo(repo)}/pipelines?per_page=${limit}`);
+        return pipelines.map((p) => ({
+            id: p.id,
+            displayTitle: `Pipeline #${p.id} (${p.ref})`,
+            workflowName: 'GitLab CI',
+            conclusion: p.status === 'success' ? 'success' : p.status === 'failed' ? 'failure' : p.status,
+            url: p.web_url,
+        }));
+    }
+    async resolveRun(repo, runId) {
+        if (runId !== undefined) {
+            const pipeline = await gitlabFetch(`/projects/${encodedRepo(repo)}/pipelines/${runId}`);
+            return {
+                id: pipeline.id,
+                displayTitle: `Pipeline #${pipeline.id} (${pipeline.ref})`,
+                workflowName: 'GitLab CI',
+                conclusion: pipeline.status === 'success' ? 'success' : pipeline.status === 'failed' ? 'failure' : pipeline.status,
+                url: pipeline.web_url,
+            };
+        }
+        const runs = await this.listRuns(repo, 20);
+        const failed = runs.find((r) => r.conclusion === 'failure');
+        if (!failed)
+            throw new Error(`No failed pipelines found for ${repo} in recent history.`);
+        return failed;
+    }
+    async fetchLogs(ref) {
+        if (!ref.runId)
+            throw new Error('runId required for GitLab provider');
+        const jobs = await gitlabFetch(`/projects/${encodedRepo(ref.repo)}/pipelines/${ref.runId}/jobs?scope[]=failed`);
+        const byJob = {};
+        for (const job of jobs) {
+            try {
+                const logRes = await fetch(`${GITLAB_API}/projects/${encodedRepo(ref.repo)}/jobs/${job.id}/trace`, { headers: { 'PRIVATE-TOKEN': token() } });
+                if (logRes.ok) {
+                    byJob[job.name] = await logRes.text();
+                }
+            }
+            catch {
+                // skip job if log fetch fails
+            }
+        }
+        const combined = Object.values(byJob).join('\n');
+        return { combined, byJob };
+    }
+    async fetchMetadata(ref) {
+        if (!ref.runId)
+            return { headSha: '', headBranch: '', event: '' };
+        try {
+            const pipeline = await gitlabFetch(`/projects/${encodedRepo(ref.repo)}/pipelines/${ref.runId}`);
+            return {
+                headSha: pipeline.sha,
+                headBranch: pipeline.ref,
+                event: 'push',
+                url: pipeline.web_url,
+            };
+        }
+        catch {
+            return { headSha: '', headBranch: '', event: '' };
+        }
+    }
+}

package/dist/providers/index.js

@@ -0,0 +1,36 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { GitHubProvider } from './github.js';
+import { GitLabProvider } from './gitlab.js';
+import { CircleCiProvider } from './circleci.js';
+export { GitHubProvider } from './github.js';
+export { GitLabProvider } from './gitlab.js';
+export { CircleCiProvider } from './circleci.js';
+const providers = {
+    github: () => new GitHubProvider(),
+    gitlab: () => new GitLabProvider(),
+    circleci: () => new CircleCiProvider(),
+};
+/**
+ * Detect CI provider by local repo markers.
+ * Checks cwd and common project root indicators.
+ */
+export function detectProvider(cwd = process.cwd()) {
+    if (existsSync(join(cwd, '.gitlab-ci.yml')))
+        return 'gitlab';
+    if (existsSync(join(cwd, '.circleci')))
+        return 'circleci';
+    return 'github';
+}
+/** Get a provider instance by name, or auto-detect if not specified. */
+export function getProvider(name) {
+    if (name) {
+        const factory = providers[name];
+        if (!factory) {
+            throw new Error(`Unknown provider: "${name}". Valid options: github, gitlab, circleci`);
+        }
+        return factory();
+    }
+    const detected = detectProvider();
+    return providers[detected]();
+}

package/dist/providers/types.js

@@ -0,0 +1,2 @@
+/** Provider abstraction for multi-CI support. */
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ci-triage",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Open-source CI failure triage for humans and agents — smart log parsing, flake detection, structured JSON, MCP server.",
   "type": "module",
   "bin": {
@@ -35,17 +35,20 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/clankamode/ci-triage.git"
+    "url": "git+https://github.com/clankamode/ci-triage.git"
   },
   "homepage": "https://github.com/clankamode/ci-triage",
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.13.10",
     "typescript": "^5.9.2",
     "vitest": "^4.0.18"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1",
+    "better-sqlite3": "^12.6.2",
     "fast-xml-parser": "^5.4.1",
+    "openai": "^6.25.0",
     "zod": "^4.3.6"
   }
 }