checkly 0.0.0-canary.7166ed8

package/dist/formatters/check-result-detail.js

@@ -0,0 +1,651 @@
+import chalk from 'chalk';
+import { formatMs, formatDate, resolveResultStatus, heading, escapeMdCell, renderDetailFields, renderCommandHints, renderAdaptiveTable, truncateSingleLine, } from './render.js';
+// --- Helpers ---
+function label(text, width = 16) {
+    return chalk.dim(text.padEnd(width));
+}
+export function formatResultDetailWithNavigation(result, format, hints, extraSections = []) {
+    const output = [formatResultDetail(result, format)];
+    for (const section of extraSections) {
+        if (section) {
+            output.push('');
+            output.push(section);
+        }
+    }
+    if (hints.length > 0) {
+        output.push('');
+        output.push(renderCommandHints(hints));
+    }
+    return output.join('\n');
+}
+// --- Retry attempts ---
+// Picks the runs sharing a sequenceId out of a resultType=ALL page (there's no
+// server-side sequenceId filter), oldest-first so the index is the run number.
+export function groupAttemptsBySequence(results, sequenceId) {
+    return results
+        .filter(r => r.sequenceId === sequenceId)
+        .sort((a, b) => new Date(a.startedAt).getTime() - new Date(b.startedAt).getTime());
+}
+// Best-effort short error summary; list rows aren't hydrated with logs/assets,
+// so fall back to the status flags. Empty string means "no error detail".
+export function extractResultErrorSummary(result) {
+    const raw = firstErrorMessage(result);
+    if (raw)
+        return raw;
+    if (result.hasErrors)
+        return 'error';
+    if (result.hasFailures)
+        return 'failed';
+    return '';
+}
+function firstErrorMessage(result) {
+    const api = result.apiCheckResult;
+    if (api?.requestError)
+        return api.requestError;
+    const browserErr = result.browserCheckResult?.errors?.find(Boolean);
+    if (browserErr)
+        return formatErrorEntry(browserErr);
+    const multiStepErr = result.multiStepCheckResult?.errors?.find(Boolean);
+    if (multiStepErr)
+        return formatErrorEntry(multiStepErr);
+    const agenticErr = result.agenticCheckResult?.errors
+        ?.map(e => e?.error?.message ?? '')
+        .find(m => m.length > 0);
+    if (agenticErr)
+        return agenticErr;
+    return '';
+}
+// Renders the retry table for a sequence; `attempts` must be oldest-first.
+export function formatAttemptsSection(attempts, format, context = {}) {
+    if (attempts.length === 0)
+        return '';
+    const rows = attempts.map((result, i) => ({
+        result,
+        runNumber: i + 1,
+        isFinal: result.resultType === 'FINAL' || result.id === context.finalId,
+        isRequested: result.id === context.requestedId,
+    }));
+    const columns = buildAttemptColumns(format);
+    const table = renderAdaptiveTable(columns, rows, format);
+    return format === 'md'
+        ? '## Attempts\n\n' + table
+        : chalk.bold('ATTEMPTS') + '\n' + table;
+}
+function buildAttemptColumns(format) {
+    if (format === 'md') {
+        return [
+            { header: '#', value: row => row.isFinal ? `${row.runNumber} (FINAL)` : String(row.runNumber) },
+            { header: 'Status', value: (row, fmt) => resolveResultStatus(row.result, fmt) },
+            { header: 'Location', value: row => row.result.runLocation },
+            { header: 'Duration', value: row => formatMs(row.result.responseTime) },
+            { header: 'Error', value: row => mdErrorCell(row.result) },
+            { header: 'Result ID', value: row => row.result.id },
+        ];
+    }
+    return [
+        {
+            header: '#',
+            width: 14,
+            value: row => {
+                const marker = row.isFinal ? chalk.dim(' (FINAL)') : '';
+                const current = row.isRequested ? chalk.cyan(' ‹') : '';
+                return String(row.runNumber) + marker + current;
+            },
+        },
+        { header: 'Status', width: 10, value: (row, fmt) => resolveResultStatus(row.result, fmt) },
+        { header: 'Location', minWidth: 8, maxWidth: 16, value: row => row.result.runLocation },
+        { header: 'Duration', width: 10, value: row => formatMs(row.result.responseTime) },
+        {
+            header: 'Error',
+            minWidth: 12,
+            maxWidth: 50,
+            value: row => {
+                const msg = extractResultErrorSummary(row.result);
+                return msg ? chalk.red(truncateSingleLine(msg, 50)) : chalk.dim('—');
+            },
+        },
+        { header: 'Result ID', minWidth: 12, maxWidth: 38, value: row => chalk.dim(row.result.id) },
+    ];
+}
+function mdErrorCell(result) {
+    const msg = extractResultErrorSummary(result);
+    if (!msg)
+        return '—';
+    return escapeMdCell(truncateSingleLine(msg, 80));
+}
+// --- Top-level result detail fields ---
+export const resultDetailFields = [
+    { label: 'Status', value: (r, fmt) => resolveResultStatus(r, fmt) },
+    { label: 'Location', value: r => r.runLocation },
+    { label: 'Response time', value: r => formatMs(r.responseTime) },
+    { label: 'Started', value: (r, fmt) => fmt === 'md' ? (r.startedAt || '-') : formatDate(r.startedAt, fmt) },
+    { label: 'Stopped', value: (r, fmt) => fmt === 'md' ? (r.stoppedAt || '-') : formatDate(r.stoppedAt, fmt) },
+    { label: 'Attempts', value: r => String(r.attempts) },
+    { label: 'Result type', value: r => r.resultType },
+    { label: 'ID', value: r => r.id },
+];
+export function formatResultDetail(result, format) {
+    const parts = [renderDetailFields(result.name, resultDetailFields, result, format)];
+    if (result.apiCheckResult) {
+        const subLines = format === 'md'
+            ? formatApiResultMd(result.apiCheckResult)
+            : formatApiResultTerminal(result.apiCheckResult);
+        parts.push(subLines.join('\n'));
+    }
+    if (result.browserCheckResult) {
+        const subLines = format === 'md'
+            ? formatBrowserResultMd(result.browserCheckResult)
+            : formatBrowserResultTerminal(result.browserCheckResult);
+        parts.push(subLines.join('\n'));
+    }
+    if (result.multiStepCheckResult && format === 'terminal') {
+        parts.push(formatMultiStepResultTerminal(result.multiStepCheckResult).join('\n'));
+    }
+    if (result.agenticCheckResult) {
+        const subLines = format === 'md'
+            ? formatAgenticResultMd(result.agenticCheckResult)
+            : formatAgenticResultTerminal(result.agenticCheckResult);
+        parts.push(subLines.join('\n'));
+    }
+    return parts.join('\n\n');
+}
+// --- API check result (terminal) ---
+function formatApiResultTerminal(api) {
+    const lines = [];
+    lines.push(heading('REQUEST', 2, 'terminal'));
+    lines.push(`${label('Method:')}${api.request.method}`);
+    lines.push(`${label('URL:')}${api.request.url}`);
+    const reqHeaders = Object.entries(api.request.headers || {});
+    if (reqHeaders.length > 0) {
+        lines.push(`${label('Headers:')}`);
+        for (const [key, val] of reqHeaders) {
+            lines.push(`  ${chalk.dim(key + ':')} ${val}`);
+        }
+    }
+    if (api.request.data) {
+        lines.push(`${label('Body:')}`);
+        lines.push(formatBody(api.request.data, '  '));
+    }
+    lines.push('');
+    lines.push(heading('RESPONSE', 2, 'terminal'));
+    const reasonPhrase = (api.response.statusText || '').replace(/^\d+\s*/, '');
+    lines.push(`${label('Status:')}${colorStatus(api.response.status)} ${reasonPhrase}`);
+    const respHeaders = Object.entries(api.response.headers || {});
+    if (respHeaders.length > 0) {
+        lines.push(`${label('Headers:')}`);
+        for (const [key, val] of respHeaders) {
+            lines.push(`  ${chalk.dim(key + ':')} ${val}`);
+        }
+    }
+    if (api.response.body) {
+        lines.push(`${label('Body:')}`);
+        lines.push(formatBody(api.response.body, '  '));
+    }
+    if (api.response.timingPhases) {
+        lines.push('');
+        lines.push(heading('TIMING', 2, 'terminal'));
+        lines.push(formatTimingBar(api.response.timingPhases));
+    }
+    if (api.assertions && api.assertions.length > 0) {
+        lines.push('');
+        lines.push(heading('ASSERTIONS', 2, 'terminal'));
+        for (const a of api.assertions) {
+            const src = a.property ? `${a.source}.${a.property}` : a.source;
+            lines.push(`  ${chalk.dim('·')} ${src} ${a.comparison} ${a.target}`);
+        }
+    }
+    if (api.requestError) {
+        lines.push('');
+        lines.push(heading('ERROR', 2, 'terminal'));
+        lines.push(chalk.red(`  ${api.requestError}`));
+    }
+    if (api.jobLog) {
+        lines.push('');
+        lines.push(...formatJobLogObject(api.jobLog));
+    }
+    return lines;
+}
+// --- API check result (markdown) ---
+function formatApiResultMd(api) {
+    const lines = [];
+    lines.push('## Request');
+    lines.push(`\`${api.request.method} ${api.request.url}\``);
+    lines.push('');
+    lines.push('## Response');
+    const mdReason = (api.response.statusText || '').replace(/^\d+\s*/, '');
+    lines.push(`**${api.response.status} ${mdReason}**`);
+    if (api.response.body) {
+        lines.push('');
+        lines.push('```json');
+        lines.push(api.response.body.slice(0, 2000));
+        lines.push('```');
+    }
+    if (api.response.timingPhases) {
+        const tp = api.response.timingPhases;
+        lines.push('');
+        lines.push('## Timing');
+        lines.push('| Phase | Duration |');
+        lines.push('| --- | --- |');
+        lines.push(`| DNS | ${formatMs(tp.dns)} |`);
+        lines.push(`| TCP | ${formatMs(tp.tcp)} |`);
+        lines.push(`| TLS | ${formatMs(tp.wait)} |`);
+        lines.push(`| TTFB | ${formatMs(tp.firstByte)} |`);
+        lines.push(`| Download | ${formatMs(tp.download)} |`);
+        lines.push(`| **Total** | **${formatMs(tp.total)}** |`);
+    }
+    if (api.assertions && api.assertions.length > 0) {
+        lines.push('');
+        lines.push('## Assertions');
+        for (const a of api.assertions) {
+            const src = a.property ? `${a.source}.${a.property}` : a.source;
+            lines.push(`- ${src} ${a.comparison} ${a.target}`);
+        }
+    }
+    return lines;
+}
+// --- Browser check result (terminal) ---
+function formatBrowserResultTerminal(browser) {
+    const lines = [];
+    lines.push(heading('BROWSER RESULT', 2, 'terminal'));
+    lines.push(`${label('Framework:')}${browser.type}`);
+    lines.push(`${label('Runtime:')}${browser.runtimeVersion}`);
+    const ts = browser.traceSummary;
+    const errorCounts = ts
+        ? [
+            ts.userScriptErrors > 0 ? `${ts.userScriptErrors} script` : null,
+            ts.consoleErrors > 0 ? `${ts.consoleErrors} console` : null,
+            ts.networkErrors > 0 ? `${ts.networkErrors} network` : null,
+            ts.documentErrors > 0 ? `${ts.documentErrors} document` : null,
+        ].filter(Boolean)
+        : [];
+    if (errorCounts.length > 0) {
+        lines.push(`${label('Errors:')}${chalk.red(errorCounts.join(', '))}`);
+    }
+    else {
+        lines.push(`${label('Errors:')}${chalk.green('none')}`);
+    }
+    appendErrors(lines, browser.errors);
+    if (browser.pages && browser.pages.length > 0) {
+        const vitalLines = [];
+        for (const page of browser.pages) {
+            const pageLines = [];
+            const vitals = page.webVitals;
+            if (vitals) {
+                const entries = Object.entries(vitals);
+                for (const [name, v] of entries) {
+                    if (v && v.value != null) {
+                        pageLines.push(`  ${label(name + ':', 8)}${formatVitalValue(name, v)} ${vitalScore(v.score)}`);
+                    }
+                }
+            }
+            if (pageLines.length > 0) {
+                if (browser.pages.length > 1) {
+                    vitalLines.push(`  ${chalk.dim(page.url)}`);
+                }
+                vitalLines.push(...pageLines);
+            }
+        }
+        if (vitalLines.length > 0) {
+            lines.push('');
+            lines.push(heading('WEB VITALS', 2, 'terminal'));
+            lines.push(...vitalLines);
+        }
+    }
+    if (browser.jobLog && browser.jobLog.length > 0) {
+        lines.push('');
+        lines.push(...formatJobLogArray(browser.jobLog));
+    }
+    appendAssets(lines, browser);
+    return lines;
+}
+// --- Browser check result (markdown) ---
+function formatBrowserResultMd(browser) {
+    const lines = [];
+    lines.push(`## Browser Result (${browser.type})`);
+    if (browser.pages && browser.pages.length > 0) {
+        lines.push('');
+        lines.push('### Web Vitals');
+        lines.push('| Metric | Value | Score |');
+        lines.push('| --- | --- | --- |');
+        for (const page of browser.pages) {
+            if (page.webVitals) {
+                for (const [name, v] of Object.entries(page.webVitals)) {
+                    if (v && v.value != null) {
+                        lines.push(`| ${name} | ${formatVitalValue(name, v)} | ${v.score} |`);
+                    }
+                }
+            }
+        }
+    }
+    if (browser.errors.length > 0) {
+        lines.push('');
+        lines.push('### Errors');
+        for (const err of browser.errors) {
+            lines.push(`- ${formatErrorEntry(err)}`);
+        }
+    }
+    return lines;
+}
+// --- Multi-step check result (terminal only — markdown has no special multi-step section) ---
+function formatMultiStepResultTerminal(ms) {
+    const lines = [];
+    lines.push(heading('MULTI-STEP RESULT', 2, 'terminal'));
+    lines.push(`${label('Runtime:')}${ms.runtimeVersion}`);
+    appendErrors(lines, ms.errors);
+    if (ms.jobLog && ms.jobLog.length > 0) {
+        lines.push('');
+        lines.push(...formatJobLogArray(ms.jobLog));
+    }
+    appendAssets(lines, ms);
+    return lines;
+}
+// --- Agentic check result (terminal) ---
+function formatAgenticResultTerminal(agentic) {
+    const lines = [];
+    lines.push(heading('AGENTIC RESULT', 2, 'terminal'));
+    if (agentic.summary) {
+        lines.push(heading('SUMMARY', 2, 'terminal'));
+        lines.push(...wrapText(agentic.summary, '  ', 100));
+    }
+    if (agentic.assertions && agentic.assertions.length > 0) {
+        lines.push('');
+        lines.push(heading('ASSERTIONS', 2, 'terminal'));
+        for (const assertion of agentic.assertions) {
+            lines.push(formatAgenticAssertionTerminal(assertion));
+        }
+    }
+    if (agentic.errors && agentic.errors.length > 0) {
+        const messages = agentic.errors
+            .map(e => e?.error?.message ?? '')
+            .filter((m) => m.length > 0);
+        if (messages.length > 0) {
+            lines.push('', heading('ERRORS', 2, 'terminal'));
+            for (const msg of messages)
+                lines.push(chalk.red(`  ${msg}`));
+        }
+    }
+    if (agentic.steps && agentic.steps.length > 0) {
+        lines.push('');
+        lines.push(heading('STEPS', 2, 'terminal'));
+        lines.push(chalk.dim(`  ${agentic.steps.length} step${agentic.steps.length === 1 ? '' : 's'} recorded`));
+        const preview = agentic.steps.slice(0, 10);
+        for (const step of preview) {
+            lines.push(formatAgenticStepTerminal(step));
+        }
+        if (agentic.steps.length > preview.length) {
+            lines.push(chalk.dim(`  ... (${agentic.steps.length - preview.length} more step${agentic.steps.length - preview.length === 1 ? '' : 's'})`));
+        }
+    }
+    if (agentic.suggestions && agentic.suggestions.length > 0) {
+        lines.push('');
+        lines.push(heading('SUGGESTIONS', 2, 'terminal'));
+        for (const suggestion of agentic.suggestions) {
+            lines.push(...formatAgenticSuggestionTerminal(suggestion));
+        }
+    }
+    if (agentic.jobLog && Array.isArray(agentic.jobLog) && agentic.jobLog.length > 0) {
+        lines.push('');
+        lines.push(...formatJobLogArray(agentic.jobLog));
+    }
+    return lines;
+}
+function formatAgenticAssertionTerminal(assertion) {
+    const status = assertion.passed ? chalk.green('✓') : chalk.red('✗');
+    const condition = assertion.condition ?? '(no condition)';
+    const suffix = assertion.passed
+        ? ''
+        : chalk.dim(`  expected ${JSON.stringify(assertion.expected ?? '')}, got ${JSON.stringify(assertion.actual ?? '')}`);
+    return `  ${status} ${condition}${suffix}`;
+}
+function formatAgenticStepTerminal(step) {
+    const seq = step.sequenceNumber != null ? chalk.dim(String(step.sequenceNumber).padStart(3)) : chalk.dim('  ·');
+    if (step.type === 'tool_call') {
+        const name = step.name ?? '(tool)';
+        return `  ${seq} ${chalk.cyan('→')} ${name}`;
+    }
+    if (step.type === 'tool_result') {
+        const name = step.name ?? '(tool)';
+        return `  ${seq} ${chalk.dim('←')} ${chalk.dim(name)}`;
+    }
+    // 'message' type
+    const preview = truncateSingleLine(step.output ?? '', 100);
+    return `  ${seq} ${chalk.dim('•')} ${preview}`;
+}
+function formatAgenticSuggestionTerminal(suggestion) {
+    const lines = [];
+    const category = suggestion.category ? chalk.dim(`[${suggestion.category}]`) : '';
+    const summary = suggestion.summary ?? '(no summary)';
+    lines.push(`  ${chalk.yellow('◆')} ${summary} ${category}`.trimEnd());
+    if (suggestion.secrets && suggestion.secrets.length > 0) {
+        lines.push(chalk.dim(`     needs: ${suggestion.secrets.join(', ')}`));
+    }
+    return lines;
+}
+// --- Agentic check result (markdown) ---
+function formatAgenticResultMd(agentic) {
+    const lines = [];
+    lines.push('## Agentic Result');
+    if (agentic.summary) {
+        lines.push('');
+        lines.push('### Summary');
+        lines.push(agentic.summary);
+    }
+    if (agentic.assertions && agentic.assertions.length > 0) {
+        lines.push('');
+        lines.push('### Assertions');
+        lines.push('| Status | Condition | Expected | Actual |');
+        lines.push('| --- | --- | --- | --- |');
+        for (const assertion of agentic.assertions) {
+            const status = assertion.passed ? '✓' : '✗';
+            const condition = assertion.condition ?? '';
+            const expected = assertion.expected ?? '';
+            const actual = assertion.actual ?? '';
+            lines.push(`| ${status} | ${condition} | ${expected} | ${actual} |`);
+        }
+    }
+    if (agentic.errors && agentic.errors.length > 0) {
+        const messages = agentic.errors
+            .map(e => e?.error?.message ?? '')
+            .filter((m) => m.length > 0);
+        if (messages.length > 0) {
+            lines.push('');
+            lines.push('### Errors');
+            for (const msg of messages)
+                lines.push(`- ${msg}`);
+        }
+    }
+    if (agentic.suggestions && agentic.suggestions.length > 0) {
+        lines.push('');
+        lines.push('### Suggestions');
+        for (const suggestion of agentic.suggestions) {
+            const category = suggestion.category ? ` _(${suggestion.category})_` : '';
+            lines.push(`- **${suggestion.summary ?? '(no summary)'}**${category}`);
+            if (suggestion.prompt) {
+                lines.push(`  - Prompt fragment: \`${suggestion.prompt.replace(/\n/g, ' ')}\``);
+            }
+            if (suggestion.secrets && suggestion.secrets.length > 0) {
+                lines.push(`  - Needs secrets: ${suggestion.secrets.map(s => `\`${s}\``).join(', ')}`);
+            }
+        }
+    }
+    if (agentic.steps && agentic.steps.length > 0) {
+        lines.push('');
+        lines.push(`### Steps (${agentic.steps.length})`);
+        const preview = agentic.steps.slice(0, 20);
+        for (const step of preview) {
+            const seq = step.sequenceNumber != null ? `${step.sequenceNumber}. ` : '- ';
+            if (step.type === 'tool_call') {
+                lines.push(`${seq}→ \`${step.name ?? '(tool)'}\``);
+            }
+            else if (step.type === 'tool_result') {
+                lines.push(`${seq}← \`${step.name ?? '(tool)'}\``);
+            }
+            else {
+                lines.push(`${seq}• ${truncateSingleLine(step.output ?? '', 200)}`);
+            }
+        }
+        if (agentic.steps.length > preview.length) {
+            lines.push(`- _... ${agentic.steps.length - preview.length} more step(s)_`);
+        }
+    }
+    return lines;
+}
+// --- Shared internal helpers ---
+function colorStatus(code) {
+    if (code >= 200 && code < 300)
+        return chalk.green(String(code));
+    if (code >= 300 && code < 400)
+        return chalk.yellow(String(code));
+    return chalk.red(String(code));
+}
+function formatErrorEntry(err) {
+    if (typeof err === 'string')
+        return err;
+    if (err && typeof err === 'object') {
+        // API may return error objects with message/name fields
+        const obj = err;
+        if (obj.message)
+            return String(obj.message);
+        return JSON.stringify(err);
+    }
+    return String(err);
+}
+function appendErrors(lines, errors) {
+    if (errors.length === 0)
+        return;
+    lines.push('', heading('ERRORS', 2, 'terminal'));
+    for (const err of errors)
+        lines.push(chalk.red(`  ${formatErrorEntry(err)}`));
+}
+function appendAssets(lines, obj) {
+    const parts = [];
+    if (obj.jobAssets?.length)
+        parts.push(`${obj.jobAssets.length} screenshot(s)`);
+    if (obj.playwrightTestTraces?.length)
+        parts.push(`${obj.playwrightTestTraces.length} trace(s)`);
+    if (obj.playwrightTestVideos?.length)
+        parts.push(`${obj.playwrightTestVideos.length} video(s)`);
+    if (parts.length > 0) {
+        lines.push('', heading('ASSETS', 2, 'terminal'));
+        lines.push(`  ${parts.join(', ')}`);
+        lines.push(chalk.dim('  Use --output json to get asset URLs'));
+    }
+}
+function wrapText(text, indent, width) {
+    const lines = [];
+    for (const paragraph of text.split('\n')) {
+        if (paragraph.length === 0) {
+            lines.push(indent);
+            continue;
+        }
+        const words = paragraph.split(/\s+/);
+        let current = indent;
+        for (const word of words) {
+            if (current.length + word.length + 1 > width && current !== indent) {
+                lines.push(current);
+                current = indent + word;
+            }
+            else {
+                current += (current === indent ? '' : ' ') + word;
+            }
+        }
+        if (current !== indent)
+            lines.push(current);
+    }
+    return lines;
+}
+function formatBody(body, indent) {
+    let text;
+    try {
+        text = JSON.stringify(JSON.parse(body), null, 2);
+    }
+    catch {
+        text = body;
+    }
+    const lines = text.split('\n');
+    if (lines.length > 30) {
+        return lines.slice(0, 30).map(l => indent + l).join('\n')
+            + `\n${indent}${chalk.dim(`... (${lines.length - 30} more lines)`)}`;
+    }
+    return lines.map(l => indent + l).join('\n');
+}
+function formatTimingBar(tp) {
+    const phases = [
+        { name: 'DNS', ms: tp.dns, color: chalk.cyan },
+        { name: 'TCP', ms: tp.tcp, color: chalk.blue },
+        { name: 'TLS', ms: tp.wait, color: chalk.magenta },
+        { name: 'TTFB', ms: tp.firstByte, color: chalk.yellow },
+        { name: 'Download', ms: tp.download, color: chalk.green },
+    ];
+    const lines = [];
+    for (const phase of phases) {
+        if (phase.ms > 0) {
+            lines.push(`  ${label(phase.name + ':', 12)}${phase.color(formatMs(phase.ms))}`);
+        }
+    }
+    lines.push(`  ${label('Total:', 12)}${chalk.bold(formatMs(tp.total))}`);
+    return lines.join('\n');
+}
+function formatVitalValue(name, v) {
+    if (v.value == null)
+        return '-';
+    if (name === 'CLS')
+        return String(v.value.toFixed(3));
+    return formatMs(v.value);
+}
+function vitalScore(score) {
+    switch (score) {
+        case 'GOOD': return chalk.green('good');
+        case 'NEEDS_IMPROVEMENT': return chalk.yellow('needs improvement');
+        case 'POOR': return chalk.red('poor');
+        default: return chalk.dim(score);
+    }
+}
+// --- Job log formatting ---
+function formatJobLogArray(log) {
+    const lines = [heading('JOB LOG', 2, 'terminal')];
+    const maxLines = 50;
+    const entries = log.slice(0, maxLines);
+    for (const entry of entries) {
+        const level = entry.level === 'ERROR' ? chalk.red(entry.level) : chalk.dim(entry.level);
+        lines.push(`  ${level} ${entry.msg}`);
+    }
+    if (log.length > maxLines) {
+        lines.push(chalk.dim(`  ... (${log.length - maxLines} more entries)`));
+    }
+    return lines;
+}
+function formatJobLogObject(log) {
+    if (!log)
+        return [];
+    if (Array.isArray(log)) {
+        return formatJobLogArray(log);
+    }
+    if (typeof log === 'object' && log !== null) {
+        const obj = log;
+        const phases = ['setup', 'request', 'teardown'];
+        const allEntries = [];
+        for (const phase of phases) {
+            const entries = obj[phase];
+            if (Array.isArray(entries)) {
+                allEntries.push(...entries);
+            }
+        }
+        if (allEntries.length > 0) {
+            return formatJobLogArray(allEntries);
+        }
+    }
+    const lines = [heading('JOB LOG', 2, 'terminal')];
+    try {
+        const pretty = JSON.stringify(log, null, 2);
+        const jsonLines = pretty.split('\n').slice(0, 50);
+        for (const l of jsonLines) {
+            lines.push(`  ${l}`);
+        }
+    }
+    catch {
+        lines.push(`  ${String(log)}`);
+    }
+    return lines;
+}
+//# sourceMappingURL=check-result-detail.js.map