ci-triage 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,67 +1,526 @@
 #!/usr/bin/env node
 import { writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
 import { classify } from './classifier.js';
-import { fetchFailedLog, fetchRunById, fetchRunMetadata, fetchRuns } from './fetcher.js';
-import { parseFailures } from './parser.js';
+import { parseAllFailures } from './parser.js';
 import { buildJsonReport, toConsoleText, toJson, toMarkdown } from './reporter.js';
+import { getProvider, detectProvider } from './providers/index.js';
+import { getDbStats, getFlakes, getRemediations, markResolved, markVerified, persistRun, pruneRuns } from './flake-store.js';
+import { analyzeLlm } from './llm-analyzer.js';
+import { fetchRepoContext } from './repo-context.js';
+import { buildMultiJson, detectSharedPatterns, formatMultiSummary } from './multi.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 multi owner/repo1 owner/repo2 owner/repo3 [--json]',
+        '  ci-triage flakes owner/repo',
+        '  ci-triage db prune [--days 90]',
+        '  ci-triage db stats [owner/repo] [--json]',
+        '  ci-triage resolve <owner/repo> <run-id> "<description>" [--commit <sha>]',
+        '  ci-triage verify <owner/repo> <run-id> --clean-run <clean-run-id>',
+        '  ci-triage history <owner/repo> [--json]',
+        '',
+        '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)) {
+export const EMPTY_OUTPUT_WARNING = 'Warning: No structured failures detected. The log may contain infra/script failures\n' +
+    "that the heuristic parser doesn't recognize. Re-run with OPENAI_API_KEY set or\n" +
+    'pass --llm for root-cause analysis.\n';
+export function shouldWarnOnEmptyOutput(totalFailures, llmRan) {
+    return totalFailures === 0 && !llmRan;
+}
+export function emitEmptyOutputWarning(totalFailures, llmRan) {
+    if (shouldWarnOnEmptyOutput(totalFailures, llmRan)) {
+        process.stderr.write(EMPTY_OUTPUT_WARNING);
+    }
+}
+function buildRepoContextHint(repoContext, failures) {
+    if (!repoContext)
+        return null;
+    const pagesFailure = failures.some((f) => /pages|deploy-pages|github pages/i.test(`${f.stepName} ${f.error}`));
+    if (pagesFailure && repoContext.private && !repoContext.pagesEnabled) {
+        return '(private repo, Pages not enabled)';
+    }
+    return null;
+}
+export function parseArgs(argv) {
+    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' };
+    }
+    // subcommand: ci-triage multi owner/repo1 owner/repo2 [--json]
+    if (args[0] === 'multi') {
+        const repos = args.slice(1).filter((arg) => !arg.startsWith('--'));
+        if (repos.length === 0 ||
+            repos.some((repo) => !/^[A-Za-z0-9_./%-]+\/[A-Za-z0-9_./%-]+$/.test(repo))) {
+            console.error('Usage: ci-triage multi owner/repo1 owner/repo2 owner/repo3 [--json]');
+            process.exit(1);
+        }
+        return { repo: repos[0], repos, limit: 0, outputJson: args.includes('--json'), subcommand: 'multi' };
+    }
+    // subcommand: ci-triage db prune [--days 90]
+    if (args[0] === 'db' && args[1] === 'prune') {
+        const daysIdx = args.indexOf('--days');
+        const days = daysIdx >= 0 ? Number(args[daysIdx + 1]) : 90;
+        return {
+            repo: '',
+            limit: 0,
+            outputJson: args.includes('--json'),
+            subcommand: 'db-prune',
+            dbPruneDays: isFinite(days) ? days : 90,
+        };
+    }
+    // subcommand: ci-triage db stats [owner/repo]
+    if (args[0] === 'db' && args[1] === 'stats') {
+        const repo = args[2];
+        if (repo && !/^[A-Za-z0-9_./%-]+\/[A-Za-z0-9_./%-]+$/.test(repo)) {
+            console.error('Usage: ci-triage db stats [owner/repo]');
+            process.exit(1);
+        }
+        return {
+            repo: '',
+            limit: 0,
+            outputJson: args.includes('--json'),
+            subcommand: 'db-stats',
+            dbStatRepo: repo,
+        };
+    }
+    // subcommand: ci-triage resolve <owner/repo> <run-id> "<description>" [--commit <sha>]
+    if (args[0] === 'resolve') {
+        const repo = args[1];
+        const resolveRunId = args[2];
+        const resolveDescription = args[3];
+        if (!repo || !resolveRunId || !resolveDescription) {
+            console.error('Usage: ci-triage resolve owner/repo run-id "description" [--commit <sha>]');
+            process.exit(1);
+        }
+        const commitIdx = args.indexOf('--commit');
+        const resolveCommit = commitIdx >= 0 ? args[commitIdx + 1] : undefined;
+        return { repo, limit: 0, outputJson: false, subcommand: 'resolve', resolveRunId, resolveDescription, resolveCommit };
+    }
+    // subcommand: ci-triage verify <owner/repo> <run-id> --clean-run <clean-run-id>
+    if (args[0] === 'verify') {
+        const repo = args[1];
+        const verifyRunId = args[2];
+        const cleanRunIdx = args.indexOf('--clean-run');
+        const cleanRunId = cleanRunIdx >= 0 ? args[cleanRunIdx + 1] : undefined;
+        if (!repo || !verifyRunId || !cleanRunId) {
+            console.error('Usage: ci-triage verify owner/repo run-id --clean-run clean-run-id');
+            process.exit(1);
+        }
+        return { repo, limit: 0, outputJson: false, subcommand: 'verify', verifyRunId, cleanRunId };
+    }
+    // subcommand: ci-triage history <owner/repo> [--json]
+    if (args[0] === 'history') {
+        const historyRepo = args[1];
+        if (!historyRepo || !/^[A-Za-z0-9_./%-]+\/[A-Za-z0-9_./%-]+$/.test(historyRepo)) {
+            console.error('Usage: ci-triage history owner/repo [--json]');
+            process.exit(1);
+        }
+        return { repo: '', limit: 0, outputJson: args.includes('--json'), subcommand: 'history', historyRepo };
+    }
+    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;
+    }
+    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}`);
+}
+async function runDbStatsCommand(repo, outputJson) {
+    const stats = getDbStats(repo);
+    if (outputJson) {
+        process.stdout.write(`${JSON.stringify(stats, null, 2)}\n`);
+        return;
+    }
+    const rows = [
+        ['scope', repo ?? 'all repos'],
+        ['run_count', String(stats.run_count)],
+        ['test_result_count', String(stats.test_result_count)],
+        ['flaky_test_count', String(stats.flaky_test_count)],
+        ['db_path', stats.db_path],
+        ['db_size_bytes', String(stats.db_size_bytes)],
+    ];
+    const keyWidth = Math.max(...rows.map(([k]) => k.length));
+    const valueWidth = Math.max(...rows.map(([, v]) => v.length));
+    const border = `+${'-'.repeat(keyWidth + 2)}+${'-'.repeat(valueWidth + 2)}+`;
+    console.log(border);
+    console.log(`| ${'metric'.padEnd(keyWidth)} | ${'value'.padEnd(valueWidth)} |`);
+    console.log(border);
+    for (const [key, value] of rows) {
+        console.log(`| ${key.padEnd(keyWidth)} | ${value.padEnd(valueWidth)} |`);
+    }
+    console.log(border);
+}
+function runResolveCommand(repo, runId, description, commit) {
+    markResolved(repo, runId, 'manual', description, commit);
+    console.log(`✓ Marked run ${runId} as resolved: ${description}`);
+}
+function runVerifyCommand(repo, runId, cleanRunId) {
+    markVerified(repo, runId, cleanRunId);
+    console.log(`✓ Verified fix: run ${runId} resolved by clean run ${cleanRunId}`);
+}
+function runHistoryCommand(repo, outputJson) {
+    const records = getRemediations(repo);
+    if (outputJson) {
+        process.stdout.write(`${JSON.stringify(records, null, 2)}\n`);
+        return;
+    }
+    if (records.length === 0) {
+        console.log(`No remediation history found for ${repo}.`);
+        return;
     }
-    const runs = fetchRuns(options.repo, options.limit);
-    return runs.find((r) => r.conclusion === 'failure') ?? null;
+    const cols = {
+        run_id: Math.max(6, ...records.map((r) => r.run_id.length)),
+        fix_action: Math.max(10, ...records.map((r) => r.fix_action.length)),
+        description: Math.max(11, ...records.map((r) => r.description.length)),
+        resolved_at: 10,
+        verified: 8,
+    };
+    const sep = `+-${'-'.repeat(cols.run_id)}-+-${'-'.repeat(cols.fix_action)}-+-${'-'.repeat(cols.description)}-+-${'-'.repeat(cols.resolved_at)}-+-${'-'.repeat(cols.verified)}-+`;
+    const header = `| ${'run_id'.padEnd(cols.run_id)} | ${'fix_action'.padEnd(cols.fix_action)} | ${'description'.padEnd(cols.description)} | ${'resolved_at'.padEnd(cols.resolved_at)} | ${'verified?'.padEnd(cols.verified)} |`;
+    console.log(sep);
+    console.log(header);
+    console.log(sep);
+    for (const r of records) {
+        const desc = r.description.length > cols.description ? r.description.slice(0, cols.description - 1) + '…' : r.description;
+        const line = `| ${r.run_id.padEnd(cols.run_id)} | ${r.fix_action.padEnd(cols.fix_action)} | ${desc.padEnd(cols.description)} | ${r.resolved_at.slice(0, 10).padEnd(cols.resolved_at)} | ${(r.is_verified ? 'yes' : 'no').padEnd(cols.verified)} |`;
+        console.log(line);
+    }
+    console.log(sep);
+    console.log(`\nTotal: ${records.length} remediation(s)`);
 }
-function main() {
+export async function triageRepo(options) {
+    const providerName = options.provider ?? detectProvider();
+    const provider = getProvider(providerName);
+    const repoContextPromise = fetchRepoContext(options.repo).catch(() => null);
+    const canHandle = await provider.canHandle(options.repo);
+    if (!canHandle) {
+        throw new Error(`Provider ${providerName} cannot handle repo ${options.repo}`);
+    }
+    const run = await provider.resolveRun(options.repo, options.runId);
+    if (!run) {
+        throw new Error('No failed runs found.');
+    }
+    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 = parseAllFailures(rawLog);
+    const classified = failures.map((failure) => ({
+        ...failure,
+        classification: classify(failure),
+    }));
+    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: runInfo,
+        failures: classified,
+        metadata: {
+            headSha: metadata.headSha,
+            headBranch: metadata.headBranch,
+            event: metadata.event,
+        },
+    });
+    const llmEnabled = options.llm || !!process.env['OPENAI_API_KEY'];
+    if (llmEnabled) {
+        const repoContext = await repoContextPromise;
+        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 ?? '',
+            fix_action: f.classification?.fixAction ?? 'unknown',
+            flaky: { is_flaky: false, confidence: 0, pass_rate_7d: 1, last_5_runs: [] },
+        }));
+        const analysis = await analyzeLlm(failureEntries, rawLog, {
+            model: options.llmModel,
+            enabled: llmEnabled,
+            repoContext,
+        });
+        report.analysis = analysis;
+    }
+    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
+    }
+    return report;
+}
+async function runMultiCommand(options) {
+    const reports = [];
+    const repos = options.repos ?? [];
+    for (const repo of repos) {
+        try {
+            const report = await triageRepo({
+                repo,
+                provider: options.provider,
+                llm: options.llm,
+                llmModel: options.llmModel,
+            });
+            reports.push(report);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`Failed to triage ${repo}: ${message}`);
+        }
+    }
+    const patterns = detectSharedPatterns(reports);
+    if (options.outputJson) {
+        process.stdout.write(buildMultiJson(reports, patterns));
+        return;
+    }
+    process.stdout.write(formatMultiSummary(reports, patterns));
+}
+async function main() {
     const options = parseArgs(process.argv);
-    const run = pickRun(options);
+    // Handle subcommands
+    if (options.subcommand === 'flakes') {
+        await runFlakesCommand(options.repo);
+        return;
+    }
+    if (options.subcommand === 'db-prune') {
+        const days = options.dbPruneDays ?? 90;
+        const deleted = pruneRuns(days);
+        console.log(`Pruned ${deleted} run(s) older than ${days} days from ~/.ci-triage/flake.db`);
+        return;
+    }
+    if (options.subcommand === 'db-stats') {
+        await runDbStatsCommand(options.dbStatRepo, options.outputJson);
+        return;
+    }
+    if (options.subcommand === 'resolve') {
+        runResolveCommand(options.repo, options.resolveRunId, options.resolveDescription, options.resolveCommit);
+        return;
+    }
+    if (options.subcommand === 'verify') {
+        runVerifyCommand(options.repo, options.verifyRunId, options.cleanRunId);
+        return;
+    }
+    if (options.subcommand === 'history') {
+        runHistoryCommand(options.historyRepo, options.outputJson);
+        return;
+    }
+    if (options.subcommand === 'multi') {
+        await runMultiCommand(options);
+        return;
+    }
+    // Resolve provider
+    const providerName = options.provider ?? detectProvider();
+    const provider = getProvider(providerName);
+    const repoContextPromise = fetchRepoContext(options.repo).catch(() => null);
+    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);
-    const failures = parseFailures(rawLog);
+    // 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 = parseAllFailures(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 repoContext = await repoContextPromise;
+        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: llmEnabled,
+            repoContext,
+        });
+        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
+    }
+    // Surface remediation status (best-effort)
+    try {
+        const remediations = getRemediations(options.repo);
+        const currentRunStr = String(run.id);
+        const currentResolved = remediations.find((r) => r.run_id === currentRunStr);
+        if (currentResolved) {
+            console.log(`✓ This run was previously marked as resolved`);
+        }
+        const unresolved = remediations.filter((r) => r.run_id !== currentRunStr && !r.is_verified);
+        if (unresolved.length > 0) {
+            console.log(`⚠ ${unresolved.length} previously unresolved run(s) for this repo`);
+        }
+    }
+    catch {
+        // non-fatal
+    }
     if (options.outputJson) {
         process.stdout.write(toJson(report));
     }
     else {
         process.stdout.write(toConsoleText(report));
+        const repoContext = await repoContextPromise;
+        const repoHint = buildRepoContextHint(repoContext, classified.map((f) => ({ stepName: f.stepName, error: f.error })));
+        if (repoHint) {
+            console.log(repoHint);
+        }
+        // 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');
+        }
     }
+    const llmRan = report.analysis?.mode === 'llm';
+    emitEmptyOutputWarning(report.summary.total_failures, llmRan);
     if (options.markdownPath) {
         writeFileSync(options.markdownPath, toMarkdown(report), 'utf8');
         if (!options.outputJson) {
@@ -69,4 +528,9 @@ function main() {
         }
     }
 }
-main();
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    main().catch((err) => {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    });
+}

package/dist/llm-analyzer.js

@@ -0,0 +1,106 @@
+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 formatRepoContext(context) {
+    const visibilityLine = `- Visibility: ${context.visibility}${context.plan ? ` (${context.plan} plan)` : ''}`;
+    const pagesLine = `- GitHub Pages: ${context.pagesEnabled ? 'enabled' : 'not enabled'}`;
+    const scanningLine = `- Code scanning: ${context.hasCodeScanning ? 'enabled' : 'not enabled'}`;
+    const workflowsLine = `- Workflow files: ${context.workflowFiles.length ? context.workflowFiles.join(', ') : 'none found'}`;
+    const scopesLine = `- Token scopes: ${context.tokenScopes.length ? context.tokenScopes.join(', ') : 'none detected'}`;
+    return [
+        'Repository context:',
+        visibilityLine,
+        pagesLine,
+        scanningLine,
+        workflowsLine,
+        scopesLine,
+        '',
+        'Given this context, consider whether workflow files should be removed rather than fixed.',
+        '',
+    ].join('\n');
+}
+export function buildPrompt(failures, logExcerpt, repoContext = null) {
+    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
+    const contextPrefix = repoContext ? `${formatRepoContext(repoContext)}\n` : '';
+    return `${contextPrefix}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, options.repoContext ?? null);
+        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,
+        };
+    }
+}