@auraindustry/aurajs 0.0.1

package/src/conformance-runner.mjs

@@ -0,0 +1,322 @@
+#!/usr/bin/env node
+
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ConformanceSuiteError, runConformanceSuite } from './conformance.mjs';
+
+const VALID_MODES = new Set(['shim', 'native', 'both']);
+
+function printUsage() {
+  console.log('');
+  console.log('  Usage: aura conformance [--mode shim|native|both] [--json] [--inspector-snapshot] [--runtime-inspector-snapshot-path <path>] [--workspace-root <path>] [--report-path <path>] [--runtime-observability-report-path <path>] [--phaser-vertical-slice-evidence-report-path <path>]');
+  console.log('');
+}
+
+function parseArgs(argv) {
+  const parsed = {
+    mode: 'shim',
+    help: false,
+    json: false,
+    inspectorSnapshot: false,
+    runtimeInspectorSnapshotPath: null,
+    workspaceRoot: null,
+    reportPath: null,
+    runtimeObservabilityReportPath: null,
+    phaserVerticalSliceEvidenceReportPath: null,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+
+    if (token === '--help' || token === '-h') {
+      parsed.help = true;
+      continue;
+    }
+
+    if (token === '--json') {
+      parsed.json = true;
+      continue;
+    }
+
+    if (token === '--inspector-snapshot') {
+      parsed.inspectorSnapshot = true;
+      continue;
+    }
+
+    if (token === '--runtime-inspector-snapshot-path') {
+      const nextValue = argv[i + 1];
+      if (!nextValue) {
+        throw new ConformanceSuiteError('Missing value for --runtime-inspector-snapshot-path.', {});
+      }
+      parsed.runtimeInspectorSnapshotPath = nextValue;
+      i += 1;
+      continue;
+    }
+
+    if (token === '--workspace-root') {
+      const nextValue = argv[i + 1];
+      if (!nextValue) {
+        throw new ConformanceSuiteError('Missing value for --workspace-root.', {});
+      }
+      parsed.workspaceRoot = nextValue;
+      i += 1;
+      continue;
+    }
+
+    if (token === '--report-path') {
+      const nextValue = argv[i + 1];
+      if (!nextValue) {
+        throw new ConformanceSuiteError('Missing value for --report-path.', {});
+      }
+      parsed.reportPath = nextValue;
+      i += 1;
+      continue;
+    }
+
+    if (token === '--runtime-observability-report-path') {
+      const nextValue = argv[i + 1];
+      if (!nextValue) {
+        throw new ConformanceSuiteError('Missing value for --runtime-observability-report-path.', {});
+      }
+      parsed.runtimeObservabilityReportPath = nextValue;
+      i += 1;
+      continue;
+    }
+
+    if (token === '--phaser-vertical-slice-evidence-report-path') {
+      const nextValue = argv[i + 1];
+      if (!nextValue) {
+        throw new ConformanceSuiteError('Missing value for --phaser-vertical-slice-evidence-report-path.', {});
+      }
+      parsed.phaserVerticalSliceEvidenceReportPath = nextValue;
+      i += 1;
+      continue;
+    }
+
+    if (token === '--mode') {
+      const nextValue = argv[i + 1];
+      if (!nextValue) {
+        throw new ConformanceSuiteError('Missing value for --mode.', {
+          validModes: [...VALID_MODES],
+        });
+      }
+
+      const normalized = String(nextValue).toLowerCase();
+      if (!VALID_MODES.has(normalized)) {
+        throw new ConformanceSuiteError(`Unknown conformance mode: ${nextValue}`, {
+          validModes: [...VALID_MODES],
+        });
+      }
+
+      parsed.mode = normalized;
+      i += 1;
+      continue;
+    }
+
+    throw new ConformanceSuiteError(`Unknown conformance option: ${token}`, {
+      validModes: [...VALID_MODES],
+    });
+  }
+
+  return parsed;
+}
+
+function formatJsonResult({
+  ok,
+  mode,
+  reportPath,
+  optionalModuleReadiness = null,
+  runtimeObservabilityReportPath = null,
+  runtimeInspectorSnapshotReportPath = null,
+  phaserVerticalSliceEvidenceReportPath = null,
+  phaserVerticalSliceEvidence = null,
+  summary,
+  runtimeCacheDiagnostics = null,
+  runtimeInspectorSnapshot = null,
+  failedCases = [],
+  hostBinary = null,
+  error = null,
+}) {
+  return {
+    ok,
+    mode,
+    reportPath,
+    optionalModuleReadiness,
+    runtimeObservabilityReportPath,
+    runtimeInspectorSnapshotReportPath,
+    phaserVerticalSliceEvidenceReportPath,
+    phaserVerticalSliceEvidence,
+    summary,
+    runtimeCacheDiagnostics,
+    runtimeInspectorSnapshot,
+    timings: summary?.byMode || {},
+    failedCases,
+    hostBinary,
+    error,
+  };
+}
+
+export function formatHostBinaryLine(hostBinary) {
+  if (!hostBinary || typeof hostBinary !== 'object') return null;
+  const path = typeof hostBinary.path === 'string' ? hostBinary.path : null;
+  const source = typeof hostBinary.source === 'string' ? hostBinary.source : null;
+  if (!path && !source) return null;
+  if (path && source) return `  Host binary: ${source} (${path})`;
+  if (path) return `  Host binary: ${path}`;
+  return `  Host binary source: ${source}`;
+}
+
+export async function runConformanceCommand(argv, io = console) {
+  const args = parseArgs(argv);
+
+  if (args.help) {
+    printUsage();
+    return 0;
+  }
+
+  try {
+    const report = await runConformanceSuite({
+      projectRoot: process.cwd(),
+      mode: args.mode,
+      workspaceRoot: args.workspaceRoot,
+      reportPath: args.reportPath,
+      runtimeObservabilityReportPath: args.runtimeObservabilityReportPath,
+      runtimeInspectorSnapshotEnabled: args.inspectorSnapshot,
+      runtimeInspectorSnapshotReportPath: args.runtimeInspectorSnapshotPath,
+      phaserVerticalSliceEvidenceReportPath: args.phaserVerticalSliceEvidenceReportPath,
+    });
+
+    if (args.json) {
+      io.log(JSON.stringify(formatJsonResult({
+        ok: true,
+        mode: report.mode,
+        reportPath: report.reportPath,
+        optionalModuleReadiness: report.optionalModuleReadiness || null,
+        runtimeObservabilityReportPath: report.runtimeObservabilityReportPath || null,
+        runtimeInspectorSnapshotReportPath: report.runtimeInspectorSnapshotReportPath || null,
+        phaserVerticalSliceEvidenceReportPath: report.phaserVerticalSliceEvidenceReportPath || null,
+        phaserVerticalSliceEvidence: report.phaserVerticalSliceEvidence || null,
+        summary: report.summary,
+        runtimeCacheDiagnostics: report.runtimeCacheDiagnostics || null,
+        runtimeInspectorSnapshot: report.runtimeInspectorSnapshot || null,
+        hostBinary: report.hostBinary || null,
+      }), null, 2));
+      return 0;
+    }
+
+    io.log('');
+    io.log('  aura conformance: PASS');
+    io.log(`  Mode: ${report.mode}`);
+    for (const [modeName, modeSummary] of Object.entries(report.summary.byMode || {})) {
+      io.log(`  ${modeName}: ${modeSummary.passed}/${modeSummary.total} (${modeSummary.durationMs}ms)`);
+    }
+    io.log(`  Cases: ${report.summary.passed}/${report.summary.total}`);
+    const hostBinaryLine = formatHostBinaryLine(report.hostBinary);
+    if (hostBinaryLine) {
+      io.log(hostBinaryLine);
+    }
+    io.log(`  Report: ${report.reportPath}`);
+    if (report.runtimeInspectorSnapshotReport?.enabled) {
+      io.log(`  Runtime inspector snapshot: ${report.runtimeInspectorSnapshotReportPath}`);
+    }
+    io.log('');
+    return 0;
+  } catch (error) {
+    if (error instanceof ConformanceSuiteError) {
+      const reportPath = error.details?.reportPath ? resolve(error.details.reportPath) : null;
+      const failedCases = Array.isArray(error.details?.failedCases) ? error.details.failedCases : [];
+      let summary = null;
+      let hostBinary = null;
+      let runtimeCacheDiagnostics = null;
+      let runtimeObservabilityReportPath = null;
+      let runtimeInspectorSnapshotReportPath = null;
+      let phaserVerticalSliceEvidenceReportPath = null;
+      let phaserVerticalSliceEvidence = null;
+      let runtimeInspectorSnapshot = null;
+      let optionalModuleReadiness = null;
+
+      if (reportPath && existsSync(reportPath)) {
+        try {
+          const report = JSON.parse(readFileSync(reportPath, 'utf8'));
+          summary = report.summary || null;
+          hostBinary = report.hostBinary || null;
+          runtimeCacheDiagnostics = report.runtimeCacheDiagnostics || null;
+          runtimeObservabilityReportPath = report.runtimeObservability?.reportPath || null;
+          runtimeInspectorSnapshotReportPath = report.runtimeInspectorSnapshotReport?.reportPath || null;
+          phaserVerticalSliceEvidenceReportPath = report.phaserVerticalSliceEvidence?.reportPath || null;
+          phaserVerticalSliceEvidence = report.phaserVerticalSliceEvidence || null;
+          runtimeInspectorSnapshot = report.runtimeInspectorSnapshot || null;
+          optionalModuleReadiness = report.optionalModuleReadiness || null;
+        } catch {
+          summary = null;
+        }
+      }
+
+      if (args.json) {
+        io.log(JSON.stringify(formatJsonResult({
+          ok: false,
+          mode: args.mode,
+          reportPath,
+          optionalModuleReadiness,
+          runtimeObservabilityReportPath,
+          runtimeInspectorSnapshotReportPath,
+          phaserVerticalSliceEvidenceReportPath,
+          phaserVerticalSliceEvidence,
+          summary,
+          runtimeCacheDiagnostics,
+          runtimeInspectorSnapshot,
+          failedCases,
+          hostBinary,
+          error: error.message,
+        }), null, 2));
+      } else {
+        io.error('');
+        io.error('  aura conformance: FAIL');
+        io.error(`  ${error.message}`);
+        const hostBinaryLine = formatHostBinaryLine(hostBinary);
+        if (hostBinaryLine) {
+          io.error(hostBinaryLine);
+        }
+        if (reportPath) {
+          io.error(`  Report: ${reportPath}`);
+        }
+        io.error('');
+      }
+      return 1;
+    }
+
+    if (args.json) {
+      io.log(JSON.stringify(formatJsonResult({
+        ok: false,
+        mode: args.mode,
+        reportPath: null,
+        optionalModuleReadiness: null,
+        runtimeObservabilityReportPath: null,
+        runtimeInspectorSnapshotReportPath: null,
+        phaserVerticalSliceEvidenceReportPath: null,
+        phaserVerticalSliceEvidence: null,
+        summary: null,
+        runtimeCacheDiagnostics: null,
+        runtimeInspectorSnapshot: null,
+        failedCases: [],
+        error: error.message,
+      }), null, 2));
+    } else {
+      io.error('');
+      io.error(`  aura conformance error: ${error.message}`);
+      io.error('');
+    }
+    return 1;
+  }
+}
+
+async function main() {
+  const exitCode = await runConformanceCommand(process.argv.slice(2));
+  process.exitCode = exitCode;
+}
+
+const executedAsEntrypoint = process.argv[1] && fileURLToPath(import.meta.url) === resolve(process.argv[1]);
+if (executedAsEntrypoint) {
+  void main();
+}