@aifabrix/builder 2.45.5 → 2.46.0

package/lib/lifecycle/product-model.js

@@ -0,0 +1,196 @@
+/**
+ * @fileoverview Enterprise AI Certification product vocabulary (plan 150.0).
+ * Defines verdict enums, tier labels, and operational readiness weights — product model drives API mapping.
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+/** @typedef {'VERIFIED'|'FAILED'|'NOT_VERIFIED'} LifecycleVerdict */
+
+/** @typedef {'BRONZE'|'SILVER'|'GOLD'|'PLATINUM'|'NONE'} CertificationLevel */
+
+/** @typedef {'TECHNICALLY_READY'|'AI_READY'|'ENTERPRISE_AI_READY'|'REGULATED_ENTERPRISE_READY'|'NOT_CERTIFIED'} CertificationStatus */
+
+const VERDICT = Object.freeze({
+  VERIFIED: 'VERIFIED',
+  FAILED: 'FAILED',
+  NOT_VERIFIED: 'NOT_VERIFIED'
+});
+
+const CERTIFICATION_LEVEL = Object.freeze({
+  BRONZE: 'BRONZE',
+  SILVER: 'SILVER',
+  GOLD: 'GOLD',
+  PLATINUM: 'PLATINUM',
+  NONE: 'NONE'
+});
+
+const CERTIFICATION_STATUS = Object.freeze({
+  TECHNICALLY_READY: 'TECHNICALLY_READY',
+  AI_READY: 'AI_READY',
+  ENTERPRISE_AI_READY: 'ENTERPRISE_AI_READY',
+  REGULATED_ENTERPRISE_READY: 'REGULATED_ENTERPRISE_READY',
+  NOT_CERTIFIED: 'NOT_CERTIFIED'
+});
+
+/** Display labels for certification status (aligned with dataplane 419 enum). */
+const STATUS_DISPLAY = Object.freeze({
+  TECHNICALLY_READY: 'TECHNICALLY READY',
+  AI_READY: 'AI READY',
+  ENTERPRISE_AI_READY: 'ENTERPRISE AI READY',
+  REGULATED_ENTERPRISE_READY: 'REGULATED ENTERPRISE READY',
+  NOT_CERTIFIED: 'NOT CERTIFIED'
+});
+
+/**
+ * v1 operational readiness weights (sum = 100).
+ * connectivity + contracts + runtime + reliability groups from plan 150.
+ */
+const OPERATIONS_WEIGHTS = Object.freeze({
+  credentials: 10,
+  authentication: 10,
+  authorization: 10,
+  openApi: 8,
+  mappings: 7,
+  sync: 5,
+  crud: 5,
+  execution: 5,
+  validation: 10,
+  unitTests: 10,
+  integrationTests: 10,
+  e2eTests: 10
+});
+
+const WARNING_CODES = Object.freeze({
+  TRUST_NOT_VERIFIED: 'TRUST_NOT_VERIFIED',
+  GOVERNANCE_NOT_VERIFIED: 'GOVERNANCE_NOT_VERIFIED',
+  OPERATIONS_NOT_VERIFIED: 'OPERATIONS_NOT_VERIFIED',
+  LIFECYCLE_API_UNAVAILABLE: 'LIFECYCLE_API_UNAVAILABLE'
+});
+
+const RECOMMENDATION_COMMAND_BY_CODE = Object.freeze({
+  OPERATIONS_NOT_VERIFIED: 'verify-operations',
+  TRUST_NOT_VERIFIED: 'verify-trust',
+  GOVERNANCE_NOT_VERIFIED: 'governance verify'
+});
+
+/**
+ * @param {string} systemKey
+ * @param {string} command e.g. verify-trust
+ * @returns {string}
+ */
+function actionHint(systemKey, command) {
+  return `aifabrix ${command} ${systemKey}`;
+}
+
+/**
+ * Normalize lifecycle recommendation to a copy-pastable CLI command.
+ * @param {string} systemKey
+ * @param {{ code?: string, action?: string }} rec
+ * @returns {string}
+ */
+function formatRecommendationAction(systemKey, rec) {
+  const action = String(rec.action || '').trim();
+  if (action.startsWith('aifabrix ')) {
+    return action;
+  }
+  const fromCode = RECOMMENDATION_COMMAND_BY_CODE[rec.code];
+  if (fromCode && systemKey) {
+    return actionHint(systemKey, fromCode);
+  }
+  const legacy = /^Run\s+(verify-[a-z-]+)$/i.exec(action);
+  if (legacy && systemKey) {
+    return actionHint(systemKey, legacy[1]);
+  }
+  return action || rec.code || '';
+}
+
+/**
+ * @param {boolean} passed
+ * @returns {LifecycleVerdict}
+ */
+function verdictFromPassed(passed) {
+  return passed ? VERDICT.VERIFIED : VERDICT.FAILED;
+}
+
+/**
+ * @param {string} [status]
+ * @returns {string}
+ */
+function formatCertificationStatusDisplay(status) {
+  if (!status) return STATUS_DISPLAY.NOT_CERTIFIED;
+  return STATUS_DISPLAY[status] || String(status).replace(/_/g, ' ');
+}
+
+/**
+ * Compute operational readiness percent from weighted check map.
+ * @param {Record<string, boolean>} checks
+ * @returns {number}
+ */
+function computeOperationalReadinessPercent(checks) {
+  let earned = 0;
+  let total = 0;
+  for (const [key, weight] of Object.entries(OPERATIONS_WEIGHTS)) {
+    total += weight;
+    if (checks[key] === true) {
+      earned += weight;
+    }
+  }
+  if (total === 0) return 0;
+  return Math.round((earned / total) * 100);
+}
+
+/**
+ * Derive connectivity/runtime checks from step outcomes (v1 inference rules).
+ * @param {{ validation?: boolean, unit?: boolean, integration?: boolean, e2e?: boolean }} steps
+ * @returns {Record<string, boolean>}
+ */
+function buildOperationsChecksFromSteps(steps) {
+  const validation = steps.validation === true;
+  const unit = steps.unit === true;
+  const integration = steps.integration === true;
+  const e2e = steps.e2e === true;
+  return {
+    credentials: integration || e2e,
+    authentication: integration || e2e,
+    authorization: integration || e2e,
+    openApi: validation,
+    mappings: validation,
+    sync: e2e,
+    crud: e2e,
+    execution: e2e,
+    validation,
+    unitTests: unit,
+    integrationTests: integration,
+    e2eTests: e2e
+  };
+}
+
+/**
+ * Worst-of rollup for datasource confidence values (0–1).
+ * @param {number[]} values
+ * @returns {number|null}
+ */
+function worstConfidencePercent(values) {
+  const nums = values.filter(v => typeof v === 'number' && !Number.isNaN(v));
+  if (nums.length === 0) return null;
+  return Math.round(Math.min(...nums) * 100);
+}
+
+module.exports = {
+  VERDICT,
+  CERTIFICATION_LEVEL,
+  CERTIFICATION_STATUS,
+  STATUS_DISPLAY,
+  OPERATIONS_WEIGHTS,
+  WARNING_CODES,
+  actionHint,
+  formatRecommendationAction,
+  verdictFromPassed,
+  formatCertificationStatusDisplay,
+  computeOperationalReadinessPercent,
+  buildOperationsChecksFromSteps,
+  worstConfidencePercent
+};

package/lib/lifecycle/report-display.js

@@ -0,0 +1,471 @@
+/**
+ * @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 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');
+  displayHeroMetric('AI Business Context Confidence', result.businessContextConfidencePercent);
+  displayVerdictLine(result.verdict, 'AI TRUST VERIFIED', 'AI TRUST FAILED');
+  if (opts.details === true && Array.isArray(result.datasourceRows)) {
+    logger.log('');
+    logger.log(chalk.white('Datasources'));
+    logger.log(chalk.gray(SEP));
+    for (const row of result.datasourceRows) {
+      const conf =
+        typeof row.confidencePercent === 'number' ? `${row.confidencePercent}%` : '—';
+      const glyph = row.verdict === VERDICT.VERIFIED ? successGlyph() : failureGlyph();
+      logger.log(`  ${row.datasourceKey}`.padEnd(36) + `${glyph} ${conf}`);
+    }
+  }
+}
+
+/**
+ * @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?.businessContextConfidencePercent,
+      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
+};