scene-capability-engine 3.6.44 → 3.6.46

package/scripts/release-drift-signals.js

@@ -0,0 +1,255 @@
+'use strict';
+
+function parseNumber(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function parseBoolean(value, fallback = false) {
+  if (value === undefined || value === null) {
+    return fallback;
+  }
+  const normalized = `${value}`.trim().toLowerCase();
+  if (!normalized) {
+    return fallback;
+  }
+  if (['1', 'true', 'yes', 'y', 'on'].includes(normalized)) {
+    return true;
+  }
+  if (['0', 'false', 'no', 'n', 'off'].includes(normalized)) {
+    return false;
+  }
+  return fallback;
+}
+
+function normalizeRisk(value) {
+  const normalized = `${value || 'unknown'}`.trim().toLowerCase();
+  if (['low', 'medium', 'high', 'unknown'].includes(normalized)) {
+    return normalized;
+  }
+  return 'unknown';
+}
+
+function countConsecutive(items, predicate) {
+  let count = 0;
+  for (const item of items) {
+    if (!predicate(item)) {
+      break;
+    }
+    count += 1;
+  }
+  return count;
+}
+
+function resolveReleaseDriftThresholds(env = process.env) {
+  return {
+    failStreakMin: Math.max(
+      1,
+      Math.floor(parseNumber(env.RELEASE_DRIFT_FAIL_STREAK_MIN, 2))
+    ),
+    highRiskShareMinPercent: Math.max(
+      0,
+      Math.min(100, parseNumber(env.RELEASE_DRIFT_HIGH_RISK_SHARE_MIN_PERCENT, 60))
+    ),
+    highRiskShareDeltaMinPercent: Math.max(
+      0,
+      Math.min(100, parseNumber(env.RELEASE_DRIFT_HIGH_RISK_SHARE_DELTA_MIN_PERCENT, 25))
+    ),
+    preflightBlockRateMinPercent: Math.max(
+      0,
+      Math.min(100, parseNumber(env.RELEASE_DRIFT_PREFLIGHT_BLOCK_RATE_MIN_PERCENT, 40))
+    ),
+    hardGateBlockStreakMin: Math.max(
+      1,
+      Math.floor(parseNumber(env.RELEASE_DRIFT_HARD_GATE_BLOCK_STREAK_MIN, 2))
+    ),
+    preflightUnavailableStreakMin: Math.max(
+      1,
+      Math.floor(parseNumber(env.RELEASE_DRIFT_PREFLIGHT_UNAVAILABLE_STREAK_MIN, 2))
+    ),
+    capabilityExpectedUnknownRateMinPercent: Math.max(
+      0,
+      Math.min(100, parseNumber(env.RELEASE_DRIFT_CAPABILITY_EXPECTED_UNKNOWN_RATE_MIN_PERCENT, 40))
+    ),
+    capabilityProvidedUnknownRateMinPercent: Math.max(
+      0,
+      Math.min(100, parseNumber(env.RELEASE_DRIFT_CAPABILITY_PROVIDED_UNKNOWN_RATE_MIN_PERCENT, 40))
+    )
+  };
+}
+
+function buildReleaseDriftSignals(payload = {}, options = {}) {
+  const entries = Array.isArray(payload && payload.entries) ? payload.entries : [];
+  const windowSize = Math.max(1, Math.floor(parseNumber(options.windowSize, 5)));
+  const shortWindowSize = Math.max(1, Math.floor(parseNumber(options.shortWindowSize, 3)));
+  const longWindowSize = Math.max(shortWindowSize, Math.floor(parseNumber(options.longWindowSize, 5)));
+  const defaultThresholds = resolveReleaseDriftThresholds(options.env || process.env);
+  const thresholds = options.thresholds && typeof options.thresholds === 'object'
+    ? {
+      ...defaultThresholds,
+      ...options.thresholds
+    }
+    : defaultThresholds;
+
+  const recent = entries.slice(0, Math.min(entries.length, windowSize));
+  const shortWindow = entries.slice(0, Math.min(entries.length, shortWindowSize));
+  const longWindow = entries.slice(0, Math.min(entries.length, longWindowSize));
+
+  const riskCounts = recent.reduce((acc, item) => {
+    const risk = normalizeRisk(item && item.risk_level);
+    acc[risk] += 1;
+    return acc;
+  }, { low: 0, medium: 0, high: 0, unknown: 0 });
+
+  const recentPass = recent.filter(item => item && item.gate_passed === true).length;
+  const recentKnown = recent.filter(item => item && typeof item.gate_passed === 'boolean').length;
+  const failedStreak = countConsecutive(recent, item => item && item.gate_passed === false);
+  const highRiskShare = recent.length > 0
+    ? Number(((riskCounts.high / recent.length) * 100).toFixed(2))
+    : 0;
+  const shortHighShare = shortWindow.length > 0
+    ? shortWindow.filter(item => normalizeRisk(item && item.risk_level) === 'high').length / shortWindow.length
+    : 0;
+  const longHighShare = longWindow.length > 0
+    ? longWindow.filter(item => normalizeRisk(item && item.risk_level) === 'high').length / longWindow.length
+    : 0;
+  const highRiskDeltaPercent = Number(((shortHighShare - longHighShare) * 100).toFixed(2));
+
+  const recentPreflightKnown = recent.filter(
+    item => item && typeof item.release_gate_preflight_blocked === 'boolean'
+  ).length;
+  const recentPreflightBlocked = recent.filter(
+    item => item && item.release_gate_preflight_blocked === true
+  ).length;
+  const recentPreflightBlockedRate = recentPreflightKnown > 0
+    ? Number(((recentPreflightBlocked / recentPreflightKnown) * 100).toFixed(2))
+    : null;
+  const hardGateBlockedStreak = countConsecutive(
+    recent,
+    item => item && item.require_release_gate_preflight === true && item.release_gate_preflight_blocked === true
+  );
+  const preflightUnavailableStreak = countConsecutive(
+    recent,
+    item => item && item.release_gate_preflight_available === false
+  );
+  const recentCapabilityExpectedUnknownKnown = recent.filter(item => (
+    item &&
+    Number.isFinite(Number(item.capability_expected_unknown_count))
+  )).length;
+  const recentCapabilityExpectedUnknownPositive = recent.filter(item => (
+    item &&
+    Number.isFinite(Number(item.capability_expected_unknown_count)) &&
+    Number(item.capability_expected_unknown_count) > 0
+  )).length;
+  const recentCapabilityExpectedUnknownRate = recentCapabilityExpectedUnknownKnown > 0
+    ? Number(((recentCapabilityExpectedUnknownPositive / recentCapabilityExpectedUnknownKnown) * 100).toFixed(2))
+    : null;
+  const recentCapabilityProvidedUnknownKnown = recent.filter(item => (
+    item &&
+    Number.isFinite(Number(item.capability_provided_unknown_count))
+  )).length;
+  const recentCapabilityProvidedUnknownPositive = recent.filter(item => (
+    item &&
+    Number.isFinite(Number(item.capability_provided_unknown_count)) &&
+    Number(item.capability_provided_unknown_count) > 0
+  )).length;
+  const recentCapabilityProvidedUnknownRate = recentCapabilityProvidedUnknownKnown > 0
+    ? Number(((recentCapabilityProvidedUnknownPositive / recentCapabilityProvidedUnknownKnown) * 100).toFixed(2))
+    : null;
+
+  const alerts = [];
+  if (failedStreak >= thresholds.failStreakMin) {
+    alerts.push(`consecutive gate failures: ${failedStreak} (threshold=${thresholds.failStreakMin})`);
+  }
+  if (highRiskShare >= thresholds.highRiskShareMinPercent) {
+    alerts.push(
+      `high-risk share in latest ${windowSize} is ${highRiskShare}% `
+      + `(threshold=${thresholds.highRiskShareMinPercent}%)`
+    );
+  }
+  if (
+    shortWindow.length >= 2 &&
+    longWindow.length >= 3 &&
+    highRiskDeltaPercent >= thresholds.highRiskShareDeltaMinPercent
+  ) {
+    alerts.push(
+      `high-risk share increased from ${(longHighShare * 100).toFixed(2)}% to ${(shortHighShare * 100).toFixed(2)}% `
+      + `(threshold=${thresholds.highRiskShareDeltaMinPercent}%)`
+    );
+  }
+  if (
+    recentPreflightBlockedRate !== null &&
+    recentPreflightBlockedRate >= thresholds.preflightBlockRateMinPercent
+  ) {
+    alerts.push(
+      `release preflight blocked rate in latest ${windowSize} is ${recentPreflightBlockedRate}% `
+      + `(threshold=${thresholds.preflightBlockRateMinPercent}%, known=${recentPreflightKnown})`
+    );
+  }
+  if (hardGateBlockedStreak >= thresholds.hardGateBlockStreakMin) {
+    alerts.push(
+      `hard-gate preflight blocked streak is ${hardGateBlockedStreak} `
+      + `(threshold=${thresholds.hardGateBlockStreakMin})`
+    );
+  }
+  if (preflightUnavailableStreak >= thresholds.preflightUnavailableStreakMin) {
+    alerts.push(
+      `release preflight unavailable streak is ${preflightUnavailableStreak} `
+      + `(threshold=${thresholds.preflightUnavailableStreakMin})`
+    );
+  }
+  if (
+    recentCapabilityExpectedUnknownRate !== null &&
+    recentCapabilityExpectedUnknownRate >= thresholds.capabilityExpectedUnknownRateMinPercent
+  ) {
+    alerts.push(
+      `capability expected unknown positive rate in latest ${windowSize} is ${recentCapabilityExpectedUnknownRate}% `
+      + `(threshold=${thresholds.capabilityExpectedUnknownRateMinPercent}%, known=${recentCapabilityExpectedUnknownKnown})`
+    );
+  }
+  if (
+    recentCapabilityProvidedUnknownRate !== null &&
+    recentCapabilityProvidedUnknownRate >= thresholds.capabilityProvidedUnknownRateMinPercent
+  ) {
+    alerts.push(
+      `capability provided unknown positive rate in latest ${windowSize} is ${recentCapabilityProvidedUnknownRate}% `
+      + `(threshold=${thresholds.capabilityProvidedUnknownRateMinPercent}%, known=${recentCapabilityProvidedUnknownKnown})`
+    );
+  }
+
+  return {
+    entries,
+    recent,
+    recentPass,
+    recentKnown,
+    riskCounts,
+    failedStreak,
+    highRiskShare,
+    highRiskDeltaPercent,
+    recentPreflightKnown,
+    recentPreflightBlocked,
+    recentPreflightBlockedRate,
+    hardGateBlockedStreak,
+    preflightUnavailableStreak,
+    recentCapabilityExpectedUnknownKnown,
+    recentCapabilityExpectedUnknownPositive,
+    recentCapabilityExpectedUnknownRate,
+    recentCapabilityProvidedUnknownKnown,
+    recentCapabilityProvidedUnknownPositive,
+    recentCapabilityProvidedUnknownRate,
+    alerts,
+    thresholds,
+    windows: {
+      recent: recent.length,
+      short: shortWindow.length,
+      long: longWindow.length
+    }
+  };
+}
+
+module.exports = {
+  buildReleaseDriftSignals,
+  parseBoolean,
+  parseNumber,
+  resolveReleaseDriftThresholds
+};

package/scripts/release-governance-snapshot-export.js

@@ -0,0 +1,132 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function appendSummary(summaryPath, lines = []) {
+  if (!summaryPath) {
+    return;
+  }
+  fs.appendFileSync(summaryPath, `${lines.join('\n')}\n\n`, 'utf8');
+}
+
+function safeReadJson(file) {
+  try {
+    if (!file || !fs.existsSync(file)) {
+      return { ok: false, error: `missing file: ${file || 'n/a'}` };
+    }
+    const payload = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return { ok: true, payload };
+  } catch (error) {
+    return { ok: false, error: `parse error: ${error.message}` };
+  }
+}
+
+function normalizeArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function exportReleaseGovernanceSnapshot(options = {}) {
+  const env = options.env && typeof options.env === 'object'
+    ? options.env
+    : process.env;
+  const now = typeof options.now === 'function'
+    ? options.now
+    : () => new Date().toISOString();
+
+  const summaryFile = `${env.RELEASE_EVIDENCE_SUMMARY_FILE || ''}`.trim();
+  const outputJson = `${env.RELEASE_GOVERNANCE_SNAPSHOT_JSON || '.sce/reports/release-evidence/governance-snapshot.json'}`.trim();
+  const outputMarkdown = `${env.RELEASE_GOVERNANCE_SNAPSHOT_MD || '.sce/reports/release-evidence/governance-snapshot.md'}`.trim();
+  const releaseTag = `${env.RELEASE_TAG || ''}`.trim();
+  const summaryPath = env.GITHUB_STEP_SUMMARY;
+
+  const summaryResult = safeReadJson(summaryFile);
+  const payload = summaryResult.ok && summaryResult.payload && typeof summaryResult.payload === 'object'
+    ? summaryResult.payload
+    : {};
+  const governanceSnapshot = payload.governance_snapshot && typeof payload.governance_snapshot === 'object'
+    ? payload.governance_snapshot
+    : null;
+  const available = governanceSnapshot !== null;
+  const concerns = normalizeArray(governanceSnapshot && governanceSnapshot.health && governanceSnapshot.health.concerns);
+  const recommendations = normalizeArray(governanceSnapshot && governanceSnapshot.health && governanceSnapshot.health.recommendations);
+  const risk = `${governanceSnapshot && governanceSnapshot.health && governanceSnapshot.health.risk || 'unknown'}`.trim().toLowerCase();
+
+  const exportPayload = {
+    mode: 'release-governance-snapshot',
+    generated_at: now(),
+    tag: releaseTag || null,
+    summary_file: summaryFile || null,
+    available,
+    warning: summaryResult.ok ? null : summaryResult.error,
+    governance_snapshot: governanceSnapshot
+  };
+
+  fs.mkdirSync(path.dirname(outputJson), { recursive: true });
+  fs.writeFileSync(outputJson, `${JSON.stringify(exportPayload, null, 2)}\n`, 'utf8');
+
+  const markdownLines = [
+    '# Release Governance Snapshot',
+    '',
+    `- Tag: ${releaseTag || 'n/a'}`,
+    `- Generated At: ${exportPayload.generated_at}`,
+    `- Summary File: ${summaryFile || 'n/a'}`,
+    `- Available: ${available ? 'yes' : 'no'}`
+  ];
+
+  if (!available) {
+    markdownLines.push(`- Warning: ${exportPayload.warning || 'governance snapshot unavailable'}`);
+  } else {
+    markdownLines.push(`- Risk: ${risk}`);
+    markdownLines.push(`- Concerns: ${concerns.length}`);
+    markdownLines.push(`- Recommendations: ${recommendations.length}`);
+    if (concerns.length > 0) {
+      markdownLines.push('', '## Concerns');
+      concerns.forEach(item => markdownLines.push(`- ${item}`));
+    }
+    if (recommendations.length > 0) {
+      markdownLines.push('', '## Recommendations');
+      recommendations.forEach(item => markdownLines.push(`- ${item}`));
+    }
+  }
+
+  fs.mkdirSync(path.dirname(outputMarkdown), { recursive: true });
+  fs.writeFileSync(outputMarkdown, `${markdownLines.join('\n')}\n`, 'utf8');
+
+  console.log(`[release-governance-snapshot] summary=${summaryFile || 'n/a'} available=${available}`);
+  console.log(`[release-governance-snapshot] json=${outputJson}`);
+  console.log(`[release-governance-snapshot] markdown=${outputMarkdown}`);
+
+  appendSummary(summaryPath, [
+    '## Release Governance Snapshot',
+    '',
+    `- summary: ${summaryFile || 'n/a'}`,
+    `- available: ${available}`,
+    `- json: ${outputJson}`,
+    `- markdown: ${outputMarkdown}`,
+    ...(available
+      ? [
+        `- risk: ${risk}`,
+        `- concerns: ${concerns.length}`,
+        `- recommendations: ${recommendations.length}`
+      ]
+      : [`- warning: ${exportPayload.warning || 'governance snapshot unavailable'}`])
+  ]);
+
+  return {
+    exit_code: 0,
+    available,
+    warning: exportPayload.warning,
+    json_file: outputJson,
+    markdown_file: outputMarkdown
+  };
+}
+
+if (require.main === module) {
+  const result = exportReleaseGovernanceSnapshot();
+  process.exit(result.exit_code);
+}
+
+module.exports = {
+  exportReleaseGovernanceSnapshot
+};