@aifabrix/builder 2.43.0 → 2.44.1

package/lib/utils/datasource-test-run-certificate-tty.js

@@ -0,0 +1,82 @@
+/**
+ * @fileoverview Certificate / certification tier lines for DatasourceTestRun TTY output.
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const { sectionTitle } = require('./cli-test-layout-chalk');
+
+function trimCertificateField(v) {
+  if (v === undefined || v === null) return '';
+  return String(v).trim();
+}
+
+function certificateEnvelopeGlyph(statusRaw) {
+  if (statusRaw === 'passed') return '✔';
+  if (statusRaw === 'not_passed') return '✖';
+  return statusRaw ? '⚠' : ' ';
+}
+
+function certificateTTYHasContent(levelRaw, stRaw, summaryRaw, blockerCount) {
+  return Boolean(levelRaw || stRaw || summaryRaw || blockerCount > 0);
+}
+
+/**
+ * @param {string[]} lines
+ * @param {string} stRaw
+ * @param {string} levelRaw
+ * @param {string} summaryRaw
+ */
+function appendCertificateStatusAndSummaryLines(lines, stRaw, levelRaw, summaryRaw) {
+  if (stRaw || levelRaw) {
+    const cg = certificateEnvelopeGlyph(stRaw);
+    const tier = levelRaw ? ` — tier ${levelRaw}` : '';
+    lines.push(chalk.white(`  ${cg} ${stRaw || 'unknown'}${tier}`));
+  }
+  if (summaryRaw) {
+    lines.push(chalk.gray(`  ${summaryRaw}`));
+  }
+}
+
+/**
+ * @param {string[]} lines
+ * @param {Object[]} blockers
+ * @param {number} maxVisible
+ */
+function appendCertificateBlockerLines(lines, blockers, maxVisible) {
+  const cap = Math.min(maxVisible, blockers.length);
+  for (let i = 0; i < cap; i += 1) {
+    const b = blockers[i];
+    const msg = b && b.message ? String(b.message) : '';
+    if (msg) lines.push(chalk.yellow(`  • ${msg}`));
+  }
+  if (blockers.length > cap) {
+    lines.push(chalk.gray(`  … and ${blockers.length - cap} more`));
+  }
+}
+
+/**
+ * Certification / certificate tier (integration engine or E2E envelope after active cert attach).
+ * @param {string[]} lines
+ * @param {Object} envelope
+ */
+function appendCertificateTTY(lines, envelope) {
+  const cert = envelope && envelope.certificate;
+  if (!cert || typeof cert !== 'object') return;
+  const levelRaw = trimCertificateField(cert.level);
+  const stRaw = trimCertificateField(cert.status);
+  const summaryRaw = trimCertificateField(cert.summary);
+  const blockers = Array.isArray(cert.blockers) ? cert.blockers : [];
+  if (!certificateTTYHasContent(levelRaw, stRaw, summaryRaw, blockers.length)) return;
+  lines.push('');
+  lines.push(sectionTitle('Certification:'));
+  appendCertificateStatusAndSummaryLines(lines, stRaw, levelRaw, summaryRaw);
+  appendCertificateBlockerLines(lines, blockers, 5);
+}
+
+module.exports = {
+  appendCertificateTTY
+};

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 };