@orangepro/orangepro-mcp 0.1.0

package/scripts/spikes/dynamic-proof-vitest-reporter.mjs

@@ -0,0 +1,81 @@
+import { writeFileSync } from "node:fs";
+
+function safeValue(value) {
+  if (value === undefined) {
+    return undefined;
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value === null) {
+    return value;
+  }
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return String(value);
+  }
+}
+
+function serializeError(error) {
+  const detail = {
+    name: error?.name ?? null,
+    constructorName: error?.constructor?.name ?? null,
+    message: error?.message ?? null,
+    stack: error?.stack ?? null
+  };
+  for (const key of ["actual", "expected", "operator", "showDiff", "ok", "diff"]) {
+    if (Object.prototype.hasOwnProperty.call(error ?? {}, key)) {
+      detail[key] = safeValue(error[key]);
+    }
+  }
+  return detail;
+}
+
+function failureMessage(error) {
+  if (typeof error?.stack === "string" && error.stack.trim()) {
+    return error.stack;
+  }
+  const name = error?.name ?? "Error";
+  const message = error?.message ?? String(error);
+  return `${name}: ${message}`;
+}
+
+function collectAssertions(task, ancestors = []) {
+  const children = Array.isArray(task?.tasks) ? task.tasks : [];
+  if (children.length > 0) {
+    return children.flatMap(child => collectAssertions(child, [...ancestors, task.name].filter(Boolean)));
+  }
+  const errors = Array.isArray(task?.result?.errors) ? task.result.errors : [];
+  const state = task?.result?.state;
+  return [{
+    ancestorTitles: ancestors,
+    fullName: [...ancestors, task?.name].filter(Boolean).join(" "),
+    status: state === "fail" ? "failed" : state === "pass" ? "passed" : "pending",
+    title: task?.name ?? "",
+    failureMessages: errors.map(failureMessage),
+    failureDetails: errors.map(serializeError)
+  }];
+}
+
+export default class DynamicProofReporter {
+  writeReport(files) {
+    const report = {
+      testResults: files.map(file => ({
+        name: file.filepath ?? file.name ?? file.task?.file?.filepath ?? file.task?.file?.name ?? "",
+        assertionResults: collectAssertions(file.task ?? file)
+      }))
+    };
+    const body = `${JSON.stringify(report, null, 2)}\n`;
+    if (process.env.OPRO_DYNAMIC_PROOF_REPORT) {
+      writeFileSync(process.env.OPRO_DYNAMIC_PROOF_REPORT, body);
+      return;
+    }
+    process.stdout.write(body);
+  }
+
+  onFinished(files) {
+    this.writeReport(files);
+  }
+
+  onTestRunEnd(modules) {
+    this.writeReport(Array.from(modules ?? []));
+  }
+}

package/scripts/spikes/failure-summary.mjs

@@ -0,0 +1,29 @@
+// Pick the reportable line from a baseline/mutant failure blob (a runner suite message,
+// an assertion failure message, or captured stderr).
+//
+// Why: build tools (esbuild / Vite / Rollup) print NON-FATAL warnings — e.g.
+// `[MIXED_EXPORTS]`, esbuild's `▲ [WARNING]`, Rollup's `(!) ...` prefix — to stderr
+// BEFORE the fatal error that actually failed the baseline. Grabbing the first line then
+// surfaced the warning (Medplum reported `[MIXED_EXPORTS]` instead of its real blocker),
+// which also starved the R-1 classifier of the true error. This skips known build-tool
+// warning lines and surfaces the first line that reads like the real failure.
+//
+// DIAGNOSTIC ONLY: the returned line feeds the report + classifier reason. It NEVER
+// affects the proof judgment (baseline_green / mutant_failed_assertion / target_not_mocked
+// are computed from exit codes + assertion results, not this string). Fail-safe: if every
+// line looks like a warning (or there is nothing better), it returns the first line — the
+// prior behaviour — so it can never hide a failure, only sharpen the label.
+const BUILD_WARNING_LINE =
+  /^(?:\(!\)|▲\s*\[WARNING\]|\[(?:MIXED_EXPORTS|CIRCULAR_DEPENDENCY|UNUSED_EXTERNAL_IMPORT|PLUGIN_WARNING|THIS_IS_UNDEFINED|EVAL|SOURCEMAP_ERROR|INVALID_ANNOTATION|EMPTY_BUNDLE)\]|\(node:\d+\)\s+ExperimentalWarning:|--import 'data:text\/javascript,import \{ register \} from "node:module"|\(Use `node --trace-warnings)/;
+
+export function pickReportableFailureLine(text) {
+  const lines = String(text ?? "")
+    .split(/\r?\n/)
+    .map(line => line.trim())
+    .filter(Boolean);
+  if (lines.length === 0) {
+    return "";
+  }
+  const fatal = lines.find(line => !BUILD_WARNING_LINE.test(line));
+  return fatal ?? lines[0];
+}