@m4trix/evals 0.21.0 → 0.22.0

package/dist/cli.cjs

@@ -13,7 +13,8 @@ var fs = require('fs');
 var jitiModule = require('jiti');
 var promises = require('fs/promises');
 var url = require('url');
-var jsonDiff = require('json-diff');
+var diff = require('diff');
+var stringify = require('fast-json-stable-stringify');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -38,6 +39,7 @@ function _interopNamespace(e) {
 
 var React2__default = /*#__PURE__*/_interopDefault(React2);
 var jitiModule__namespace = /*#__PURE__*/_interopNamespace(jitiModule);
+var stringify__default = /*#__PURE__*/_interopDefault(stringify);
 
 var SEP = "  ";
 var ARROW = "\u203A";
@@ -1004,10 +1006,102 @@ async function collectTestCasesFromFiles(config) {
   );
   return found.flat();
 }
+function preprocessForDiff(value, options) {
+  if (options?.sort && Array.isArray(value)) {
+    return [...value].sort((a, b) => {
+      const aStr = stringify__default.default(preprocessForDiff(a, options));
+      const bStr = stringify__default.default(preprocessForDiff(b, options));
+      return aStr.localeCompare(bStr);
+    }).map((item) => preprocessForDiff(item, options));
+  }
+  if (value !== null && typeof value === "object" && !Array.isArray(value) && options?.excludeKeys) {
+    const keys = Array.isArray(options.excludeKeys) ? options.excludeKeys : options.excludeKeys.split(",").map((k) => k.trim());
+    const filtered = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (!keys.includes(k)) {
+        filtered[k] = preprocessForDiff(v, options);
+      }
+    }
+    return filtered;
+  }
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = preprocessForDiff(v, options);
+    }
+    return result;
+  }
+  if (typeof value === "number" && options?.precision !== void 0) {
+    return Number(value.toFixed(options.precision));
+  }
+  return value;
+}
+function toPrettyJson(value) {
+  const str = stringify__default.default(value);
+  try {
+    const parsed = JSON.parse(str);
+    return JSON.stringify(parsed, null, 2);
+  } catch {
+    return str;
+  }
+}
+function formatDiffParts(parts) {
+  const lines = [];
+  for (const part of parts) {
+    const prefix = part.added ? "+ " : part.removed ? "- " : "";
+    const partLines = part.value.split("\n");
+    for (let i = 0; i < partLines.length; i++) {
+      const line = partLines[i];
+      if (i === partLines.length - 1 && line === "")
+        continue;
+      lines.push(prefix + line);
+    }
+  }
+  return lines.join("\n");
+}
 function createDiffString(expected, actual, diffOptions) {
-  const opts = { ...diffOptions, color: false };
-  const result = jsonDiff.diffString(expected, actual, opts);
-  return typeof result === "string" ? result : "";
+  const expectedProcessed = preprocessForDiff(expected, diffOptions);
+  const actualProcessed = preprocessForDiff(actual, diffOptions);
+  if (diffOptions?.keysOnly) {
+    const expectedKeys = JSON.stringify(
+      extractKeys(expectedProcessed),
+      null,
+      2
+    );
+    const actualKeys = JSON.stringify(
+      extractKeys(actualProcessed),
+      null,
+      2
+    );
+    const parts2 = diff.diffLines(expectedKeys, actualKeys);
+    return formatDiffParts(parts2);
+  }
+  const expectedStr = toPrettyJson(expectedProcessed);
+  const actualStr = toPrettyJson(actualProcessed);
+  if (expectedStr === actualStr) {
+    return "";
+  }
+  const parts = diff.diffLines(expectedStr, actualStr);
+  if (diffOptions?.outputNewOnly) {
+    const filtered = parts.filter(
+      (p) => p.added === true
+    );
+    return formatDiffParts(filtered);
+  }
+  return formatDiffParts(parts);
+}
+function extractKeys(value) {
+  if (value === null || typeof value !== "object") {
+    return "\xB7";
+  }
+  if (Array.isArray(value)) {
+    return value.map(extractKeys);
+  }
+  const result = {};
+  for (const [k, v] of Object.entries(value)) {
+    result[k] = extractKeys(v);
+  }
+  return result;
 }
 function formatLogMessage(msg) {
   if (typeof msg === "string")
@@ -1349,6 +1443,20 @@ function readOutput(testCase) {
   }
   return candidate.getOutput();
 }
+function buildEvaluationUnits(testCases) {
+  const units = [];
+  for (const testCaseItem of testCases) {
+    const rerunTotal = typeof testCaseItem.testCase.getReruns === "function" ? testCaseItem.testCase.getReruns() : 1;
+    for (let r = 0; r < rerunTotal; r++) {
+      units.push({
+        testCaseItem,
+        rerunIndex: r + 1,
+        rerunTotal
+      });
+    }
+  }
+  return units;
+}
 function nowIsoForFile() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
 }
@@ -1358,157 +1466,171 @@ function createArtifactPath(artifactDirectory, datasetId, runId) {
     `${datasetId}_${runId}_${nowIsoForFile()}.jsonl`
   );
 }
-function processOneTestCase(task, testCaseItem, totalEvaluations, publishEvent, persistenceQueue, updateSnapshot, startedRef, completedRef, passedRef, failedRef) {
+function processOneEvaluation(task, unit, totalEvaluations, publishEvent, persistenceQueue, updateSnapshot, startedRef, completedRef, passedRef, failedRef, testCaseResultsRef) {
+  const { testCaseItem, rerunIndex, rerunTotal } = unit;
   return effect.Effect.gen(function* () {
-    const reruns = typeof testCaseItem.testCase.getReruns === "function" ? testCaseItem.testCase.getReruns() : 1;
-    const rerunPassed = [];
-    for (let r = 0; r < reruns; r++) {
-      const evaluatorRunId = `run-${crypto.randomUUID()}`;
-      const started = Date.now();
-      const startedEvaluations = yield* effect.Ref.modify(startedRef, (n) => [
-        n + 1,
-        n + 1
-      ]);
-      yield* publishEvent({
-        type: "TestCaseStarted",
-        runId: task.runId,
-        testCaseId: testCaseItem.id,
-        testCaseName: testCaseItem.testCase.getName(),
-        startedTestCases: startedEvaluations,
-        totalTestCases: totalEvaluations,
-        rerunIndex: r + 1,
-        rerunTotal: reruns
-      });
-      const evaluatorScores = [];
-      let testCaseError;
-      const output = readOutput(testCaseItem.testCase);
-      for (const { id: evaluatorId, evaluator } of task.evaluators) {
-        const evaluateFn = evaluator.getEvaluateFn();
-        if (!evaluateFn) {
-          continue;
-        }
-        const logs = [];
-        const logDiff = (expected, actual, options) => {
-          logs.push(createDiffLogEntry(expected, actual, options));
-        };
-        const log = (message, options) => {
-          logs.push(createLogEntry(message, options));
-        };
-        const createError = (message, options) => {
-          const entry = createLogEntry(message, options);
-          const error = message instanceof Error ? message : new Error(entry.message);
-          error[evaluatorErrorLogEntryKey] = entry;
-          return error;
-        };
-        try {
-          const ctx = yield* effect.Effect.promise(
-            () => Promise.resolve(evaluator.resolveContext())
-          );
-          const result = yield* effect.Effect.promise(
-            () => Promise.resolve().then(
-              () => evaluateFn({
-                input: testCaseItem.testCase.getInput(),
-                ctx,
-                output,
-                meta: {
-                  triggerId: task.triggerId,
-                  runId: evaluatorRunId,
-                  datasetId: task.datasetId
-                },
-                logDiff,
-                log,
-                createError
-              })
-            )
-          );
-          if (result instanceof Error) {
-            const evaluatorError = result;
-            const taggedEntry = evaluatorError[evaluatorErrorLogEntryKey];
-            logs.push(taggedEntry ?? createLogEntry(result));
-            testCaseError = result.message;
-            evaluatorScores.push({
-              evaluatorId,
-              scores: [],
-              passed: false,
-              logs: logs.length > 0 ? logs : void 0
-            });
-            continue;
-          }
-          const { scores, metrics } = normalizeResult(result);
-          const passed2 = computeEvaluatorPassed(evaluator, result, scores);
-          evaluatorScores.push({
-            evaluatorId,
-            scores,
-            passed: passed2,
-            metrics,
-            logs: logs.length > 0 ? logs : void 0
-          });
-        } catch (error) {
-          if (error instanceof Error) {
-            const taggedEntry = error[evaluatorErrorLogEntryKey];
-            logs.push(taggedEntry ?? createLogEntry(error));
-          }
-          testCaseError = error instanceof Error ? error.message : "Evaluator execution failed";
+    const evaluatorRunId = `run-${crypto.randomUUID()}`;
+    const started = Date.now();
+    const startedEvaluations = yield* effect.Ref.modify(startedRef, (n) => [
+      n + 1,
+      n + 1
+    ]);
+    yield* publishEvent({
+      type: "TestCaseStarted",
+      runId: task.runId,
+      testCaseId: testCaseItem.id,
+      testCaseName: testCaseItem.testCase.getName(),
+      startedTestCases: startedEvaluations,
+      totalTestCases: totalEvaluations,
+      rerunIndex,
+      rerunTotal
+    });
+    const evaluatorScores = [];
+    let testCaseError;
+    const output = readOutput(testCaseItem.testCase);
+    for (const { id: evaluatorId, evaluator } of task.evaluators) {
+      const evaluateFn = evaluator.getEvaluateFn();
+      if (!evaluateFn) {
+        continue;
+      }
+      const logs = [];
+      const logDiff = (expected, actual, options) => {
+        logs.push(createDiffLogEntry(expected, actual, options));
+      };
+      const log = (message, options) => {
+        logs.push(createLogEntry(message, options));
+      };
+      const createError = (message, options) => {
+        const entry = createLogEntry(message, options);
+        const error = message instanceof Error ? message : new Error(entry.message);
+        error[evaluatorErrorLogEntryKey] = entry;
+        return error;
+      };
+      try {
+        const ctx = yield* effect.Effect.promise(
+          () => Promise.resolve(evaluator.resolveContext())
+        );
+        const result = yield* effect.Effect.promise(
+          () => Promise.resolve().then(
+            () => evaluateFn({
+              input: testCaseItem.testCase.getInput(),
+              ctx,
+              output,
+              meta: {
+                triggerId: task.triggerId,
+                runId: evaluatorRunId,
+                datasetId: task.datasetId
+              },
+              logDiff,
+              log,
+              createError
+            })
+          )
+        );
+        if (result instanceof Error) {
+          const evaluatorError = result;
+          const taggedEntry = evaluatorError[evaluatorErrorLogEntryKey];
+          logs.push(taggedEntry ?? createLogEntry(result));
+          testCaseError = result.message;
           evaluatorScores.push({
             evaluatorId,
             scores: [],
             passed: false,
             logs: logs.length > 0 ? logs : void 0
           });
+          continue;
+        }
+        const { scores, metrics } = normalizeResult(result);
+        const passed = computeEvaluatorPassed(evaluator, result, scores);
+        evaluatorScores.push({
+          evaluatorId,
+          scores,
+          passed,
+          metrics,
+          logs: logs.length > 0 ? logs : void 0
+        });
+      } catch (error) {
+        if (error instanceof Error) {
+          const taggedEntry = error[evaluatorErrorLogEntryKey];
+          logs.push(taggedEntry ?? createLogEntry(error));
         }
+        testCaseError = error instanceof Error ? error.message : "Evaluator execution failed";
+        evaluatorScores.push({
+          evaluatorId,
+          scores: [],
+          passed: false,
+          logs: logs.length > 0 ? logs : void 0
+        });
       }
-      const rerunPassedThis = evaluatorScores.every((s) => s.passed);
-      rerunPassed.push(rerunPassedThis);
-      const completedEvaluations = yield* effect.Ref.modify(completedRef, (n) => [
-        n + 1,
-        n + 1
-      ]);
-      const progressEvent = {
-        type: "TestCaseProgress",
-        runId: task.runId,
-        testCaseId: testCaseItem.id,
-        testCaseName: testCaseItem.testCase.getName(),
-        completedTestCases: completedEvaluations,
-        totalTestCases: totalEvaluations,
-        rerunIndex: r + 1,
-        rerunTotal: reruns,
-        passed: rerunPassedThis,
-        durationMs: Date.now() - started,
-        evaluatorScores,
-        output,
-        errorMessage: testCaseError
-      };
-      updateSnapshot(task.runId, (snapshot) => ({
-        ...snapshot,
-        completedTestCases: completedEvaluations
-      }));
-      yield* publishEvent(progressEvent);
-      yield* effect.Queue.offer(persistenceQueue, {
-        runId: task.runId,
-        artifactPath: task.snapshot.artifactPath,
-        payload: progressEvent
-      });
     }
-    const testCasePassed = rerunPassed.every(Boolean);
-    if (testCasePassed) {
-      yield* effect.Ref.update(passedRef, (n) => n + 1);
-    } else {
-      yield* effect.Ref.update(failedRef, (n) => n + 1);
-    }
-    const [passed, failed] = yield* effect.Effect.all([
-      effect.Ref.get(passedRef),
-      effect.Ref.get(failedRef)
+    const rerunPassedThis = evaluatorScores.every((s) => s.passed);
+    const completedEvaluations = yield* effect.Ref.modify(completedRef, (n) => [
+      n + 1,
+      n + 1
     ]);
-    updateSnapshot(task.runId, (snapshot) => ({
+    const progressEvent = {
+      type: "TestCaseProgress",
+      runId: task.runId,
+      testCaseId: testCaseItem.id,
+      testCaseName: testCaseItem.testCase.getName(),
+      completedTestCases: completedEvaluations,
+      totalTestCases: totalEvaluations,
+      rerunIndex,
+      rerunTotal,
+      passed: rerunPassedThis,
+      durationMs: Date.now() - started,
+      evaluatorScores,
+      output,
+      errorMessage: testCaseError
+    };
+    yield* updateSnapshot(task.runId, (snapshot) => ({
       ...snapshot,
-      passedTestCases: passed,
-      failedTestCases: failed
+      completedTestCases: completedEvaluations
     }));
+    yield* publishEvent(progressEvent);
+    yield* effect.Queue.offer(persistenceQueue, {
+      runId: task.runId,
+      artifactPath: task.snapshot.artifactPath,
+      payload: progressEvent
+    });
+    const testCaseCompleted = yield* effect.Ref.modify(
+      testCaseResultsRef,
+      (map) => {
+        const key = testCaseItem.id;
+        const existing = map.get(key) ?? { completedCount: 0, results: [] };
+        const newResults = [...existing.results, rerunPassedThis];
+        const newCompletedCount = existing.completedCount + 1;
+        const isLast = newCompletedCount === rerunTotal;
+        const newMap = new Map(map);
+        newMap.set(key, {
+          completedCount: newCompletedCount,
+          results: newResults
+        });
+        const outcome = isLast ? newResults.every(Boolean) : null;
+        return [outcome, newMap];
+      }
+    );
+    if (testCaseCompleted !== null) {
+      if (testCaseCompleted) {
+        yield* effect.Ref.update(passedRef, (n) => n + 1);
+      } else {
+        yield* effect.Ref.update(failedRef, (n) => n + 1);
+      }
+      const [passed, failed] = yield* effect.Effect.all([
+        effect.Ref.get(passedRef),
+        effect.Ref.get(failedRef)
+      ]);
+      yield* updateSnapshot(task.runId, (snapshot) => ({
+        ...snapshot,
+        passedTestCases: passed,
+        failedTestCases: failed
+      }));
+    }
   });
 }
 var executeRunTask = (task, publishEvent, persistenceQueue, updateSnapshot) => effect.Effect.gen(function* () {
   const startedAt = Date.now();
-  updateSnapshot(task.runId, (snapshot) => ({
+  yield* updateSnapshot(task.runId, (snapshot) => ({
     ...snapshot,
     status: "running",
     startedAt
@@ -1527,9 +1649,13 @@ var executeRunTask = (task, publishEvent, persistenceQueue, updateSnapshot) => e
   const startedRef = yield* effect.Ref.make(0);
   const passedRef = yield* effect.Ref.make(0);
   const failedRef = yield* effect.Ref.make(0);
-  const processTestCase = (testCaseItem) => processOneTestCase(
+  const testCaseResultsRef = yield* effect.Ref.make(
+    /* @__PURE__ */ new Map()
+  );
+  const evaluationUnits = buildEvaluationUnits(task.testCases);
+  const processEvaluation = (unit) => processOneEvaluation(
     task,
-    testCaseItem,
+    unit,
     totalEvaluations,
     publishEvent,
     persistenceQueue,
@@ -1537,11 +1663,12 @@ var executeRunTask = (task, publishEvent, persistenceQueue, updateSnapshot) => e
     startedRef,
     completedRef,
     passedRef,
-    failedRef
+    failedRef,
+    testCaseResultsRef
   );
   yield* effect.Effect.forEach(
-    task.testCases,
-    processTestCase,
+    evaluationUnits,
+    processEvaluation,
     maxConcurrency > 1 ? { concurrency: maxConcurrency } : void 0
   );
   const [completedEvaluations, passedUniqueTestCases, failedUniqueTestCases] = yield* effect.Effect.all([
@@ -1559,7 +1686,7 @@ var executeRunTask = (task, publishEvent, persistenceQueue, updateSnapshot) => e
     totalTestCases: task.testCases.length,
     artifactPath: task.snapshot.artifactPath
   };
-  updateSnapshot(task.runId, (snapshot) => ({
+  yield* updateSnapshot(task.runId, (snapshot) => ({
     ...snapshot,
     status: "completed",
     completedTestCases: completedEvaluations,
@@ -1842,7 +1969,9 @@ var EffectRunner = class {
     this.persistenceQueue = effect.Effect.runSync(
       effect.Queue.unbounded()
     );
-    this.snapshots = /* @__PURE__ */ new Map();
+    this.snapshotsRef = effect.Effect.runSync(
+      effect.Ref.make(/* @__PURE__ */ new Map())
+    );
     this.listeners = /* @__PURE__ */ new Set();
     this.datasetsById = /* @__PURE__ */ new Map();
     this.evaluatorsById = /* @__PURE__ */ new Map();
@@ -1945,7 +2074,13 @@ var EffectRunner = class {
       status: "queued",
       artifactPath
     };
-    this.snapshots.set(runId, snapshot);
+    await effect.Effect.runPromise(
+      effect.Ref.update(this.snapshotsRef, (map) => {
+        const next = new Map(map);
+        next.set(runId, snapshot);
+        return next;
+      })
+    );
     const queuedEvent = {
       type: "RunQueued",
       runId,
@@ -1986,12 +2121,12 @@ var EffectRunner = class {
     };
   }
   getRunSnapshot(runId) {
-    return this.snapshots.get(runId);
+    return effect.Effect.runSync(effect.Ref.get(this.snapshotsRef)).get(runId);
   }
   getAllRunSnapshots() {
-    return Array.from(this.snapshots.values()).sort(
-      (a, b) => b.queuedAt - a.queuedAt
-    );
+    return Array.from(
+      effect.Effect.runSync(effect.Ref.get(this.snapshotsRef)).values()
+    ).sort((a, b) => b.queuedAt - a.queuedAt);
   }
   async loadRunSnapshotsFromArtifacts() {
     return loadRunSnapshotsFromArtifacts(this.config);
@@ -2020,11 +2155,15 @@ var EffectRunner = class {
     );
   }
   updateSnapshot(runId, updater) {
-    const existing = this.snapshots.get(runId);
-    if (!existing) {
-      return;
-    }
-    this.snapshots.set(runId, updater(existing));
+    return effect.Ref.modify(this.snapshotsRef, (map) => {
+      const existing = map.get(runId);
+      if (!existing) {
+        return [void 0, map];
+      }
+      const next = new Map(map);
+      next.set(runId, updater(existing));
+      return [void 0, next];
+    }).pipe(effect.Effect.asVoid);
   }
   publishEvent(event) {
     return effect.Effect.sync(() => {