@aifabrix/builder 2.42.1 → 2.44.0

package/lib/utils/datasource-test-run-debug-display.js

@@ -0,0 +1,137 @@
+/**
+ * @fileoverview Debug / audit TTY appendix for DatasourceTestRun (plan §3.7).
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { SEP, appendReferenceLayoutLines } = require('./datasource-test-run-display');
+const { buildDebugEnvelopeSlice } = require('./datasource-test-run-debug-slice');
+
+const FULL_MAX_BYTES_PER_STRING = 8192;
+const RAW_MAX_STRING_TTY = 65536;
+const RAW_MAX_STRING_PIPE = 1024 * 1024;
+const RAW_MAX_LINES = 200;
+
+/**
+ * @param {*} debugOpt - Commander value: undefined, false, true, or level string
+ * @returns {null|'summary'|'full'|'raw'}
+ */
+function resolveDebugDisplayMode(debugOpt) {
+  if (debugOpt === undefined || debugOpt === false) return null;
+  if (debugOpt === true) return 'summary';
+  const s = String(debugOpt).trim().toLowerCase();
+  if (s === 'summary' || s === 'full' || s === 'raw') return s;
+  return 'summary';
+}
+
+/**
+ * @param {string} str
+ * @param {number} maxBytes
+ * @returns {string}
+ */
+function truncateUtf8String(str, maxBytes) {
+  if (str === null || str === undefined) return '';
+  const s = String(str);
+  if (Buffer.byteLength(s, 'utf8') <= maxBytes) return s;
+  let end = s.length;
+  while (end > 0 && Buffer.byteLength(s.slice(0, end), 'utf8') > maxBytes) {
+    end -= 1;
+  }
+  const prefix = s.slice(0, end);
+  const omitted = Buffer.byteLength(s, 'utf8') - Buffer.byteLength(prefix, 'utf8');
+  return `${prefix} … [truncated, ${omitted} bytes]`;
+}
+
+/**
+ * @param {*} value
+ * @param {number} maxBytesPerString
+ * @param {number} depth
+ * @returns {*}
+ */
+function deepTruncateStrings(value, maxBytesPerString, depth) {
+  if (depth <= 0) return '[…]';
+  if (value === null || typeof value === 'boolean' || typeof value === 'number') return value;
+  if (typeof value === 'string') return truncateUtf8String(value, maxBytesPerString);
+  if (Array.isArray(value)) return value.map(v => deepTruncateStrings(v, maxBytesPerString, depth - 1));
+  if (typeof value === 'object') {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = deepTruncateStrings(v, maxBytesPerString, depth - 1);
+    }
+    return out;
+  }
+  return value;
+}
+
+/**
+ * @param {string} text
+ * @returns {string}
+ */
+function redactDebugText(text) {
+  return String(text)
+    .replace(/Bearer\s+\S+/gi, 'Bearer [REDACTED]')
+    .replace(/("Authorization"\s*:\s*")[^"]*(")/gi, '$1[REDACTED]$2')
+    .replace(/("authorization"\s*:\s*")[^"]*(")/g, '$1[REDACTED]$2');
+}
+
+function pushSummaryRefLines(lines, envelope) {
+  const before = lines.length;
+  appendReferenceLayoutLines(lines, envelope, { maxRefChars: 600 });
+  if (lines.length === before) {
+    lines.push('(No audit or debug references on this report.)');
+  }
+}
+
+/**
+ * Rich JSON appendix for full/raw debug (validation, integration, certificate, capabilities).
+ * @param {Object} envelope
+ * @param {number} maxStr
+ * @returns {string}
+ */
+function stringifyDebugSlice(envelope, maxStr) {
+  const slice = buildDebugEnvelopeSlice(envelope);
+  return JSON.stringify(deepTruncateStrings(slice, maxStr, 16), null, 2);
+}
+
+function applyRawLineCap(text) {
+  let t = redactDebugText(text);
+  const ls = t.split('\n');
+  if (ls.length > RAW_MAX_LINES) {
+    const omitted = ls.length - RAW_MAX_LINES;
+    t = `${ls.slice(0, RAW_MAX_LINES).join('\n')}\n… [${omitted} lines omitted; use audit ref]`;
+  }
+  return t;
+}
+
+/**
+ * Human appendix after main TTY/summary (not used for --json).
+ * @param {Object|null} envelope
+ * @param {'summary'|'full'|'raw'} mode
+ * @param {boolean} isTTY
+ * @returns {string}
+ */
+function formatDatasourceTestRunDebugBlock(envelope, mode, isTTY) {
+  if (!envelope || typeof envelope !== 'object') return '';
+
+  const lines = ['', SEP, `Debug (${mode})`];
+
+  if (mode === 'summary') {
+    pushSummaryRefLines(lines, envelope);
+    return lines.join('\n');
+  }
+
+  const maxStr = mode === 'full' ? FULL_MAX_BYTES_PER_STRING : isTTY ? RAW_MAX_STRING_TTY : RAW_MAX_STRING_PIPE;
+  const text = mode === 'raw' ? applyRawLineCap(stringifyDebugSlice(envelope, maxStr)) : stringifyDebugSlice(envelope, maxStr);
+  lines.push(text);
+  return lines.join('\n');
+}
+
+module.exports = {
+  resolveDebugDisplayMode,
+  truncateUtf8String,
+  formatDatasourceTestRunDebugBlock,
+  FULL_MAX_BYTES_PER_STRING,
+  RAW_MAX_STRING_TTY,
+  RAW_MAX_STRING_PIPE,
+  RAW_MAX_LINES
+};

package/lib/utils/datasource-test-run-debug-slice.js

@@ -0,0 +1,93 @@
+/**
+ * @fileoverview Compact slice of DatasourceTestRun for debug JSON output (full/raw modes).
+ */
+
+'use strict';
+
+/**
+ * @param {Object|undefined|null} v
+ * @returns {Object|undefined}
+ */
+function sliceValidationLayer(v) {
+  if (!v || typeof v !== 'object') return undefined;
+  return {
+    status: v.status,
+    summary: v.summary,
+    dataReadiness: v.dataReadiness,
+    metricsOutput: v.metricsOutput,
+    issues: Array.isArray(v.issues) ? v.issues.slice(0, 50) : undefined
+  };
+}
+
+/**
+ * @param {Object|undefined|null} integ
+ * @returns {Object|undefined}
+ */
+function sliceIntegration(integ) {
+  if (!integ || typeof integ !== 'object') return undefined;
+  return {
+    status: integ.status,
+    summary: integ.summary,
+    stepResults: integ.stepResults
+  };
+}
+
+/**
+ * @param {Object|undefined|null} cert
+ * @returns {Object|undefined}
+ */
+function sliceCertificate(cert) {
+  if (!cert || typeof cert !== 'object') return undefined;
+  return {
+    status: cert.status,
+    level: cert.level,
+    summary: cert.summary,
+    blockers: Array.isArray(cert.blockers) ? cert.blockers.slice(0, 30) : undefined
+  };
+}
+
+/**
+ * @param {Object|undefined|null} e2e
+ * @returns {Object|undefined}
+ */
+function sliceCapabilityE2e(e2e) {
+  if (!e2e || typeof e2e !== 'object') return undefined;
+  return {
+    status: e2e.status,
+    strategy: e2e.strategy,
+    steps: e2e.steps
+  };
+}
+
+/**
+ * @param {Array|undefined|null} capabilities
+ * @returns {Array|undefined}
+ */
+function sliceCapabilities(capabilities) {
+  if (!Array.isArray(capabilities) || capabilities.length === 0) return undefined;
+  return capabilities.map(c => ({
+    key: c.key,
+    status: c.status,
+    permission: c.permission,
+    e2e: sliceCapabilityE2e(c.e2e)
+  }));
+}
+
+/**
+ * @param {Object} envelope
+ * @returns {Object}
+ */
+function buildDebugEnvelopeSlice(envelope) {
+  return {
+    audit: envelope.audit,
+    debug: envelope.debug,
+    developer: envelope.developer,
+    validation: sliceValidationLayer(envelope.validation),
+    integration: sliceIntegration(envelope.integration),
+    certificate: sliceCertificate(envelope.certificate),
+    capabilitySummary: envelope.capabilitySummary,
+    capabilities: sliceCapabilities(envelope.capabilities)
+  };
+}
+
+module.exports = { buildDebugEnvelopeSlice };

package/lib/utils/datasource-test-run-display.js

@@ -0,0 +1,442 @@
+/**
+ * @fileoverview Minimal human TTY + --summary for DatasourceTestRun (plan §3.2 / §16.9 subset).
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const chalk = require('chalk');
+const { sectionTitle, headerKeyValue, colorAggregateGlyph, successGlyph, failureGlyph } = require('./cli-test-layout-chalk');
+
+const SEP = '────────────────────────────────';
+
+/** @type {number} */
+const DEFAULT_MAX_REF_CHARS = 200;
+
+/**
+ * @param {'ok'|'warn'|'fail'|'skipped'} status
+ * @returns {string}
+ */
+function statusGlyph(status) {
+  if (status === 'ok') return '✔';
+  if (status === 'warn') return '⚠';
+  if (status === 'fail') return '✖';
+  if (status === 'skipped') return '⏭';
+  return '?';
+}
+
+/**
+ * Map API status string to aggregate bucket for colors.
+ * @param {*} status
+ * @returns {'ok'|'warn'|'fail'|'skipped'|null} null = unknown / other
+ */
+function envelopeStatusAggregate(status) {
+  const s = String(status || '').toLowerCase();
+  if (s === 'warn') return 'warn';
+  if (s === 'fail') return 'fail';
+  if (s === 'skipped' || s === 'skip') return 'skipped';
+  if (s === 'ok') return 'ok';
+  return null;
+}
+
+/**
+ * @param {*} status
+ * @param {string} rawWord - as returned by API (e.g. ok, warn)
+ * @returns {string}
+ */
+function colorStatusWord(status, rawWord) {
+  const agg = envelopeStatusAggregate(status);
+  const w = String(rawWord);
+  if (!agg) return chalk.gray(w);
+  if (agg === 'ok') return chalk.green(w);
+  if (agg === 'warn') return chalk.yellow(w);
+  if (agg === 'fail') return chalk.red(w);
+  return chalk.gray(w);
+}
+
+/**
+ * Colored glyph for status (neutral when unknown).
+ * @param {*} status
+ * @returns {string}
+ */
+function colorStatusGlyph(status) {
+  const agg = envelopeStatusAggregate(status);
+  const glyph = statusGlyph(status);
+  return agg ? colorAggregateGlyph(agg, glyph) : chalk.gray(glyph);
+}
+
+/**
+ * `Status: ✔ ok` with layout-aligned colors (preserves raw status text).
+ * @param {Object} envelope
+ * @returns {string}
+ */
+function formatEnvelopeStatusLine(envelope) {
+  const raw = envelope.status !== undefined && envelope.status !== null ? String(envelope.status) : 'unknown';
+  const g = colorStatusGlyph(envelope.status);
+  return `${chalk.gray('Status:')} ${g} ${colorStatusWord(envelope.status, raw)}`;
+}
+
+/**
+ * @param {boolean} ok
+ * @param {string} body - step name + optional tail
+ * @returns {string}
+ */
+function colorStepLine(ok, body) {
+  const sym = ok ? successGlyph() : failureGlyph();
+  return `  ${sym} ${chalk.white(body)}`;
+}
+
+/**
+ * Normalize CLI --capability value for matching envelope.capabilities[].key
+ * @param {*} focusCapabilityKey
+ * @returns {string} trimmed or ''
+ */
+function normalizedFocusCapabilityKey(focusCapabilityKey) {
+  if (focusCapabilityKey === undefined || focusCapabilityKey === null) return '';
+  const s = String(focusCapabilityKey).trim();
+  return s;
+}
+
+/**
+ * @param {string[]} lines
+ * @param {Object|null|undefined} e2e
+ */
+function pushCapabilityE2eLines(lines, e2e) {
+  if (!e2e || typeof e2e !== 'object') return;
+  if (e2e.status) {
+    const g = colorStatusGlyph(e2e.status);
+    lines.push(`${chalk.gray('E2E:')} ${g} ${colorStatusWord(e2e.status, e2e.status)}`);
+  }
+  const esteps = Array.isArray(e2e.steps) ? e2e.steps : [];
+  for (const st of esteps) {
+    const nm = st.name || st.step || 'step';
+    const ok = st.success !== false && !st.error;
+    const tail = st.error || st.message ? `: ${st.error || st.message}` : '';
+    lines.push(colorStepLine(ok, `${nm}${tail}`));
+  }
+}
+
+/**
+ * Multi-line TTY block for a single capability row (plan §2.3 drill-down).
+ * @param {Object|null|undefined} envelope
+ * @param {string} focusKey - non-empty
+ * @returns {string}
+ */
+function formatCapabilityFocusSection(envelope, focusKey) {
+  if (!focusKey) return '';
+  const lines = ['', chalk.gray(SEP), sectionTitle(`Capability scope: ${focusKey}`)];
+  const caps =
+    envelope && typeof envelope === 'object' && Array.isArray(envelope.capabilities)
+      ? envelope.capabilities
+      : [];
+  const cap = caps.find(c => c && String(c.key) === focusKey);
+  if (!cap) {
+    lines.push(chalk.yellow(`(No row with key "${focusKey}" in capabilities[])`));
+    return lines.join('\n');
+  }
+  lines.push(formatEnvelopeStatusLine(cap));
+  if (cap.permission) {
+    lines.push(headerKeyValue('Permission:', String(cap.permission)));
+  }
+  pushCapabilityE2eLines(lines, cap.e2e);
+  return lines.join('\n');
+}
+
+/**
+ * @param {Object} envelope
+ * @returns {string[]}
+ */
+function buildTtyMetaLines(envelope) {
+  const lines = [];
+  lines.push(
+    headerKeyValue('Datasource:', `${envelope.datasourceKey} (${envelope.systemKey})`)
+  );
+  lines.push(headerKeyValue('Run:', String(envelope.runType)));
+  lines.push(formatEnvelopeStatusLine(envelope));
+  const rid = envelope.runId || envelope.testRunId;
+  if (rid) lines.push(`${chalk.gray('Run ID:')} ${chalk.cyan(String(rid))}`);
+  if (envelope.reportCompleteness && envelope.reportCompleteness !== 'full') {
+    lines.push(
+      `${chalk.gray('Report:')} ${chalk.yellow(String(envelope.reportCompleteness))}`
+    );
+  }
+  return lines;
+}
+
+/**
+ * @param {*} val
+ * @returns {string[]}
+ */
+function normalizeRefArray(val) {
+  if (val === null || val === undefined) return [];
+  return Array.isArray(val) ? val : [val];
+}
+
+/**
+ * @param {string} str
+ * @param {number} maxChars
+ * @returns {string}
+ */
+function truncateRefLine(str, maxChars) {
+  const s = String(str);
+  if (s.length <= maxChars) return s;
+  return `${s.slice(0, Math.max(0, maxChars - 24))}… [+${s.length - maxChars + 24} chars]`;
+}
+
+/**
+ * @param {string[]} lines
+ * @param {string} title
+ * @param {*} arr
+ * @param {number} maxRefChars
+ * @returns {boolean}
+ */
+function appendStringRefBlock(lines, title, arr, maxRefChars) {
+  const entries = normalizeRefArray(arr).map(String);
+  if (!entries.length) return false;
+  lines.push(chalk.blue.bold(String(title)));
+  entries.forEach((text, i) => {
+    lines.push(`  ${chalk.gray(`[${i + 1}]`)} ${chalk.white(truncateRefLine(text, maxRefChars))}`);
+  });
+  return true;
+}
+
+/**
+ * @param {string[]} lines
+ * @param {Object|null|undefined} dbg
+ * @param {number} maxRefChars
+ * @returns {boolean}
+ */
+function appendDebugPayloadRefLines(lines, dbg, maxRefChars) {
+  const payloadRefs = dbg && typeof dbg === 'object' ? normalizeRefArray(dbg.payloadRefs) : [];
+  if (!payloadRefs.length) return false;
+  lines.push(chalk.blue.bold('debug.payloadRefs:'));
+  payloadRefs.forEach((pr, i) => {
+    const idx = chalk.gray(`[${i + 1}]`);
+    if (typeof pr === 'string') {
+      lines.push(`  ${idx} ${chalk.white(truncateRefLine(pr, maxRefChars))}`);
+      return;
+    }
+    if (pr && typeof pr === 'object') {
+      const k = pr.key !== undefined && pr.key !== null ? String(pr.key) : 'payload';
+      const r = pr.ref !== undefined && pr.ref !== null ? String(pr.ref) : '';
+      const row = r ? `${k}: ${r}` : k;
+      lines.push(`  ${idx} ${chalk.white(truncateRefLine(row, maxRefChars))}`);
+      return;
+    }
+    lines.push(`  ${idx} ${chalk.gray('(ref)')}`);
+  });
+  return true;
+}
+
+/**
+ * @param {string[]} lines
+ * @param {Object} dbg
+ * @param {number} maxRefChars
+ * @returns {boolean}
+ */
+function appendDebugMetaLines(lines, dbg, maxRefChars) {
+  let added = false;
+  if (dbg.mode) {
+    lines.push(
+      `${chalk.blue.bold('debug.mode:')} ${chalk.white(String(dbg.mode))}`
+    );
+    added = true;
+  }
+  if (dbg.executionSummary) {
+    lines.push(
+      `${chalk.blue.bold('debug.executionSummary:')} ${chalk.white(
+        truncateRefLine(String(dbg.executionSummary), maxRefChars)
+      )}`
+    );
+    added = true;
+  }
+  return added;
+}
+
+/**
+ * Append audit + debug reference layout (OpenAPI AuditRefs, DebugTrace.payloadRefs).
+ * @param {string[]} lines
+ * @param {Object} envelope
+ * @param {{ maxRefChars?: number }} [opts]
+ * @returns {boolean} True if any reference line was added
+ */
+function appendReferenceLayoutLines(lines, envelope, opts = {}) {
+  const maxRefChars = opts.maxRefChars ?? DEFAULT_MAX_REF_CHARS;
+  const audit = envelope && envelope.audit;
+  const dbg = envelope && envelope.debug;
+  const parts = [];
+
+  if (audit && typeof audit === 'object') {
+    parts.push(appendStringRefBlock(lines, 'audit.executionIds:', audit.executionIds, maxRefChars));
+    parts.push(appendStringRefBlock(lines, 'audit.traceRefs:', audit.traceRefs, maxRefChars));
+    parts.push(appendStringRefBlock(lines, 'audit.rbacTraceRefs:', audit.rbacTraceRefs, maxRefChars));
+    parts.push(appendStringRefBlock(lines, 'audit.abacTraceRefs:', audit.abacTraceRefs, maxRefChars));
+  }
+
+  parts.push(appendDebugPayloadRefLines(lines, dbg, maxRefChars));
+
+  if (dbg && typeof dbg === 'object') {
+    parts.push(appendStringRefBlock(lines, 'debug.executionIds:', dbg.executionIds, maxRefChars));
+    parts.push(appendDebugMetaLines(lines, dbg, maxRefChars));
+  }
+
+  return parts.some(Boolean);
+}
+
+/**
+ * @param {string[]} lines
+ * @param {Object} envelope
+ * @param {number} [maxIssues]
+ */
+function appendValidationIssueLines(lines, envelope, maxIssues = 5) {
+  const issues = envelope && envelope.validation && Array.isArray(envelope.validation.issues) ? envelope.validation.issues : [];
+  if (!issues.length) return;
+  lines.push(sectionTitle('Validation issues:'));
+  const cap = Math.min(maxIssues, issues.length);
+  for (let i = 0; i < cap; i += 1) {
+    const iss = issues[i];
+    const code = iss && iss.code ? chalk.red(`[${iss.code}] `) : '';
+    const msg = iss && iss.message ? String(iss.message) : JSON.stringify(iss);
+    lines.push(`  ${code}${chalk.yellow(msg)}`);
+  }
+  if (issues.length > cap) {
+    lines.push(chalk.gray(`  … and ${issues.length - cap} more (see --json or debug full/raw)`));
+  }
+}
+
+/**
+ * @param {string[]} lines
+ * @param {Object} envelope
+ */
+function formatIntegrationStepLine(st) {
+  const nm = (st && (st.name || st.step)) || 'step';
+  const ok = st && st.success !== false && !st.error;
+  const detail = st && (st.message || st.error) ? `: ${st.message || st.error}` : '';
+  return colorStepLine(ok, `${nm}${detail}`);
+}
+
+function appendIntegrationStepLines(lines, envelope) {
+  const integ = envelope && envelope.integration;
+  const steps = integ && Array.isArray(integ.stepResults) ? integ.stepResults : [];
+  if (!steps.length) return;
+  lines.push(sectionTitle('Integration steps:'));
+  for (const st of steps) {
+    lines.push(formatIntegrationStepLine(st));
+  }
+}
+
+function pickExecutiveVerdictLine(envelope) {
+  const dev = envelope.developer;
+  return (
+    (dev && dev.executiveSummary) ||
+    (envelope.certificate && envelope.certificate.summary) ||
+    (envelope.validation && envelope.validation.summary) ||
+    (envelope.integration && envelope.integration.summary) ||
+    `Run finished with status ${envelope.status}.`
+  );
+}
+
+/**
+ * Plan §3.9: explicit line when E2E has no capability rows (skipped when --capability drill-down is active).
+ * @param {string[]} lines
+ * @param {Object} envelope
+ * @param {{ focusCapabilityKey?: string }} [options]
+ */
+function appendNoCapabilitiesReportedLine(lines, envelope, options = {}) {
+  if (envelope.runType !== 'e2e') return;
+  if (normalizedFocusCapabilityKey(options.focusCapabilityKey)) return;
+  const caps = envelope.capabilities;
+  if (Array.isArray(caps) && caps.length > 0) return;
+  lines.push(chalk.gray('No capabilities reported.'));
+}
+
+/**
+ * @param {string[]} parts
+ * @param {Object} envelope
+ * @param {string} focus - normalized or ''
+ */
+function appendCapabilitySummaryPart(parts, envelope, focus) {
+  if (focus) {
+    const caps = Array.isArray(envelope.capabilities) ? envelope.capabilities : [];
+    const row = caps.find(c => c && String(c.key) === focus);
+    parts.push(
+      row ? `Cap ${focus}: ${statusGlyph(row.status)} ${row.status}` : `Cap ${focus}: (missing)`
+    );
+    return;
+  }
+  const capSummary = envelope.capabilitySummary;
+  if (capSummary && typeof capSummary === 'object') {
+    const passed = capSummary.passedCount;
+    const total = capSummary.totalCount;
+    if (typeof passed === 'number' && typeof total === 'number') {
+      parts.push(`Capabilities: ${passed}/${total}`);
+    }
+  }
+}
+
+/**
+ * @param {string[]} parts
+ * @param {Object} envelope
+ */
+function appendCertificateSummaryPart(parts, envelope) {
+  const cert = envelope.certificate;
+  if (!cert || typeof cert !== 'object') return;
+  const level =
+    cert.level !== undefined && cert.level !== null ? String(cert.level) : '';
+  const cg = cert.status === 'passed' ? '✔' : cert.status === 'not_passed' ? '✖' : '⚠';
+  if (level) parts.push(`Certificate: ${level} ${cg}`);
+}
+
+/**
+ * One-line summary (plan §16.9 normative field order subset).
+ * @param {Object} envelope
+ * @param {{ focusCapabilityKey?: string }} [options]
+ * @returns {string}
+ */
+function formatDatasourceTestRunSummary(envelope, options = {}) {
+  if (!envelope || typeof envelope !== 'object') return '';
+  const parts = [];
+  parts.push(String(envelope.datasourceKey || 'unknown'));
+  parts.push(`${statusGlyph(envelope.status)} ${(envelope.status || '').toUpperCase()}`);
+  const focus = normalizedFocusCapabilityKey(options.focusCapabilityKey);
+  appendCapabilitySummaryPart(parts, envelope, focus);
+  appendCertificateSummaryPart(parts, envelope);
+  return parts.join(' | ');
+}
+
+/**
+ * Default TTY block (header + verdict line + short summary + optional completeness).
+ * @param {Object} envelope
+ * @param {{ focusCapabilityKey?: string }} [options] - When set (e.g. --capability), append single-cap block (plan §2.3).
+ * @returns {string}
+ */
+function formatDatasourceTestRunTTY(envelope, options = {}) {
+  if (!envelope || typeof envelope !== 'object') return '';
+  const lines = [...buildTtyMetaLines(envelope)];
+  appendNoCapabilitiesReportedLine(lines, envelope, options);
+  lines.push('');
+  lines.push(sectionTitle('Verdict:'));
+  lines.push(chalk.white(pickExecutiveVerdictLine(envelope)));
+  lines.push('');
+  lines.push(chalk.gray(SEP));
+  if (appendReferenceLayoutLines(lines, envelope, { maxRefChars: 160 })) {
+    lines.push('');
+  }
+  appendValidationIssueLines(lines, envelope);
+  appendIntegrationStepLines(lines, envelope);
+  const focus = normalizedFocusCapabilityKey(options.focusCapabilityKey);
+  if (focus) {
+    lines.push(formatCapabilityFocusSection(envelope, focus));
+  }
+  return lines.join('\n');
+}
+
+module.exports = {
+  formatDatasourceTestRunSummary,
+  formatDatasourceTestRunTTY,
+  formatCapabilityFocusSection,
+  normalizedFocusCapabilityKey,
+  statusGlyph,
+  SEP,
+  appendReferenceLayoutLines,
+  normalizeRefArray
+};