@vitest-evals/github-reporter 0.15.0 → 0.16.1

package/dist/index.js

@@ -22,9 +22,16 @@ var index_exports = {};
 __export(index_exports, {
   buildCheckAnnotations: () => buildCheckAnnotations,
   collectEvalReport: () => collectEvalReport,
+  computePassRate: () => computePassRate,
+  evaluateEvalGate: () => evaluateEvalGate,
+  formatPercent: () => formatPercent,
   publishCheckRun: () => publishCheckRun,
+  publishEvalReport: () => publishEvalReport,
+  renderGateWorkflowCommand: () => renderGateWorkflowCommand,
   renderJobSummary: () => renderJobSummary,
-  renderWorkflowCommands: () => renderWorkflowCommands
+  renderWorkflowCommands: () => renderWorkflowCommands,
+  resolveCheckDetailsUrl: () => resolveCheckDetailsUrl,
+  resolveCheckSha: () => resolveCheckSha
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -297,9 +304,10 @@ var DEFAULT_MAX_CHECK_ANNOTATIONS = 50;
 var MAX_CHECK_FIELD_LENGTH = 64e3;
 function renderWorkflowCommands(report, options = {}) {
   const maxAnnotations = options.maxAnnotations ?? DEFAULT_MAX_WORKFLOW_ANNOTATIONS;
+  const command = caseAnnotationCommand(options.gate);
   return report.failures.filter(hasAnnotationLocation).slice(0, maxAnnotations).map(
     (testCase) => formatWorkflowCommand({
-      command: "error",
+      command,
       properties: {
         file: testCase.displayFile,
         line: String(testCase.location.line),
@@ -315,11 +323,12 @@ function buildCheckAnnotations(report, options = {}) {
     options.maxAnnotations ?? DEFAULT_MAX_CHECK_ANNOTATIONS,
     DEFAULT_MAX_CHECK_ANNOTATIONS
   );
+  const annotationLevel = caseAnnotationLevel(options.gate);
   return report.failures.filter(hasAnnotationLocation).slice(0, maxAnnotations).map((testCase) => ({
     path: testCase.displayFile,
     start_line: testCase.location.line,
     end_line: testCase.location.line,
-    annotation_level: "failure",
+    annotation_level: annotationLevel,
     title: truncate(
       `${testCase.primaryFailure?.judgeName ?? "vitest-evals"} - ${testCase.displayName}`,
       255
@@ -331,6 +340,12 @@ function buildCheckAnnotations(report, options = {}) {
     raw_details: truncate(formatRawDetails(testCase), MAX_CHECK_FIELD_LENGTH)
   }));
 }
+function caseAnnotationCommand(gate) {
+  return gate?.ok ? "warning" : "error";
+}
+function caseAnnotationLevel(gate) {
+  return gate?.ok ? "warning" : "failure";
+}
 function hasAnnotationLocation(testCase) {
   return Boolean(testCase.location);
 }
@@ -390,6 +405,167 @@ function formatWorkflowCommand({
   return `::${command} ${renderedProperties}::${escapeCommandData(message)}`;
 }
 
+// src/gate.ts
+function evaluateEvalGate(report, policy = {}) {
+  const minPassRate = resolveMinPassRate(policy);
+  const minScoreAverage = policy.minScoreAverage;
+  const enforced = minPassRate !== void 0 || minScoreAverage !== void 0 || policy.failOnFailures === true;
+  const passRate = computePassRate(report);
+  const counts = formatEvalCounts(report, passRate);
+  if (!enforced) {
+    const ok = report.status === "passed";
+    return {
+      ok,
+      status: ok ? "passed" : "failed",
+      enforced: false,
+      passRate,
+      title: defaultCheckTitle(report),
+      message: ok ? `eval report passed: ${counts}` : `eval report failed: ${counts}`
+    };
+  }
+  const nonEvalFailures = Math.max(
+    0,
+    report.totals.failed - report.totals.evalFailed
+  );
+  if (nonEvalFailures > 0) {
+    return {
+      ok: false,
+      status: "failed",
+      enforced: true,
+      passRate,
+      title: "Eval report hard failure",
+      message: `${formatNumber(nonEvalFailures)} non-eval test failure${nonEvalFailures === 1 ? "" : "s"}; ${counts}`
+    };
+  }
+  if (report.totals.evalTotal === 0) {
+    return {
+      ok: false,
+      status: "failed",
+      enforced: true,
+      passRate: null,
+      title: "Eval report hard failure",
+      message: "no eval cases were reported"
+    };
+  }
+  if (report.status === "failed" && report.totals.failed === 0 && report.failures.length === 0) {
+    return {
+      ok: false,
+      status: "failed",
+      enforced: true,
+      passRate,
+      title: "Eval report hard failure",
+      message: `vitest run failed without counted test failures; ${counts}`
+    };
+  }
+  if (minPassRate !== void 0 && (passRate === null || passRate + Number.EPSILON < minPassRate)) {
+    return {
+      ok: false,
+      status: "failed",
+      enforced: true,
+      passRate,
+      title: `Eval pass rate ${formatPercent(passRate)} \u2014 required ${formatPercent(minPassRate)}`,
+      message: `eval pass rate below floor: ${counts}; required >= ${formatPercent(minPassRate)}`
+    };
+  }
+  if (minScoreAverage !== void 0) {
+    const average = report.score?.average;
+    if (average === void 0 || !Number.isFinite(average)) {
+      return {
+        ok: false,
+        status: "failed",
+        enforced: true,
+        passRate,
+        title: "Eval score gate failed",
+        message: `no score average available; required avg score >= ${formatScore(minScoreAverage)}`
+      };
+    }
+    if (average + Number.EPSILON < minScoreAverage) {
+      return {
+        ok: false,
+        status: "failed",
+        enforced: true,
+        passRate,
+        title: `Avg score ${formatScore(average)} \u2014 required ${formatScore(minScoreAverage)}`,
+        message: `avg score below floor: ${counts}; required avg score >= ${formatScore(minScoreAverage)}`
+      };
+    }
+  }
+  return {
+    ok: true,
+    status: "passed",
+    enforced: true,
+    passRate,
+    title: enforcedPassTitle(report, passRate, minPassRate, minScoreAverage),
+    message: `eval gate passed: ${counts}${formatFloorSuffix(minPassRate, minScoreAverage)}`
+  };
+}
+function computePassRate(report) {
+  if (report.totals.evalTotal <= 0) {
+    return null;
+  }
+  return report.totals.evalPassed / report.totals.evalTotal;
+}
+function formatPercent(value) {
+  if (value == null || !Number.isFinite(value)) {
+    return "n/a";
+  }
+  return `${(value * 100).toFixed(1)}%`;
+}
+function renderGateWorkflowCommand(gate) {
+  if (gate.ok || !gate.enforced) {
+    return void 0;
+  }
+  return `::error title=${escapeCommandProperty(gate.title)}::${escapeCommandData(gate.message)}`;
+}
+function resolveMinPassRate(policy) {
+  const configured = policy.minPassRate;
+  if (policy.failOnFailures) {
+    if (configured === void 0) {
+      return 1;
+    }
+    return Math.max(configured, 1);
+  }
+  return configured;
+}
+function defaultCheckTitle(report) {
+  if (report.failures.length === 0 && report.status === "passed") {
+    return "No eval failures";
+  }
+  if (report.failures.length === 0) {
+    return "Vitest run failed";
+  }
+  return `${report.failures.length} eval failure${report.failures.length === 1 ? "" : "s"}`;
+}
+function enforcedPassTitle(report, passRate, minPassRate, minScoreAverage) {
+  if (minPassRate !== void 0) {
+    return `Eval pass rate ${formatPercent(passRate)} \u2014 floor ${formatPercent(minPassRate)}`;
+  }
+  if (minScoreAverage !== void 0) {
+    return `Avg score ${formatScore(report.score?.average)} \u2014 floor ${formatScore(minScoreAverage)}`;
+  }
+  return defaultCheckTitle(report);
+}
+function formatEvalCounts(report, passRate) {
+  const scoreText = report.score?.average === void 0 ? "n/a" : formatScore(report.score.average);
+  const passRateText = passRate === null ? "n/a" : formatPercent(passRate);
+  return `${formatNumber(report.totals.evalPassed)}/${formatNumber(
+    report.totals.evalTotal
+  )} passed (${passRateText}), avg score ${scoreText}`;
+}
+function formatFloorSuffix(minPassRate, minScoreAverage) {
+  const parts = [];
+  if (minPassRate !== void 0) {
+    parts.push(`pass rate floor ${formatPercent(minPassRate)}`);
+  }
+  if (minScoreAverage !== void 0) {
+    parts.push(`avg score floor ${formatScore(minScoreAverage)}`);
+  }
+  return parts.length === 0 ? "" : `; ${parts.join(", ")}`;
+}
+
+// src/github.ts
+var import_node_fs = require("fs");
+
 // src/summary.ts
 var DEFAULT_MAX_FAILURES = 20;
 var DEFAULT_MAX_REASON_CHARS = 8e3;
@@ -410,20 +586,22 @@ function renderJobSummary(report, options = {}) {
   const lines = [
     "# vitest-evals",
     "",
-    ...renderSummaryTable(report, nonEvalFailures),
+    ...renderSummaryTable(report, nonEvalFailures, options.gate),
     "",
     ...renderScoreDistribution(report),
     "## Results",
     ""
   ];
   if (report.failures.length > 0) {
-    lines.push("### Failures", "");
+    const failureHeading = options.gate?.ok === true ? "### Quality Misses" : "### Failures";
+    lines.push(failureHeading, "");
     failures.forEach((testCase, index) => {
       lines.push(...renderFailureDetails(testCase, index + 1, options), "");
     });
     if (report.failures.length > failures.length) {
+      const omittedLabel = options.gate?.ok === true ? "quality misses" : "failures";
       lines.push(
-        `${report.failures.length - failures.length} more failures omitted from this summary.`,
+        `${report.failures.length - failures.length} more ${omittedLabel} omitted from this summary.`,
         ""
       );
     }
@@ -439,9 +617,9 @@ function renderJobSummary(report, options = {}) {
 function formatCountLine(passed, failed, total) {
   return `${formatNumber(passed)} passed, ${formatNumber(failed)} failed, ${formatNumber(total)} total`;
 }
-function renderSummaryTable(report, nonEvalFailures) {
+function renderSummaryTable(report, nonEvalFailures, gate) {
   const rows = [
-    ["Status", report.status],
+    ["Status", gate?.status ?? report.status],
     [
       "Evals",
       formatCountLine(
@@ -451,9 +629,20 @@ function renderSummaryTable(report, nonEvalFailures) {
       )
     ]
   ];
+  if (gate?.passRate !== void 0 && gate.passRate !== null) {
+    rows.push(["Pass Rate", formatPercent(gate.passRate)]);
+  } else if (report.totals.evalTotal > 0) {
+    rows.push([
+      "Pass Rate",
+      formatPercent(report.totals.evalPassed / report.totals.evalTotal)
+    ]);
+  }
   if (report.score) {
     rows.push(["Score", formatScoreSummary(report.score)]);
   }
+  if (gate?.enforced) {
+    rows.push(["Gate", gate.message]);
+  }
   if (nonEvalFailures > 0) {
     rows.push([
       "Other Failures",
@@ -677,10 +866,44 @@ function formatCaseUsage(testCase) {
 var DEFAULT_CHECK_NAME = "vitest-evals";
 var MAX_CHECK_SUMMARY_LENGTH = 64e3;
 var CHECK_SUMMARY_TRUNCATION_SUFFIX = "\n\n[truncated for GitHub Check Run]\n";
+function resolveCheckSha(env = process.env, options = {}) {
+  const explicit = options.sha?.trim() || env.GITHUB_PR_HEAD_SHA?.trim();
+  if (explicit) {
+    return explicit;
+  }
+  const eventPath = options.eventPath?.trim() || env.GITHUB_EVENT_PATH?.trim();
+  if (eventPath) {
+    try {
+      const event = JSON.parse((0, import_node_fs.readFileSync)(eventPath, "utf8"));
+      const headSha = event.pull_request?.head?.sha;
+      if (typeof headSha === "string" && headSha.trim()) {
+        return headSha.trim();
+      }
+    } catch {
+    }
+  }
+  return env.GITHUB_SHA?.trim() || void 0;
+}
+function resolveCheckDetailsUrl(env = process.env, options = {}) {
+  const explicit = options.detailsUrl?.trim();
+  if (explicit) {
+    return explicit;
+  }
+  const server = env.GITHUB_SERVER_URL?.replace(/\/$/, "");
+  const repository = env.GITHUB_REPOSITORY?.trim();
+  const runId = env.GITHUB_RUN_ID?.trim();
+  if (!server || !repository || !runId) {
+    return void 0;
+  }
+  return `${server}/${repository}/actions/runs/${runId}`;
+}
 async function publishCheckRun(report, options = {}) {
   const token = options.token ?? process.env.GITHUB_TOKEN;
   const repository = options.repository ?? process.env.GITHUB_REPOSITORY;
-  const sha = options.sha ?? process.env.GITHUB_SHA;
+  const sha = resolveCheckSha(process.env, { sha: options.sha });
+  const detailsUrl = resolveCheckDetailsUrl(process.env, {
+    detailsUrl: options.detailsUrl
+  });
   if (!token) {
     return { status: "skipped", reason: "missing GITHUB_TOKEN" };
   }
@@ -688,7 +911,10 @@ async function publishCheckRun(report, options = {}) {
     return { status: "skipped", reason: "missing GITHUB_REPOSITORY" };
   }
   if (!sha && options.checkRunId === void 0) {
-    return { status: "skipped", reason: "missing GITHUB_SHA" };
+    return {
+      status: "skipped",
+      reason: "missing commit SHA (set --sha / options.sha, GITHUB_PR_HEAD_SHA, pull_request.head.sha, or GITHUB_SHA)"
+    };
   }
   const [owner, repo] = repository.split("/");
   if (!owner || !repo) {
@@ -697,7 +923,7 @@ async function publishCheckRun(report, options = {}) {
       reason: `invalid GitHub repository: ${repository}`
     };
   }
-  const payload = buildCheckRunPayload(report, options);
+  const payload = buildCheckRunPayload(report, options, detailsUrl);
   const apiUrl = options.apiUrl ?? process.env.GITHUB_API_URL ?? "https://api.github.com";
   const requestUrl = options.checkRunId === void 0 ? `${apiUrl}/repos/${owner}/${repo}/check-runs` : `${apiUrl}/repos/${owner}/${repo}/check-runs/${options.checkRunId}`;
   const response = await fetch(requestUrl, {
@@ -712,6 +938,7 @@ async function publishCheckRun(report, options = {}) {
       options.checkRunId === void 0 ? {
         name: options.name ?? DEFAULT_CHECK_NAME,
         head_sha: sha,
+        ...options.externalId ? { external_id: options.externalId } : {},
         ...payload
       } : payload
     )
@@ -726,27 +953,31 @@ async function publishCheckRun(report, options = {}) {
   return {
     status: options.checkRunId === void 0 ? "created" : "updated",
     id: data.id,
-    htmlUrl: data.html_url
+    htmlUrl: data.html_url,
+    sha
   };
 }
-function buildCheckRunPayload(report, options) {
+function buildCheckRunPayload(report, options, detailsUrl) {
+  const gate = options.gate ?? evaluateEvalGate(report);
   const annotations = buildCheckAnnotations(report, {
-    maxAnnotations: options.maxAnnotations
+    maxAnnotations: options.maxAnnotations,
+    gate
   });
-  const title = report.failures.length === 0 && report.status === "passed" ? "No eval failures" : report.failures.length === 0 ? "Vitest run failed" : `${report.failures.length} eval failure${report.failures.length === 1 ? "" : "s"}`;
   return {
     status: "completed",
-    conclusion: report.status === "passed" ? "success" : "failure",
+    conclusion: gate.ok ? "success" : "failure",
     completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...detailsUrl ? { details_url: detailsUrl } : {},
     output: {
-      title,
+      title: gate.title,
       summary: truncateCheckSummary(
         renderJobSummary(report, {
           ...options,
           maxFailures: options.maxFailures ?? 5,
           maxReasonChars: options.maxReasonChars ?? 4e3,
           maxOutputChars: options.maxOutputChars ?? 2e3,
-          maxToolCalls: options.maxToolCalls ?? 10
+          maxToolCalls: options.maxToolCalls ?? 10,
+          gate
         })
       ),
       annotations
@@ -759,12 +990,189 @@ function truncateCheckSummary(summary) {
   }
   return `${summary.slice(0, MAX_CHECK_SUMMARY_LENGTH - CHECK_SUMMARY_TRUNCATION_SUFFIX.length).trimEnd()}${CHECK_SUMMARY_TRUNCATION_SUFFIX}`;
 }
+
+// src/report.ts
+var import_promises = require("fs/promises");
+var import_node = require("@vitest-evals/core/node");
+
+// src/merge.ts
+function mergeEvalReports(reports) {
+  const cases = reports.flatMap((report) => report.cases);
+  const failures = reports.flatMap((report) => report.failures);
+  const scoredCases = cases.map((testCase) => testCase.eval?.avgScore).filter(
+    (score) => typeof score === "number" && Number.isFinite(score)
+  );
+  const startedAtValues = reports.map((report) => report.startedAt).filter(
+    (startedAt2) => typeof startedAt2 === "number" && Number.isFinite(startedAt2)
+  );
+  const startedAt = startedAtValues.length > 0 ? Math.min(...startedAtValues) : void 0;
+  return {
+    status: reports.some((report) => report.status === "failed") ? "failed" : "passed",
+    startedAt,
+    durationMs: mergeDuration(reports),
+    totals: {
+      total: sum(reports, (report) => report.totals.total),
+      passed: sum(reports, (report) => report.totals.passed),
+      failed: sum(reports, (report) => report.totals.failed),
+      skipped: sum(reports, (report) => report.totals.skipped),
+      evalTotal: sum(reports, (report) => report.totals.evalTotal),
+      evalPassed: sum(reports, (report) => report.totals.evalPassed),
+      evalFailed: sum(reports, (report) => report.totals.evalFailed)
+    },
+    score: scoredCases.length > 0 ? {
+      average: scoredCases.reduce((total, score) => total + score, 0) / scoredCases.length,
+      minimum: Math.min(...scoredCases)
+    } : void 0,
+    usage: mergeUsage(reports.map((report) => report.usage)),
+    cases,
+    failures
+  };
+}
+function mergeUsage(usages) {
+  return {
+    inputTokens: sum(usages, (usage) => usage.inputTokens),
+    outputTokens: sum(usages, (usage) => usage.outputTokens),
+    reasoningTokens: sum(usages, (usage) => usage.reasoningTokens),
+    totalTokens: sum(usages, (usage) => usage.totalTokens),
+    toolCalls: sum(usages, (usage) => usage.toolCalls)
+  };
+}
+function mergeDuration(reports) {
+  const durations = reports.map((report) => report.durationMs).filter(
+    (durationMs) => typeof durationMs === "number" && Number.isFinite(durationMs)
+  );
+  const intervals = reports.map((report) => {
+    if (typeof report.startedAt !== "number" || !Number.isFinite(report.startedAt) || typeof report.durationMs !== "number" || !Number.isFinite(report.durationMs)) {
+      return void 0;
+    }
+    return {
+      start: report.startedAt,
+      end: report.startedAt + report.durationMs
+    };
+  }).filter(
+    (interval) => Boolean(interval)
+  );
+  if (intervals.length > 0 && intervals.length === durations.length) {
+    return Math.max(...intervals.map((interval) => interval.end)) - Math.min(...intervals.map((interval) => interval.start));
+  }
+  return durations.length > 0 ? durations.reduce((total, durationMs) => total + durationMs, 0) : void 0;
+}
+function sum(items, select) {
+  return items.reduce((total, item) => total + select(item), 0);
+}
+
+// src/report.ts
+async function publishEvalReport(options) {
+  const resultFiles = await (0, import_node.resolveResultFiles)(options.resultPatterns, {
+    cwd: options.cwd
+  });
+  if (resultFiles.length === 0) {
+    throw new Error(
+      `No eval result files matched: ${options.resultPatterns.join(", ")}`
+    );
+  }
+  const reports = await Promise.all(
+    resultFiles.map(async (resultFile) => {
+      const json = await (0, import_node.readVitestJsonReportFile)(resultFile);
+      return collectEvalReport(json, {
+        workspace: options.workspace
+      });
+    })
+  );
+  const report = mergeEvalReports(reports);
+  const gate = evaluateEvalGate(report, {
+    failOnFailures: options.failOnFailures,
+    minPassRate: options.minPassRate,
+    minScoreAverage: options.minScoreAverage
+  });
+  const summary = renderJobSummary(report, {
+    maxFailures: options.maxFailures,
+    maxOutputChars: options.maxOutputChars,
+    maxReasonChars: options.maxReasonChars,
+    maxToolCalls: options.maxToolCalls,
+    gate
+  });
+  if (options.summaryEnabled !== false) {
+    if (options.summaryPath) {
+      await (0, import_promises.appendFile)(options.summaryPath, `${summary}
+`);
+    } else {
+      console.log(summary);
+    }
+  }
+  if (options.annotations) {
+    const gateCommand = renderGateWorkflowCommand(gate);
+    if (gateCommand) {
+      console.log(gateCommand);
+    }
+    for (const command of renderWorkflowCommands(report, {
+      maxAnnotations: options.maxAnnotations,
+      gate
+    })) {
+      console.log(command);
+    }
+  }
+  let checkRun;
+  if (options.checkRun) {
+    try {
+      checkRun = await publishCheckRun(report, {
+        checkRunId: options.checkRunId,
+        maxAnnotations: options.maxAnnotations,
+        maxFailures: options.maxFailures,
+        maxOutputChars: options.maxOutputChars,
+        maxReasonChars: options.maxReasonChars,
+        maxToolCalls: options.maxToolCalls,
+        name: options.checkName,
+        repository: options.repository,
+        sha: options.sha,
+        detailsUrl: options.detailsUrl,
+        externalId: options.externalId,
+        token: options.token,
+        gate
+      });
+      if (checkRun.status === "skipped") {
+        options.warn?.(`GitHub Check Run skipped: ${checkRun.reason}`);
+      } else if (checkRun.htmlUrl) {
+        console.log(`published check run: ${checkRun.htmlUrl}`);
+      } else if (checkRun.id !== void 0) {
+        console.log(`published check run id: ${checkRun.id}`);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (options.failOnCheckError) {
+        throw error;
+      }
+      options.warn?.(message);
+    }
+  }
+  const gateFailed = gate.enforced && !gate.ok;
+  const wantsSoftFail = options.softFail ?? options.checkRun === true;
+  const softFail = wantsSoftFail && checkRunPublished(checkRun);
+  const shouldFail = gateFailed && !softFail;
+  return {
+    report,
+    resultFiles,
+    gate,
+    shouldFail,
+    checkRun
+  };
+}
+function checkRunPublished(checkRun) {
+  return checkRun?.status === "created" || checkRun?.status === "updated";
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   buildCheckAnnotations,
   collectEvalReport,
+  computePassRate,
+  evaluateEvalGate,
+  formatPercent,
   publishCheckRun,
+  publishEvalReport,
+  renderGateWorkflowCommand,
   renderJobSummary,
-  renderWorkflowCommands
+  renderWorkflowCommands,
+  resolveCheckDetailsUrl,
+  resolveCheckSha
 });
 //# sourceMappingURL=index.js.map