ci-triage 0.2.0 → 0.3.1

package/dist/index.js

@@ -1,12 +1,16 @@
 #!/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 { 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 { getFlakes, persistRun } from './flake-store.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';
+import { startMcpServer } from './mcp-server.js';
 // --version support
 const _require = createRequire(import.meta.url);
 let pkgVersion = 'unknown';
@@ -23,20 +27,48 @@ function usage() {
         '',
         '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                   Enable LLM root-cause analysis (auto-on when OPENAI_API_KEY is set)',
+        '  --no-llm                Disable LLM even when OPENAI_API_KEY is set (alias: CI_TRIAGE_NO_LLM=1)',
         '  --llm-model <model>     Override LLM model (default: gpt-4.1-mini)',
+        '  --mcp                   Start MCP server (stdio transport) for agent tool use',
         '  --version               Print version and exit',
     ].join('\n'));
     process.exit(1);
 }
-function parseArgs(argv) {
+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')) {
@@ -52,6 +84,77 @@ function parseArgs(argv) {
         }
         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();
@@ -76,6 +179,8 @@ function parseArgs(argv) {
         outputJson: args.includes('--json'),
         provider,
         llm: args.includes('--llm'),
+        noLlm: args.includes('--no-llm'),
+        mcp: args.includes('--mcp'),
         llmModel,
     };
 }
@@ -96,16 +201,215 @@ async function runFlakesCommand(repo) {
     }
     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 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)`);
+}
+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 noLlm = options.noLlm || !!process.env['CI_TRIAGE_NO_LLM'];
+    const autoLlm = !noLlm && !!process.env['OPENAI_API_KEY'];
+    if (autoLlm && !options.llm && !noLlm) {
+        process.stderr.write('ℹ using LLM analysis (set CI_TRIAGE_NO_LLM=1 or pass --no-llm to disable)\n');
+    }
+    const llmEnabled = !noLlm && (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,
+                noLlm: options.noLlm,
+                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);
+    // --mcp: start MCP server in stdio mode
+    if (options.mcp) {
+        await startMcpServer();
+        return;
+    }
     // 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);
@@ -130,7 +434,7 @@ async function main() {
         provider.fetchMetadata(runRef),
     ]);
     const rawLog = logBundle.combined;
-    const failures = parseFailures(rawLog);
+    const failures = parseAllFailures(rawLog);
     const classified = failures.map((failure) => ({
         ...failure,
         classification: classify(failure),
@@ -154,8 +458,14 @@ async function main() {
         },
     });
     // LLM analysis (gated)
-    const llmEnabled = options.llm || !!process.env['OPENAI_API_KEY'];
+    const noLlm = options.noLlm || !!process.env['CI_TRIAGE_NO_LLM'];
+    const autoLlm = !noLlm && !!process.env['OPENAI_API_KEY'];
+    if (autoLlm && !options.llm && !noLlm) {
+        process.stderr.write('ℹ using LLM analysis (set CI_TRIAGE_NO_LLM=1 or pass --no-llm to disable)\n');
+    }
+    const llmEnabled = !noLlm && (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,
@@ -167,7 +477,8 @@ async function main() {
         }));
         const analysis = await analyzeLlm(failureEntries, rawLog, {
             model: options.llmModel,
-            enabled: true,
+            enabled: llmEnabled,
+            repoContext,
         });
         report.analysis = analysis;
     }
@@ -183,11 +494,32 @@ async function main() {
     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 ─────────────────────────────');
@@ -208,6 +540,8 @@ async function main() {
             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) {
@@ -215,7 +549,9 @@ async function main() {
         }
     }
 }
-main().catch((err) => {
-    console.error(err instanceof Error ? err.message : String(err));
-    process.exit(1);
-});
+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

@@ -10,13 +10,32 @@ 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) {
+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
-    return `You are a CI failure analyst. Given the following CI failures and log excerpt, provide:
+    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
 
@@ -40,7 +59,7 @@ export async function analyzeLlm(failures, logExcerpt, options = {}) {
     }
     const client = new OpenAI({ apiKey: process.env['OPENAI_API_KEY'] });
     try {
-        const prompt = buildPrompt(failures, logExcerpt);
+        const prompt = buildPrompt(failures, logExcerpt, options.repoContext ?? null);
         const response = await client.responses.create({
             model,
             input: prompt,

package/dist/multi.js

@@ -0,0 +1,116 @@
+function reportFailures(report) {
+    const failures = [];
+    for (const job of report.jobs) {
+        for (const step of job.steps ?? []) {
+            failures.push(...step.failures);
+        }
+    }
+    return failures;
+}
+function normalizeError(error) {
+    return error.replace(/\s+/g, ' ').trim();
+}
+export function detectSharedPatterns(reports) {
+    const byFixAction = new Map();
+    const byCategory = new Map();
+    const byErrorSubstring = new Map();
+    for (const report of reports) {
+        const failures = reportFailures(report);
+        const repoFixActions = new Set();
+        const repoCategories = new Set();
+        const repoErrorSubstrings = new Set();
+        for (const failure of failures) {
+            repoFixActions.add(failure.fix_action ?? 'unknown');
+            repoCategories.add(failure.category);
+            const normalized = normalizeError(failure.error);
+            if (normalized.length > 20) {
+                repoErrorSubstrings.add(normalized.slice(0, 120));
+            }
+        }
+        for (const action of repoFixActions) {
+            const repos = byFixAction.get(action) ?? new Set();
+            repos.add(report.repo);
+            byFixAction.set(action, repos);
+        }
+        for (const category of repoCategories) {
+            const repos = byCategory.get(category) ?? new Set();
+            repos.add(report.repo);
+            byCategory.set(category, repos);
+        }
+        for (const substring of repoErrorSubstrings) {
+            const repos = byErrorSubstring.get(substring) ?? new Set();
+            repos.add(report.repo);
+            byErrorSubstring.set(substring, repos);
+        }
+    }
+    const patterns = [];
+    for (const [fix_action, repos] of byFixAction) {
+        if (repos.size >= 2) {
+            patterns.push({
+                fix_action,
+                repos: [...repos].sort(),
+                description: `Common fix action across repos: ${fix_action}`,
+            });
+        }
+    }
+    for (const [category, repos] of byCategory) {
+        if (repos.size >= 2) {
+            patterns.push({
+                category,
+                repos: [...repos].sort(),
+                description: `Common category across repos: ${category}`,
+            });
+        }
+    }
+    for (const [error_substring, repos] of byErrorSubstring) {
+        if (repos.size >= 2) {
+            patterns.push({
+                error_substring,
+                repos: [...repos].sort(),
+                description: `Common error text across repos: ${error_substring}`,
+            });
+        }
+    }
+    return patterns;
+}
+export function formatMultiSummary(reports, patterns) {
+    const lines = [`Multi-repo triage: ${reports.length} repos`, ''];
+    if (patterns.length === 0) {
+        lines.push('Shared patterns detected: none', '');
+    }
+    else {
+        lines.push('Shared patterns detected:');
+        for (const pattern of patterns) {
+            const repos = pattern.repos.map((repo) => repo.split('/').at(-1) ?? repo).join(', ');
+            if (pattern.fix_action) {
+                lines.push(`  [${pattern.fix_action}] ${pattern.repos.length} repos affected: ${repos}`);
+            }
+            else if (pattern.category) {
+                lines.push(`  [${pattern.category}] ${pattern.repos.length} repos affected: ${repos}`);
+            }
+            else if (pattern.error_substring) {
+                lines.push(`  [error] ${pattern.repos.length} repos affected: ${repos}`);
+            }
+            lines.push(`    -> ${pattern.description}`);
+        }
+        lines.push('');
+    }
+    lines.push('Per-repo:');
+    for (const report of reports) {
+        const failures = reportFailures(report);
+        const actionCounts = new Map();
+        for (const failure of failures) {
+            const action = failure.fix_action ?? 'unknown';
+            actionCounts.set(action, (actionCounts.get(action) ?? 0) + 1);
+        }
+        const actionSummary = [...actionCounts.entries()]
+            .sort((a, b) => b[1] - a[1])
+            .map(([action, count]) => `${action} x${count}`)
+            .join(', ');
+        lines.push(`  ${report.repo} - ${failures.length} failures${actionSummary ? ` (${actionSummary})` : ''}`);
+    }
+    return `${lines.join('\n')}\n`;
+}
+export function buildMultiJson(reports, patterns) {
+    return `${JSON.stringify({ repos: reports, patterns }, null, 2)}\n`;
+}