@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-runtime/runtime-governance-route-model.mjs

@@ -0,0 +1,194 @@
+export const runtimeGovernanceRouteModelContractSync = {
+  runtime_check_owner: 'tools/vibe-runtime-check/index.mjs',
+  release_check_owner: 'tools/vibe-release-check',
+};
+
+const governanceModeSpecs = Object.freeze([
+  ['attest', 'governanceAttest'],
+  ['compatibility', 'governanceCompatibility'],
+  ['convergence', 'governanceConvergence'],
+  ['superpowers-gap', 'governanceSuperpowersGap'],
+  ['superpowers-comparison', 'governanceSuperpowersComparison'],
+  ['superpowers-regression-guard', 'governanceSuperpowersRegressionGuard'],
+  ['experience-friction', 'governanceExperienceFriction'],
+  ['experience-dashboard', 'governanceExperienceDashboard'],
+  ['experience-upgrades', 'governanceExperienceUpgrades'],
+  ['superpowers-parity-scorecard', 'governanceSuperpowersParityScorecard'],
+  ['contributor-guardrails', 'governanceContributorGuardrails'],
+  ['subagent-permission', 'governanceSubagentPermission'],
+  ['traceability-map', 'governanceTraceabilityMap'],
+  ['pr-readiness', 'governancePrReadiness'],
+  ['pr-review-intake', 'governancePrReviewIntake'],
+  ['advice', 'governanceAdvice'],
+  ['surface', 'governanceSurface'],
+  ['list', 'governanceList'],
+  ['show', 'governanceShow'],
+  ['verify', 'governanceVerify'],
+]);
+
+const governanceModeSelectionError = 'governance requires exactly one of --attest, --compatibility --report, --convergence --report, --superpowers-gap, --superpowers-comparison, --superpowers-regression-guard, --experience-friction, --experience-dashboard, --experience-upgrades, --superpowers-parity-scorecard, --contributor-guardrails, --subagent-permission, --traceability-map, --pr-readiness, --pr-review-intake, --advice, --surface, --list, --show, or --verify';
+
+const executionLikeOptionKeys = Object.freeze([
+  'write',
+  'scan',
+  'once',
+  'fromDispatch',
+  'dispatchEvent',
+  'actor',
+  'approval',
+  'run',
+  'autoRun',
+  'confirm',
+  'dryRun',
+  'preflight',
+  'dispatch',
+  'dispatchIntent',
+]);
+
+const broadReportOnlyOptionKeys = Object.freeze([
+  'confirm',
+  'dryRun',
+  'write',
+  'preflight',
+  'dispatch',
+  'dispatchIntent',
+  'scan',
+  'once',
+  'run',
+  'autoRun',
+  'fromDispatch',
+  'dispatchEvent',
+  'actor',
+  'approval',
+]);
+
+const dashboardExclusiveOptionKeys = Object.freeze([
+  'fromFile',
+  'fromSuperpowers',
+  'fromReadiness',
+  'fromRunbook',
+  'fromEvidence',
+  'fromExecutablePlan',
+  'fromPlan',
+  'fromComparison',
+  'fromDashboard',
+  'fromInstallExperience',
+  'selectedStage',
+  'task',
+  'commitSubject',
+  'confirmPlan',
+  'methodologyKind',
+  'prompt',
+]);
+
+const superpowersRootExclusiveOptionKeys = Object.freeze(dashboardExclusiveOptionKeys.filter((key) => key !== 'fromSuperpowers'));
+
+function hasAnyOption(options, keys) {
+  return keys.some((key) => Boolean(options[key]));
+}
+
+function hasAnyListOption(options, keys) {
+  return keys.some((key) => Array.isArray(options[key]) && options[key].length > 0);
+}
+
+function selectedGovernanceModes(options) {
+  return governanceModeSpecs.filter(([, key]) => Boolean(options[key])).map(([mode]) => mode);
+}
+
+export function resolveGovernanceRoute(options) {
+  if (options.governanceSurfaceDriftGuard && !options.governanceSurface) {
+    throw new Error('governance --surface --drift-guard requires --surface');
+  }
+  const modes = selectedGovernanceModes(options);
+  if (modes.length !== 1) throw new Error(governanceModeSelectionError);
+  return modes[0];
+}
+
+export function assertGovernanceSharedRouteOptions(options) {
+  if (!options.governanceSuperpowersGap && !options.governanceSuperpowersComparison && !options.governanceSuperpowersRegressionGuard && options.fromSuperpowers) throw new Error('--from-superpowers is only supported by governance --superpowers-gap, governance --superpowers-comparison, or governance --superpowers-regression-guard');
+  if (!options.governanceExperienceDashboard && !options.governanceExperienceUpgrades && (options.fromFriction || options.fromConsole || options.fromTokenBudget || options.fromLearningPattern)) throw new Error('--from-friction, --from-console, --from-token-budget, and --from-learning-pattern are only supported by governance --experience-dashboard');
+  if (!options.governanceExperienceUpgrades && !options.governanceSuperpowersParityScorecard && (options.fromComparison || options.fromDashboard || options.fromInstallExperience || options.fromEntryDiscipline || options.fromUpgrades)) throw new Error('--from-comparison, --from-dashboard, --from-install-experience, --from-entry-discipline, and --from-upgrades are only supported by governance --experience-upgrades, governance --superpowers-parity-scorecard, or evals --superpowers-style-pack');
+  if (!options.governanceContributorGuardrails && options.fromEvidencePrompts) throw new Error('--from-evidence-prompts is only supported by governance --contributor-guardrails');
+  if (!options.governanceSubagentPermission && options.fromGuardrails) throw new Error('--from-guardrails is only supported by governance --subagent-permission');
+  if (!options.governanceSubagentPermission && !options.governanceContributorGuardrails && !options.governanceSuperpowersParityScorecard && !options.governanceExperienceUpgrades && !options.governanceExperienceDashboard && !options.governanceSuperpowersComparison && !options.governanceSuperpowersRegressionGuard && !options.governanceSuperpowersGap && !options.governanceTraceabilityMap && options.fromScorecard) throw new Error('--from-scorecard is only supported by workflow --entry-tightening, tokens --entry-defaults, governance --contributor-guardrails, or governance --subagent-permission');
+  if (!options.governanceAdvice && !options.governanceSurface && !options.governanceTraceabilityMap && !options.governanceSuperpowersComparison && !options.governanceSuperpowersRegressionGuard && !options.governanceExperienceFriction && !options.governanceExperienceDashboard && !options.governanceExperienceUpgrades && !options.governanceSuperpowersParityScorecard && !options.governanceContributorGuardrails && !options.governanceSubagentPermission && hasAnyOption(options, ['write', 'scan', 'once', 'fromDispatch', 'dispatchEvent', 'actor', 'approval', 'run', 'autoRun'])) throw new Error('governance supports local attest, PR readiness, compatibility report, convergence report, and read-only audit only');
+  if (options.methodologyIntent && !options.governanceAdvice && !options.governanceSurface && !options.governanceExperienceDashboard) throw new Error('--intent is only supported by governance --advice or governance --experience-dashboard');
+}
+
+export function assertGovernanceSurfaceRouteOptions(options) {
+  if (hasAnyOption(options, executionLikeOptionKeys)) throw new Error('governance --surface is read-only and does not accept execution, dispatch, preview, confirm, or write flags');
+  if (options.methodologyIntent || options.governanceReport || options.fromFile || options.fromReadiness) throw new Error('governance --surface does not accept --intent, --report, --from-file, or --from-readiness');
+}
+
+export function assertGovernanceAdviceRouteOptions(options) {
+  if (hasAnyOption(options, executionLikeOptionKeys)) throw new Error('governance --advice is read-only and does not accept execution, dispatch, preview, confirm, or write flags');
+  if (options.governanceReport || options.fromFile || options.fromReadiness) throw new Error('governance --advice does not accept --report, --from-file, or --from-readiness');
+}
+
+export function assertGovernancePrReviewIntakeRouteOptions(options) {
+  if (options.confirm && options.dryRun) throw new Error('governance --pr-review-intake accepts either --preview or --confirm, not both');
+  if (options.governanceReport) throw new Error('governance --pr-review-intake does not accept --report');
+  if (!options.fromFile) throw new Error('governance --pr-review-intake requires --from-file <local-evidence-file>');
+}
+
+export function assertGovernancePrReadinessRouteOptions(options) {
+  if (options.confirm && options.dryRun) throw new Error('governance --pr-readiness accepts either --preview or --confirm, not both');
+  if (options.governanceReport) throw new Error('governance --pr-readiness does not accept --report');
+}
+
+export function assertGovernanceReportRouteOptions(options, flag, reportError, readOnlyError) {
+  if (!options.governanceReport) throw new Error(reportError);
+  if (options.confirm || options.dryRun) throw new Error(readOnlyError);
+  return flag;
+}
+
+export function assertGovernanceSuperpowersGapRouteOptions(options) {
+  if (options.governanceReport) throw new Error('governance --superpowers-gap does not accept --report');
+  if (options.confirm || options.dryRun || options.preflight || options.dispatch || options.dispatchIntent) throw new Error('governance --superpowers-gap is read-only');
+  if (!options.fromSuperpowers) throw new Error('governance --superpowers-gap requires --from-superpowers <local-superpowers-dir>');
+  if (options.fromSuperpowersRoot) throw new Error('governance --superpowers-gap requires --from-superpowers, not --from-superpowers-root');
+  if (options.fromFile || options.fromReadiness) throw new Error('governance --superpowers-gap only accepts --from-superpowers, --json, and --root');
+}
+
+export function assertGovernanceSuperpowersComparisonRouteOptions(options) {
+  if (options.governanceReport) throw new Error('governance --superpowers-comparison does not accept --report');
+  if (hasAnyOption(options, broadReportOnlyOptionKeys)) throw new Error('governance --superpowers-comparison is read-only and report-only');
+  if (!options.fromSuperpowers) throw new Error('governance --superpowers-comparison requires --from-superpowers-root <local-superpowers-root>');
+  if (hasAnyOption(options, [...superpowersRootExclusiveOptionKeys, 'fromReadiness', 'fromFriction', 'fromConsole', 'fromTokenBudget', 'fromLearningPattern', 'methodologyIntent']) || hasAnyListOption(options, ['learningObservationFiles', 'tokenCompactionFiles']) || options.learningInstinctFile) throw new Error('governance --superpowers-comparison only accepts --from-superpowers-root, --json, and --root');
+}
+
+export function assertGovernanceSuperpowersRegressionGuardRouteOptions(options) {
+  if (options.governanceReport) throw new Error('governance --superpowers-regression-guard does not accept --report');
+  if (options.confirm || options.dryRun || options.write || options.preflight || options.dispatch || options.dispatchIntent || options.scan || options.once || options.run || options.autoRun) throw new Error('governance --superpowers-regression-guard is read-only');
+  if (!options.fromSuperpowers) throw new Error('governance --superpowers-regression-guard requires --from-superpowers <local-superpowers-dir>');
+  if (options.fromSuperpowersRoot) throw new Error('governance --superpowers-regression-guard requires --from-superpowers, not --from-superpowers-root');
+  if (options.fromFile || options.fromReadiness || options.methodologyIntent || options.task || options.commitSubject) throw new Error('governance --superpowers-regression-guard only accepts --from-superpowers, --json, and --root');
+}
+
+export function assertGovernanceExperienceFrictionRouteOptions(options) {
+  if (options.governanceReport) throw new Error('governance --experience-friction does not accept --report');
+  if (options.confirm || options.dryRun || options.write || options.preflight || options.dispatch || options.dispatchIntent || options.scan || options.once || options.run || options.autoRun || options.fromDispatch || options.dispatchEvent || options.actor || options.approval) throw new Error('governance --experience-friction is read-only');
+  if (!options.fromFile) throw new Error('governance --experience-friction requires --from-file <local-session-evidence-json>');
+  if (options.fromSuperpowers || options.fromReadiness || options.methodologyIntent || options.task || options.commitSubject) throw new Error('governance --experience-friction only accepts --from-file, --json, and --root');
+}
+
+export function assertGovernanceExperienceDashboardRouteOptions(options) {
+  if (options.governanceReport) throw new Error('governance --experience-dashboard does not accept --report');
+  if (hasAnyOption(options, broadReportOnlyOptionKeys)) throw new Error('governance --experience-dashboard is read-only and report-only');
+  if (!options.fromFriction) throw new Error('governance --experience-dashboard requires --from-friction <local-friction-json>');
+  if (hasAnyOption(options, dashboardExclusiveOptionKeys) || hasAnyListOption(options, ['learningObservationFiles', 'tokenCompactionFiles']) || options.learningInstinctFile) throw new Error('governance --experience-dashboard only accepts --from-friction, optional --from-console, optional --from-token-budget, optional --from-learning-pattern, optional --intent, --json, and --root');
+}
+
+export function assertGovernanceTraceabilityRouteOptions(options) {
+  if (options.governanceReport) throw new Error('governance --traceability-map does not accept --report');
+  if (options.confirm || options.dryRun || options.write || options.preflight || options.dispatch || options.dispatchIntent || options.scan || options.once || options.run || options.autoRun) throw new Error('governance --traceability-map is read-only');
+  if (options.fromFile || options.fromReadiness || options.fromSuperpowers || options.methodologyIntent || options.task || options.commitSubject) throw new Error('governance --traceability-map only accepts --json and --root');
+}
+
+export function assertGovernanceAttestRouteOptions(options) {
+  if (options.confirm && options.dryRun) throw new Error('governance --attest accepts either --dry-run or --confirm, not both');
+}
+
+export function assertGovernanceAuditRouteOptions(options) {
+  if (options.confirm || options.dryRun || options.governanceReport) throw new Error('governance audit is read-only');
+}