@m4trix/evals 0.20.0 → 0.21.1

package/dist/cli-simple.js

@@ -6,8 +6,11 @@ import { resolve, relative, join, parse, dirname } from 'path';
 import * as jitiModule from 'jiti';
 import { writeFile, readdir, readFile, mkdir, appendFile } from 'fs/promises';
 import { pathToFileURL } from 'url';
-import { diffString } from 'json-diff';
-import React2, { useState, useEffect, useCallback } from 'react';
+import { diffLines } from 'diff';
+import stringify from 'fast-json-stable-stringify';
+import { cpus } from 'os';
+import * as React2 from 'react';
+import React2__default, { useState, useEffect, useCallback } from 'react';
 import { render, Box, Text } from 'ink';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
 
@@ -260,10 +263,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(preprocessForDiff(a, options));
+      const bStr = stringify(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(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 = 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 = diffLines(expectedKeys, actualKeys);
+    return formatDiffParts(parts2);
+  }
+  const expectedStr = toPrettyJson(expectedProcessed);
+  const actualStr = toPrettyJson(actualProcessed);
+  if (expectedStr === actualStr) {
+    return "";
+  }
+  const parts = 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")
@@ -651,13 +746,27 @@ function createArtifactPath(artifactDirectory, datasetId, runId) {
     `${datasetId}_${runId}_${nowIsoForFile()}.jsonl`
   );
 }
-function processOneTestCase(task, testCaseItem, totalEvaluations, publishEvent, persistenceQueue, updateSnapshot, completedRef, passedRef, failedRef) {
+function processOneTestCase(task, testCaseItem, totalEvaluations, publishEvent, persistenceQueue, updateSnapshot, startedRef, completedRef, passedRef, failedRef) {
   return 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-${randomUUID()}`;
       const started = Date.now();
+      const startedEvaluations = yield* 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);
@@ -803,6 +912,7 @@ var executeRunTask = (task, publishEvent, persistenceQueue, updateSnapshot) => E
   );
   const maxConcurrency = Math.max(1, task.maxConcurrency ?? 1);
   const completedRef = yield* Ref.make(0);
+  const startedRef = yield* Ref.make(0);
   const passedRef = yield* Ref.make(0);
   const failedRef = yield* Ref.make(0);
   const processTestCase = (testCaseItem) => processOneTestCase(
@@ -812,6 +922,7 @@ var executeRunTask = (task, publishEvent, persistenceQueue, updateSnapshot) => E
     publishEvent,
     persistenceQueue,
     updateSnapshot,
+    startedRef,
     completedRef,
     passedRef,
     failedRef
@@ -1287,8 +1398,9 @@ var EffectRunner = class {
     );
   }
 };
-
-// src/cli-simple/args.ts
+function getDefaultConcurrency() {
+  return Math.max(1, cpus().length);
+}
 function parseSimpleCliArgs(argv) {
   const args = {
     help: false,
@@ -1315,6 +1427,14 @@ function parseSimpleCliArgs(argv) {
       index += 1;
       continue;
     }
+    if ((token === "--concurrency" || token === "-c") && argv[index + 1]) {
+      const n = parseInt(argv[index + 1], 10);
+      if (!Number.isNaN(n) && n >= 1) {
+        args.concurrency = n;
+      }
+      index += 1;
+      continue;
+    }
     args.unknownArgs.push(token);
   }
   return args;
@@ -1322,9 +1442,12 @@ function parseSimpleCliArgs(argv) {
 function getSimpleCliUsage() {
   return [
     "Usage:",
-    "  eval-agents-simple run --dataset <datasetName> --evaluator <name-or-pattern>",
+    "  eval-agents-simple run --dataset <datasetName> --evaluator <name-or-pattern> [--concurrency N]",
     "  eval-agents-simple generate --dataset <datasetName>",
     "",
+    "Options:",
+    "  --concurrency, -c N   Max concurrent test cases (default: CPU count). Use 1 for sequential.",
+    "",
     "Pattern examples for --evaluator:",
     "  score-evaluator       exact name (case-insensitive)",
     '  "*score*"             wildcard pattern',
@@ -1463,7 +1586,7 @@ async function generateDatasetJsonCommandPlain(runner, datasetName) {
 async function generateDatasetJsonCommandInk(runner, datasetName) {
   return new Promise((resolve5, reject) => {
     const app = render(
-      React2.createElement(GenerateView, {
+      React2__default.createElement(GenerateView, {
         runner,
         datasetName,
         onComplete: (err) => {
@@ -1613,6 +1736,7 @@ function RunView({
   runner,
   datasetName,
   evaluatorPattern,
+  concurrency,
   onComplete
 }) {
   const [phase, setPhase] = useState(
@@ -1620,7 +1744,9 @@ function RunView({
   );
   const [runInfo, setRunInfo] = useState(null);
   const [testCases, setTestCases] = useState([]);
+  const [startedEvaluations, setStartedEvaluations] = useState(0);
   const [completedEvaluations, setCompletedEvaluations] = useState(0);
+  const [runningEvaluations, setRunningEvaluations] = useState([]);
   const [summary, setSummary] = useState(null);
   const [evaluatorNameById, setEvaluatorNameById] = useState(/* @__PURE__ */ new Map());
   const runEval = useCallback(async () => {
@@ -1657,6 +1783,25 @@ function RunView({
     let overallScoreCount = 0;
     const done = new Promise((resolve5) => {
       const unsubscribe = runner.subscribeRunEvents((event) => {
+        if (event.type === "TestCaseStarted") {
+          setStartedEvaluations(event.startedTestCases);
+          setRunningEvaluations((prev) => {
+            const withoutDuplicate = prev.filter(
+              (item) => !(item.testCaseId === event.testCaseId && item.rerunIndex === event.rerunIndex)
+            );
+            return [
+              ...withoutDuplicate,
+              {
+                testCaseId: event.testCaseId,
+                name: event.testCaseName,
+                rerunIndex: event.rerunIndex,
+                rerunTotal: event.rerunTotal,
+                startedTestCases: event.startedTestCases,
+                totalTestCases: event.totalTestCases
+              }
+            ];
+          });
+        }
         if (event.type === "TestCaseProgress") {
           for (const item of event.evaluatorScores) {
             const numeric = toNumericScoreFromScores(item.scores);
@@ -1723,6 +1868,11 @@ function RunView({
             };
             byId.set(event.testCaseId, merged);
             setCompletedEvaluations(event.completedTestCases);
+            setRunningEvaluations(
+              (running) => running.filter(
+                (item) => !(item.testCaseId === event.testCaseId && item.rerunIndex === event.rerunIndex)
+              )
+            );
             return Array.from(byId.values());
           });
         }
@@ -1734,7 +1884,8 @@ function RunView({
     });
     const snapshot = await runner.runDatasetWith({
       datasetId: dataset.id,
-      evaluatorIds: evaluators.map((item) => item.id)
+      evaluatorIds: evaluators.map((item) => item.id),
+      concurrency
     });
     setRunInfo({
       runId: snapshot.runId,
@@ -1762,7 +1913,7 @@ function RunView({
     });
     setPhase("completed");
     setTimeout(() => onComplete(), 200);
-  }, [runner, datasetName, evaluatorPattern, onComplete]);
+  }, [runner, datasetName, evaluatorPattern, concurrency, onComplete]);
   useEffect(() => {
     void runEval();
   }, [runEval]);
@@ -1798,12 +1949,38 @@ function RunView({
         runInfo.totalTestCases
       ] })
     ] }),
-    phase === "running" && /* @__PURE__ */ jsx(Box, { marginBottom: 1, children: /* @__PURE__ */ jsx(
-      Spinner,
-      {
-        label: `Evaluations ${completedEvaluations}/${runInfo?.totalTestCases ?? 0}`
-      }
-    ) }),
+    phase === "running" && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx(
+        Spinner,
+        {
+          label: `Evaluations ${completedEvaluations}/${runInfo?.totalTestCases ?? 0} completed \u2022 ${startedEvaluations}/${runInfo?.totalTestCases ?? 0} started`
+        }
+      ),
+      runningEvaluations.length > 0 && /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 1, children: runningEvaluations.map((item) => /* @__PURE__ */ jsxs(
+        Text,
+        {
+          color: "yellow",
+          children: [
+            "[running ",
+            item.startedTestCases,
+            "/",
+            item.totalTestCases,
+            "]",
+            " ",
+            item.name,
+            " ",
+            /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+              "(",
+              item.rerunIndex,
+              "/",
+              item.rerunTotal,
+              ")"
+            ] })
+          ]
+        },
+        `${item.testCaseId}:${item.rerunIndex}`
+      )) })
+    ] }),
     testCases.length > 0 && /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginBottom: 1, children: testCases.map((tc) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 0, children: [
       /* @__PURE__ */ jsxs(Text, { children: [
         /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
@@ -1884,7 +2061,7 @@ function RunView({
                 },
                 `${item.evaluatorId}-${s.id}-${idx}`
               );
-            }) : /* @__PURE__ */ jsx(Text, { color: "gray", children: "      n/a" }),
+            }) : /* @__PURE__ */ jsx(Text, { color: "gray", children: " n/a" }),
             !item.passed && item.logs && item.logs.length > 0 && /* @__PURE__ */ jsx(Box, { marginLeft: 2, flexDirection: "column", children: item.logs.map(
               (log, logIdx) => log.type === "diff" ? /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: getDiffLines(log).map(
                 ({ type, line }, lineIdx) => /* @__PURE__ */ jsx(
@@ -1942,9 +2119,9 @@ function RunView({
         /* @__PURE__ */ jsx(Text, { color: "magenta", children: "evaluator averages" }),
         Array.from(evaluatorNameById.entries()).map(([id, name]) => {
           const agg = summary.aggregates.get(id);
-          const scoreKeys = [...summary.scoreItemsByEvaluatorScore?.keys() ?? []].filter(
-            (k) => k.startsWith(`${id}:`)
-          );
+          const scoreKeys = [
+            ...summary.scoreItemsByEvaluatorScore?.keys() ?? []
+          ].filter((k) => k.startsWith(`${id}:`));
           if (scoreKeys.length === 0) {
             return /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
               "- ",
@@ -2252,7 +2429,7 @@ function formatEvaluatorScoreLine(name, scores, passed, metrics, options) {
   }
   return lines;
 }
-async function runSimpleEvalCommandPlain(runner, datasetName, evaluatorPattern) {
+async function runSimpleEvalCommandPlain(runner, datasetName, evaluatorPattern, concurrency) {
   const dataset = await runner.resolveDatasetByName(datasetName);
   if (!dataset) {
     const known = await runner.collectDatasets();
@@ -2278,9 +2455,11 @@ async function runSimpleEvalCommandPlain(runner, datasetName, evaluatorPattern)
   let overallScoreTotal = 0;
   let overallScoreSumSq = 0;
   let overallScoreCount = 0;
+  let startedCount = 0;
   let completedCount = 0;
   let totalCount = 0;
   let runFinished = false;
+  const inFlightReruns = /* @__PURE__ */ new Set();
   const spinnerFrames = ["\u280B", "\u2819", "\u2838", "\u2834", "\u2826", "\u2807"];
   let spinnerIndex = 0;
   function clearLine() {
@@ -2304,7 +2483,7 @@ async function runSimpleEvalCommandPlain(runner, datasetName, evaluatorPattern)
       `\r${colorize(frame, ansi2.cyan)} Running evaluations ${colorize(
         `${completedCount}/${totalCount}`,
         ansi2.bold
-      )} ${colorize("(live)", ansi2.dim)}`
+      )} completed ${colorize(`${startedCount}/${totalCount}`, ansi2.bold)} started ${colorize(`(${inFlightReruns.size} running)`, ansi2.dim)}`
     );
   }
   let lastPrintedTestCaseId = null;
@@ -2312,8 +2491,19 @@ async function runSimpleEvalCommandPlain(runner, datasetName, evaluatorPattern)
   let spinnerTimer;
   const done = new Promise((resolve5) => {
     const unsubscribe = runner.subscribeRunEvents((event) => {
+      if (event.type === "TestCaseStarted") {
+        startedCount = event.startedTestCases;
+        inFlightReruns.add(`${event.testCaseId}:${event.rerunIndex}`);
+        clearLine();
+        process.stdout.write(
+          `${colorize(`[started ${event.startedTestCases}/${event.totalTestCases}]`, ansi2.cyan)} ${event.testCaseName} ${colorize(`(${event.rerunIndex}/${event.rerunTotal})`, ansi2.cyan)} ${colorize("(running)", ansi2.dim)}
+`
+        );
+        drawSpinner();
+      }
       if (event.type === "TestCaseProgress") {
         completedCount = event.completedTestCases;
+        inFlightReruns.delete(`${event.testCaseId}:${event.rerunIndex}`);
         const numericScores = event.evaluatorScores.map((item) => toNumericScoreFromScores(item.scores)).filter((item) => item !== void 0);
         const averageScore = numericScores.length > 0 ? numericScores.reduce((sum, value) => sum + value, 0) / numericScores.length : void 0;
         const testCaseId = event.testCaseId;
@@ -2429,7 +2619,8 @@ async function runSimpleEvalCommandPlain(runner, datasetName, evaluatorPattern)
   });
   const snapshot = await runner.runDatasetWith({
     datasetId: dataset.id,
-    evaluatorIds: evaluators.map((item) => item.id)
+    evaluatorIds: evaluators.map((item) => item.id),
+    concurrency
   });
   totalCount = snapshot.totalTestCases;
   console.log(colorize("=== Eval Run Started ===", `${ansi2.bold}${ansi2.cyan}`));
@@ -2518,13 +2709,14 @@ async function runSimpleEvalCommandPlain(runner, datasetName, evaluatorPattern)
   }
   console.log(`- artifact: ${colorize(completed.artifactPath, ansi2.dim)}`);
 }
-async function runSimpleEvalCommandInk(runner, datasetName, evaluatorPattern) {
+async function runSimpleEvalCommandInk(runner, datasetName, evaluatorPattern, concurrency) {
   return new Promise((resolve5, reject) => {
     const app = render(
       React2.createElement(RunView, {
         runner,
         datasetName,
         evaluatorPattern,
+        concurrency,
         onComplete: (err) => {
           app.unmount();
           if (err) {
@@ -2571,10 +2763,12 @@ async function main() {
   const runner = createRunner();
   try {
     if (args.command === "run") {
+      const concurrency = args.concurrency ?? getDefaultConcurrency();
       await (useInk ? runSimpleEvalCommandInk : runSimpleEvalCommandPlain)(
         runner,
         args.datasetName,
-        args.evaluatorPattern
+        args.evaluatorPattern,
+        concurrency
       );
       return;
     }