@aifabrix/builder 2.45.5 → 2.47.0

package/lib/lifecycle/report-display.js

@@ -0,0 +1,472 @@
+/**
+ * @fileoverview TTY display for Enterprise AI Certification verify + lifecycle commands.
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const {
+  sectionTitle,
+  formatSuccessParagraph,
+  formatBlockingError,
+  formatWarningLine,
+  successGlyph,
+  failureGlyph,
+  metadata: metaGray
+} = require('../utils/cli-test-layout-chalk');
+const {
+  VERDICT,
+  formatCertificationStatusDisplay,
+  actionHint,
+  formatRecommendationAction
+} = require('./product-model');
+const {
+  METRIC_KEYS,
+  OPERATIONS_METRIC_LABELS
+} = require('./operations-readiness-metrics');
+const { displayGovernanceVerboseDetails } = require('../governance/governance-run-display');
+const {
+  formatCertificationLevel,
+  formatCriterionCurrentHint,
+  resolveNextStepCommand,
+  formatProgressBar
+} = require('./certification-progress');
+const {
+  displaySubMetricLine,
+  displayTrustFindings,
+  displayTrustDatasourceRows
+} = require('./report-display-trust');
+
+const SEP = '────────────────────────';
+
+function displayPillarHeader(systemKey, pillarLabel) {
+  logger.log('');
+  logger.log(sectionTitle(`${String(systemKey).toUpperCase()} — ${pillarLabel}`));
+}
+
+function displayHeroMetric(label, percent) {
+  logger.log('');
+  logger.log(chalk.white(label));
+  if (typeof percent === 'number') {
+    logger.log(chalk.cyan.bold(`${percent}%`));
+  } else {
+    logger.log(chalk.gray('—'));
+  }
+  logger.log('');
+}
+
+function displayVerdictLine(verdict, verifiedLabel, failedLabel) {
+  if (verdict === VERDICT.VERIFIED) {
+    logger.log(formatSuccessParagraph(verifiedLabel));
+  } else {
+    logger.log(formatBlockingError(failedLabel));
+  }
+}
+
+/**
+ * @param {string} systemKey
+ * @param {Array<{ code: string, action?: string }>} warnings
+ */
+function displayPillarWarnings(systemKey, warnings) {
+  if (!warnings || warnings.length === 0) return;
+  logger.log('');
+  for (const w of warnings) {
+    const action = w.action || actionHint(systemKey, w.suggestedCommand || 'verify-trust');
+    logger.log(formatWarningLine(`${w.message || w.code}. Run: ${action}`));
+  }
+}
+
+/**
+ * @param {Record<string, number>|null} readinessMetrics
+ */
+function displayOperationsReadinessMetrics(readinessMetrics) {
+  if (!readinessMetrics || typeof readinessMetrics !== 'object') {
+    return;
+  }
+  logger.log('');
+  logger.log(chalk.white('Readiness breakdown'));
+  logger.log(chalk.gray(SEP));
+  for (const key of METRIC_KEYS) {
+    const label = OPERATIONS_METRIC_LABELS[key] || key;
+    const pct = readinessMetrics[key];
+    const value =
+      typeof pct === 'number' ? chalk.cyan.bold(`${pct}%`) : chalk.gray('—');
+    logger.log(`  ${label.padEnd(34)}${value}`);
+  }
+}
+
+/**
+ * @param {Record<string, Record<string, boolean>>} detailsGrouped
+ */
+function displayOperationsVerificationSteps(detailsGrouped) {
+  logger.log('');
+  logger.log(chalk.white('Verification steps'));
+  logger.log(chalk.gray(SEP));
+  const groups = [
+    ['Connectivity', ['credentials', 'authentication', 'authorization']],
+    ['Contracts', ['openApi', 'mappings']],
+    ['Runtime', ['sync', 'crud', 'execution']],
+    ['Reliability', ['validation', 'unitTests', 'integrationTests', 'e2eTests']]
+  ];
+  const labels = {
+    credentials: 'Credentials',
+    authentication: 'Authentication',
+    authorization: 'Authorization',
+    openApi: 'OpenAPI',
+    mappings: 'Mappings',
+    sync: 'Sync',
+    crud: 'CRUD',
+    execution: 'Execution',
+    validation: 'Validation',
+    unitTests: 'Unit Tests',
+    integrationTests: 'Integration Tests',
+    e2eTests: 'E2E Tests'
+  };
+  for (const [groupName, keys] of groups) {
+    logger.log(chalk.white(groupName));
+    for (const key of keys) {
+      const passed = detailsGrouped[groupName.toLowerCase()]?.[key] ?? detailsGrouped[key];
+      const glyph = passed ? successGlyph() : failureGlyph();
+      logger.log(`  ${labels[key] || key}`.padEnd(24) + glyph);
+    }
+  }
+}
+
+/**
+ * @param {string} systemKey
+ * @param {Object} result
+ * @param {{ details?: boolean, warnings?: Array }} opts
+ */
+function displayVerifyOperationsTTY(systemKey, result, opts = {}) {
+  displayPillarHeader(systemKey, 'OPERATIONS');
+  displayHeroMetric('Operational Readiness', result.operationalReadinessPercent);
+  displayVerdictLine(
+    result.verdict,
+    'OPERATIONS VERIFIED',
+    'OPERATIONS FAILED'
+  );
+  displayPillarWarnings(systemKey, result.warnings);
+  if (opts.details === true) {
+    displayOperationsReadinessMetrics(result.readinessMetrics);
+    if (result.details) {
+      displayOperationsVerificationSteps(result.details);
+    }
+  }
+}
+
+/**
+ * @param {string} systemKey
+ * @param {Object} result
+ * @param {{ details?: boolean }} opts
+ */
+function displayVerifyTrustTTY(systemKey, result, opts = {}) {
+  displayPillarHeader(systemKey, 'AI TRUST REPORT');
+  displayHeroMetric('Overall', result.aiTrustPercent);
+  logger.log('');
+  displaySubMetricLine('Access Confidence', result.accessConfidencePercent);
+  displaySubMetricLine('Business Confidence', result.businessConfidencePercent);
+  displayVerdictLine(result.verdict, 'AI TRUST VERIFIED', 'AI TRUST FAILED');
+  displayTrustFindings(result.findings);
+  if (opts.details === true) {
+    displayTrustDatasourceRows(result.datasourceRows);
+  }
+}
+
+/**
+ * @param {string} systemKey
+ * @param {Object} result
+ * @param {{ details?: boolean }} opts
+ */
+function displayVerifyGovernanceTTY(systemKey, result, opts = {}) {
+  displayPillarHeader(systemKey, 'GOVERNANCE');
+  displayHeroMetric('Policy Coverage', result.policyCoveragePercent);
+  logger.log(chalk.white('Dimension Coverage'));
+  logger.log(
+    typeof result.dimensionCoveragePercent === 'number'
+      ? chalk.cyan.bold(`${result.dimensionCoveragePercent}%`)
+      : chalk.gray('—')
+  );
+  logger.log('');
+  const scenarios = result.enforcementScenarios || {};
+  const total = scenarios.total || 0;
+  const passed = scenarios.passed || 0;
+  logger.log(chalk.white('Enforcement Scenarios'));
+  logger.log(chalk.cyan.bold(`${passed}/${total} Passed`));
+  logger.log('');
+  displayVerdictLine(result.verdict, 'GOVERNANCE VERIFIED', 'GOVERNANCE FAILED');
+  if (opts.details === true) {
+    displayGovernanceVerboseDetails(result);
+  }
+}
+
+function formatPillarLine(label, verdict) {
+  if (verdict === VERDICT.VERIFIED) {
+    return `${label.padEnd(24)}${successGlyph()} VERIFIED`;
+  }
+  if (verdict === VERDICT.FAILED) {
+    return `${label.padEnd(24)}${failureGlyph()} FAILED`;
+  }
+  return `${label.padEnd(24)}— NOT VERIFIED`;
+}
+
+/**
+ * @param {string} label
+ * @param {number|undefined} percent
+ * @param {string|undefined} verdict
+ * @returns {string}
+ */
+function formatPillarScoreLine(label, percent, verdict) {
+  const COL_LABEL = 22;
+  const COL_PCT = 10;
+  const pctPlain =
+    typeof percent === 'number' && Number.isFinite(percent)
+      ? `${Math.round(percent)}%`
+      : '—';
+  const pctStr =
+    typeof percent === 'number' && Number.isFinite(percent)
+      ? chalk.cyan.bold(pctPlain)
+      : chalk.gray(pctPlain);
+  const verdictPart = formatPillarLine('', verdict).trim();
+  const pctGap = Math.max(2, COL_PCT - pctPlain.length);
+  return `${label.padEnd(COL_LABEL)}${pctStr}${' '.repeat(pctGap)}${verdictPart}`;
+}
+
+/** Longest Silver→Gold criterion label ("Operational Readiness ≥ 90%"). */
+const CRITERION_LABEL_COL = 32;
+
+/**
+ * @param {string} glyph
+ * @param {string} label
+ * @param {string|null|undefined} hintPlain
+ * @returns {string}
+ */
+function formatCriterionProgressLine(glyph, label, hintPlain) {
+  const prefix = `  ${glyph}  `;
+  if (!hintPlain) {
+    return `${prefix}${label}`;
+  }
+  const gap = Math.max(2, CRITERION_LABEL_COL - label.length);
+  return `${prefix}${label}${' '.repeat(gap)}${metaGray(hintPlain)}`;
+}
+
+/**
+ * @param {Object} report
+ */
+function displayPillarScores(report) {
+  logger.log(chalk.white('Pillar scores'));
+  logger.log(chalk.gray(SEP));
+  logger.log(
+    formatPillarScoreLine(
+      'Operations',
+      report.operations?.operationalReadinessPercent,
+      report.operations?.verdict
+    )
+  );
+  logger.log(
+    formatPillarScoreLine(
+      'AI Trust',
+      report.trust?.aiTrustPercent,
+      report.trust?.verdict
+    )
+  );
+  logger.log(
+    formatPillarScoreLine(
+      'Governance',
+      report.governance?.policyCoveragePercent,
+      report.governance?.verdict
+    )
+  );
+  logger.log('');
+}
+
+/**
+ * @param {import('./certification-progress').CertificationProgressViewModel} progress
+ */
+function displayHighestTierAchieved(progress) {
+  logger.log(
+    metaGray(
+      `Current: ${formatCertificationLevel(progress.currentLevel)} — highest tier achieved`
+    )
+  );
+  logger.log('');
+}
+
+/**
+ * @param {import('./certification-progress').CertificationProgressViewModel} progress
+ */
+function displayProgressTargetHeader(progress) {
+  const targetLabel = formatCertificationLevel(progress.targetLevel);
+  const headerSuffix =
+    progress.mode === 'progress' && typeof progress.progressPercent === 'number'
+      ? ` (${progress.progressPercent}%)`
+      : '';
+  logger.log(
+    chalk.white(
+      `Current: ${formatCertificationLevel(progress.currentLevel).toUpperCase()}  →  Progress to ${targetLabel.toUpperCase()}${headerSuffix}`
+    )
+  );
+  logger.log('');
+}
+
+/**
+ * @param {Object} report
+ * @param {import('./certification-progress').CertificationProgressViewModel} progress
+ * @param {boolean} openApiPublished
+ */
+function displayProgressCriteriaRows(report, progress, openApiPublished) {
+  if (progress.criteria.length === 0) {
+    logger.log(
+      metaGray(
+        `Progress criteria for ${formatCertificationLevel(progress.targetLevel)} are not configured yet.`
+      )
+    );
+    logger.log('');
+    return;
+  }
+  for (const row of progress.criteria) {
+    const glyph = row.met ? successGlyph() : failureGlyph();
+    const hintPlain = row.met
+      ? null
+      : formatCriterionCurrentHint(row.id, report, openApiPublished);
+    logger.log(formatCriterionProgressLine(glyph, row.label, hintPlain));
+  }
+}
+
+/**
+ * @param {import('./certification-progress').CertificationProgressViewModel} progress
+ */
+function displayProgressBarRow(progress) {
+  if (progress.mode !== 'progress' || typeof progress.progressPercent !== 'number') {
+    return;
+  }
+  logger.log('');
+  const targetLabel = formatCertificationLevel(progress.targetLevel);
+  const barPlain = formatProgressBar(progress.progressPercent);
+  const pctPlain = `${progress.progressPercent}%`;
+  const progressLabel = `${targetLabel} progress`;
+  logger.log(
+    `  ${progressLabel.padEnd(18)}  ${chalk.cyan(barPlain)}  ${chalk.cyan.bold(pctPlain)}`
+  );
+}
+
+/**
+ * @param {string} systemKey
+ * @param {Object} report
+ * @param {import('./certification-progress').CertificationProgressViewModel|null} progress
+ * @param {boolean} openApiPublished
+ * @param {string|null} dataplaneUrl
+ * @param {string|null} [dataplaneUiBaseUrl]
+ */
+function displayCertificationProgressBlock(
+  systemKey,
+  report,
+  progress,
+  openApiPublished,
+  dataplaneUrl,
+  dataplaneUiBaseUrl = null
+) {
+  if (!progress) {
+    return;
+  }
+  logger.log(chalk.white('Certification progress'));
+  logger.log(chalk.gray(SEP));
+  if (progress.highestTierAchieved) {
+    displayHighestTierAchieved(progress);
+    return;
+  }
+  displayProgressTargetHeader(progress);
+  displayProgressCriteriaRows(report, progress, openApiPublished);
+  displayProgressBarRow(progress);
+  const nextStep = resolveNextStepCommand(systemKey, progress, {
+    dataplaneUrl,
+    dataplaneUiBaseUrl
+  });
+  if (nextStep) {
+    logger.log('');
+    logger.log(chalk.white('Next step:') + `  ${nextStep}`);
+  }
+  logger.log('');
+}
+
+function displayCertificationSummary(report) {
+  const level = report.certification?.level || 'NONE';
+  const status = report.certification?.status || 'NOT_CERTIFIED';
+  logger.log(chalk.white('Certification'));
+  logger.log(chalk.gray(SEP));
+  logger.log(chalk.cyan.bold(level));
+  logger.log('');
+  logger.log(chalk.white('Status'));
+  logger.log(chalk.gray(SEP));
+  logger.log(formatCertificationStatusDisplay(status));
+  logger.log('');
+}
+
+/**
+ * @param {string} systemKey
+ * @param {Array<{ code: string, action?: string }>} recs
+ */
+function displayRecommendationsBlock(systemKey, recs) {
+  if (recs.length === 0) {
+    return;
+  }
+  logger.log('');
+  logger.log(chalk.white('Recommendations'));
+  logger.log(chalk.gray(SEP));
+  logger.log(metaGray(`${recs.length} improvement${recs.length === 1 ? '' : 's'} available`));
+  for (const rec of recs) {
+    logger.log(`  • ${formatRecommendationAction(systemKey, rec)}`);
+  }
+}
+
+/**
+ * @param {Array<Object>} datasources
+ */
+function displayDatasourceBreakdown(datasources) {
+  logger.log('');
+  logger.log(chalk.white('Datasource breakdown'));
+  logger.log(chalk.gray(SEP));
+  for (const ds of datasources) {
+    logger.log(chalk.white(`  ${ds.datasourceKey}`));
+    logger.log(`    ${formatPillarLine('Operations', ds.operations?.verdict).trim()}`);
+    logger.log(`    ${formatPillarLine('AI Trust', ds.trust?.verdict).trim()}`);
+    logger.log(`    ${formatPillarLine('Governance', ds.governance?.verdict).trim()}`);
+  }
+}
+
+/**
+ * @param {string} systemKey
+ * @param {Object} report - SystemLifecycleReport shape
+ * @param {{ details?: boolean, certificationProgress?: Object|null, openApiPublished?: boolean, dataplaneUrl?: string|null, dataplaneUiBaseUrl?: string|null }} opts
+ */
+function displayLifecycleReportTTY(systemKey, report, opts = {}) {
+  logger.log('');
+  logger.log(sectionTitle(`${String(systemKey).toUpperCase()} CERTIFICATION REPORT`));
+  logger.log('');
+  displayCertificationSummary(report);
+  displayPillarScores(report);
+  displayCertificationProgressBlock(
+    systemKey,
+    report,
+    opts.certificationProgress ?? null,
+    opts.openApiPublished === true,
+    opts.dataplaneUrl ?? null,
+    opts.dataplaneUiBaseUrl ?? null
+  );
+  displayRecommendationsBlock(systemKey, report.recommendations || []);
+  if (opts.details === true && Array.isArray(report.datasources) && report.datasources.length > 0) {
+    displayDatasourceBreakdown(report.datasources);
+  }
+  logger.log('');
+}
+
+module.exports = {
+  displayVerifyOperationsTTY,
+  displayVerifyTrustTTY,
+  displayVerifyGovernanceTTY,
+  displayLifecycleReportTTY,
+  displayOperationsReadinessMetrics,
+  displayOperationsVerificationSteps
+};

package/lib/lifecycle/scenario-upload.js

@@ -0,0 +1,191 @@
+/**
+ * @fileoverview Upload local governance scenario YAML packs to dataplane (419.0).
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const path = require('path');
+const {
+  existsSync,
+  readFileSync,
+  readdirSync,
+  mkdirSync,
+  writeFileSync
+} = require('../internal/fs-real-sync');
+const yaml = require('js-yaml');
+const logger = require('../utils/logger');
+const { getIntegrationPath } = require('../utils/paths');
+const { upsertDatasourceGovernancePack } = require('../api/governance-scenario-pack.api');
+const { formatSuccessLine, formatWarningLine } = require('../utils/cli-test-layout-chalk');
+const { shortGovernanceApiError } = require('../governance/governance-cli-errors');
+const { printGovernanceDownloadMisses } = require('../governance/governance-download-display');
+
+/**
+ * @param {string} scenariosDir
+ * @returns {string[]}
+ */
+function listScenarioYamlFiles(scenariosDir) {
+  if (!existsSync(scenariosDir)) return [];
+  return readdirSync(scenariosDir)
+    .filter(name => name.endsWith('.yaml') || name.endsWith('.yml'))
+    .map(name => path.join(scenariosDir, name));
+}
+
+/**
+ * Extract datasource keys referenced in a pack document.
+ * @param {Object} pack
+ * @returns {string[]}
+ */
+function datasourceKeysFromPack(pack) {
+  const keys = new Set();
+  const scenarios = pack?.spec?.scenarios || [];
+  for (const scenario of scenarios) {
+    const dsKeys = scenario?.search?.datasourceKeys || [];
+    for (const k of dsKeys) {
+      if (k && typeof k === 'string') keys.add(k.trim());
+    }
+  }
+  return [...keys];
+}
+
+/**
+ * @param {string} filePath
+ * @returns {Object}
+ */
+function loadPackFromFile(filePath) {
+  const raw = readFileSync(filePath, 'utf8');
+  const doc = yaml.load(raw);
+  if (!doc || typeof doc !== 'object') {
+    throw new Error(`Invalid scenario pack YAML: ${filePath}`);
+  }
+  return doc;
+}
+
+/**
+ * Upload scenario packs under integration/<systemKey>/scenarios/ to dataplane.
+ * @async
+ * @param {string} systemKey
+ * @param {string} dataplaneUrl
+ * @param {Object} authConfig
+ * @param {{ silent?: boolean }} [opts]
+ * @returns {Promise<number>} count of packs uploaded
+ */
+async function uploadGovernanceScenarioPacks(systemKey, dataplaneUrl, authConfig, opts = {}) {
+  const scenariosDir = path.join(getIntegrationPath(systemKey), 'scenarios');
+  const files = listScenarioYamlFiles(scenariosDir);
+  if (files.length === 0) return 0;
+
+  let uploaded = 0;
+  for (const filePath of files) {
+    const pack = loadPackFromFile(filePath);
+    const dsKeys = datasourceKeysFromPack(pack);
+    if (dsKeys.length === 0) {
+      if (!opts.silent) {
+        logger.log(
+          formatWarningLine(
+            `Skipping ${path.basename(filePath)} — no datasourceKeys in scenarios`
+          )
+        );
+      }
+      continue;
+    }
+    for (const dsKey of dsKeys) {
+      await upsertDatasourceGovernancePack(dataplaneUrl, authConfig, dsKey, pack);
+      uploaded += 1;
+      if (!opts.silent) {
+        logger.log(
+          formatSuccessLine(
+            `Governance scenario pack uploaded for ${dsKey} (${path.basename(filePath)})`
+          )
+        );
+      }
+    }
+  }
+  return uploaded;
+}
+
+/**
+ * Write governance scenario packs from dataplane to integration/<systemKey>/scenarios/.
+ * @async
+ * @param {string} systemKey
+ * @param {string[]} datasourceKeys
+ * @param {string} dataplaneUrl
+ * @param {Object} authConfig
+ * @returns {Promise<number>}
+ */
+async function downloadGovernanceScenarioPacks(
+  systemKey,
+  datasourceKeys,
+  dataplaneUrl,
+  authConfig
+) {
+  const { getDatasourceGovernancePack } = require('../api/governance-scenario-pack.api');
+  const scenariosDir = path.join(getIntegrationPath(systemKey), 'scenarios');
+  if (!existsSync(scenariosDir)) {
+    mkdirSync(scenariosDir, { recursive: true });
+  }
+
+  let written = 0;
+  const missing = [];
+  for (const dsKey of datasourceKeys) {
+    try {
+      const row = await getDatasourceGovernancePack(dataplaneUrl, authConfig, dsKey);
+      if (!row || !row.pack) {
+        missing.push({
+          datasourceKey: dsKey,
+          reason: 'No active pack on dataplane'
+        });
+        continue;
+      }
+      const outPath = path.join(scenariosDir, `${dsKey}.yaml`);
+      writeFileSync(outPath, yaml.dump(row.pack, { lineWidth: 120 }), 'utf8');
+      written += 1;
+      logger.log(formatSuccessLine(`Scenario pack saved: ${outPath}`));
+    } catch (err) {
+      missing.push({
+        datasourceKey: dsKey,
+        reason: shortGovernanceApiError(err)
+      });
+    }
+  }
+  printGovernanceDownloadMisses(missing);
+  return written;
+}
+
+/**
+ * Download governance packs for all datasource keys on a running manifest.
+ * @async
+ * @param {string} systemKey
+ * @param {Object} manifest
+ * @param {string} dataplaneUrl
+ * @param {Object} authConfig
+ * @returns {Promise<number>}
+ */
+async function downloadGovernanceScenarioPacksFromManifest(
+  systemKey,
+  manifest,
+  dataplaneUrl,
+  authConfig
+) {
+  const dsKeys = (manifest.dataSources || []).map((ds) => ds && ds.key).filter(Boolean);
+  if (dsKeys.length === 0) {
+    return 0;
+  }
+  try {
+    return await downloadGovernanceScenarioPacks(systemKey, dsKeys, dataplaneUrl, authConfig);
+  } catch (err) {
+    logger.log(formatWarningLine(`Governance scenario download skipped: ${err.message}`));
+    return 0;
+  }
+}
+
+module.exports = {
+  listScenarioYamlFiles,
+  datasourceKeysFromPack,
+  loadPackFromFile,
+  uploadGovernanceScenarioPacks,
+  downloadGovernanceScenarioPacks,
+  downloadGovernanceScenarioPacksFromManifest
+};