executable-stories-formatters 0.4.0 → 0.5.0

package/dist/index.js

@@ -2561,6 +2561,21 @@ body {
   }
 }
 
+/* ============================================================================
+   History metric badges
+   ============================================================================ */
+.badge { display: inline-block; padding: 2px 6px; border-radius: 4px; font-size: 0.75em; font-weight: 600; margin-left: 4px; vertical-align: middle; }
+.badge-grade { color: #fff; }
+.badge-grade-A { background: var(--success); }
+.badge-grade-B { background: #2196F3; }
+.badge-grade-C { background: #FF9800; }
+.badge-grade-D { background: #f44336; }
+.badge-grade-F { background: #9E0000; }
+.badge-flaky { background: #FF9800; color: #fff; }
+.badge-perf { font-size: 0.7em; }
+.badge-perf-improving { color: var(--success); }
+.badge-perf-regressing { color: var(--error); }
+
 `;
 
 // src/formatters/html/renderers/status.ts
@@ -2594,7 +2609,22 @@ function renderMetaInfo(args, deps) {
     items.push(`<dt>Git:</dt><dd>${deps.escapeHtml(shortSha)}</dd>`);
   }
   if (args.ciName) {
-    items.push(`<dt>CI:</dt><dd>${deps.escapeHtml(args.ciName)}</dd>`);
+    if (args.ciUrl && args.ciBuildNumber) {
+      items.push(
+        `<dt>CI:</dt><dd>${deps.escapeHtml(args.ciName)} <a href="${deps.escapeHtml(args.ciUrl)}">#${deps.escapeHtml(args.ciBuildNumber)}</a></dd>`
+      );
+    } else {
+      items.push(`<dt>CI:</dt><dd>${deps.escapeHtml(args.ciName)}</dd>`);
+    }
+  }
+  if (args.ciBranch) {
+    items.push(`<dt>Branch:</dt><dd>${deps.escapeHtml(args.ciBranch)}</dd>`);
+  }
+  if (args.ciCommitSha) {
+    const shortSha = args.ciCommitSha.length > 7 ? args.ciCommitSha.slice(0, 7) : args.ciCommitSha;
+    items.push(
+      `<dt>Commit:</dt><dd title="${deps.escapeHtml(args.ciCommitSha)}">${deps.escapeHtml(shortSha)}</dd>`
+    );
   }
   return `<dl class="meta-info">${items.join("")}</dl>`;
 }
@@ -2845,6 +2875,14 @@ function highlightStepParams(text, deps) {
   return result;
 }
 
+// src/history/sample-policy.ts
+var MIN_PERF_SAMPLES = 6;
+var MIN_METRIC_SAMPLES = 5;
+var MIN_FLAKINESS_SAMPLES = 3;
+function hasSufficientHistory(entries, min) {
+  return entries.length >= min;
+}
+
 // src/formatters/html/renderers/scenario.ts
 function renderScenario(args, deps) {
   const { tc } = args;
@@ -2865,6 +2903,19 @@ function renderScenario(args, deps) {
       traceBadge = `<span class="tag trace-tag" title="${deps.escapeHtml(otelMeta.traceId)}">${deps.escapeHtml(shortId)}\u2026</span>`;
     }
   }
+  let metricBadges = "";
+  const { metrics } = args;
+  if (metrics && metrics.sampleSize >= MIN_METRIC_SAMPLES) {
+    const grade = metrics.stabilityGrade;
+    metricBadges += `<span class="badge badge-grade badge-grade-${grade}" title="Pass rate: ${(metrics.passRate * 100).toFixed(0)}% (${metrics.sampleSize} runs)">${grade}</span>`;
+    if (metrics.flakinessLevel !== "stable") {
+      metricBadges += `<span class="badge badge-flaky">${metrics.flakinessLevel}</span>`;
+    }
+    if (metrics.performanceTrend !== "stable") {
+      const arrow = metrics.performanceTrend === "improving" ? "\u2191" : "\u2193";
+      metricBadges += `<span class="badge badge-perf badge-perf-${metrics.performanceTrend}">${arrow} ${metrics.performanceTrend}</span>`;
+    }
+  }
   const storyDocs = deps.renderDocs(tc.story.docs, "story-docs");
   const steps = deps.renderSteps(
     { steps: tc.story.steps, stepResults: tc.stepResults },
@@ -2899,7 +2950,7 @@ function renderScenario(args, deps) {
         <span class="status-icon ${statusClass}">${statusIcon}</span>
         <span class="scenario-name">${deps.escapeHtml(tc.story.scenario)}</span>
       </div>
-      <div class="scenario-meta">${tags}${traceBadge}</div>
+      <div class="scenario-meta">${tags}${traceBadge}${metricBadges}</div>
     </div>
     <span class="scenario-duration">${duration}</span>
   </div>
@@ -3111,7 +3162,12 @@ function renderFeature(args, deps) {
   const featureName = suitePaths.length > 0 && suitePaths[0].length > 0 ? suitePaths[0][0] : file.split("/").pop()?.replace(/\.[^.]+$/, "") ?? file;
   const collapsedClass = deps.startCollapsed ? " collapsed" : "";
   const ariaExpanded = !deps.startCollapsed;
-  const scenarios = testCases.map((tc) => deps.renderScenario({ tc }, deps.scenarioDeps)).join("\n");
+  const scenarios = testCases.map(
+    (tc) => deps.renderScenario(
+      { tc, metrics: args.metricsMap?.get(tc.id) },
+      deps.scenarioDeps
+    )
+  ).join("\n");
   return `
 <div class="feature${collapsedClass}">
   <div class="feature-header" role="button" tabindex="0" aria-expanded="${ariaExpanded}">
@@ -3156,7 +3212,11 @@ function buildBody(args, deps) {
         durationMs: run.durationMs,
         packageVersion: run.packageVersion,
         gitSha: run.gitSha,
-        ciName: run.ci?.name
+        ciName: run.ci?.name,
+        ciBranch: run.ci?.branch,
+        ciUrl: run.ci?.url,
+        ciCommitSha: run.ci?.commitSha,
+        ciBuildNumber: run.ci?.buildNumber
       },
       deps.metaDeps
     )
@@ -3185,7 +3245,10 @@ function buildBody(args, deps) {
   const byFile = groupBy(run.testCases, (tc) => tc.sourceFile);
   for (const [file, testCases] of byFile) {
     parts.push(
-      deps.renderFeature({ file, testCases }, deps.featureDeps)
+      deps.renderFeature(
+        { file, testCases, metricsMap: args.metricsMap },
+        deps.featureDeps
+      )
     );
   }
   return parts.join("\n");
@@ -5657,45 +5720,102 @@ function clearVersionCache() {
 
 // src/utils/ci-detect.ts
 function detectCI4(env = process.env) {
+  if (env.TF_BUILD === "True") {
+    const branch = env.BUILD_SOURCEBRANCH?.replace(/^refs\/heads\//, "");
+    const serverUri = env.SYSTEM_TEAMFOUNDATIONSERVERURI;
+    const teamProject = env.SYSTEM_TEAMPROJECT;
+    const buildId = env.BUILD_BUILDID;
+    const url = serverUri && teamProject && buildId ? `${serverUri}${teamProject}/_build/results?buildId=${buildId}` : void 0;
+    return {
+      name: "azure",
+      provider: "azure",
+      buildNumber: buildId,
+      url,
+      branch,
+      commitSha: env.BUILD_SOURCEVERSION,
+      prNumber: env.SYSTEM_PULLREQUEST_PULLREQUESTID
+    };
+  }
+  if (env.BUILDKITE === "true") {
+    const prRaw = env.BUILDKITE_PULL_REQUEST;
+    const prNumber = prRaw && prRaw !== "false" ? prRaw : void 0;
+    return {
+      name: "buildkite",
+      provider: "buildkite",
+      buildNumber: env.BUILDKITE_BUILD_NUMBER,
+      url: env.BUILDKITE_BUILD_URL,
+      branch: env.BUILDKITE_BRANCH,
+      commitSha: env.BUILDKITE_COMMIT,
+      prNumber
+    };
+  }
   if (env.GITHUB_ACTIONS === "true") {
     const url = env.GITHUB_SERVER_URL && env.GITHUB_REPOSITORY && env.GITHUB_RUN_ID ? `${env.GITHUB_SERVER_URL}/${env.GITHUB_REPOSITORY}/actions/runs/${env.GITHUB_RUN_ID}` : void 0;
+    const branch = env.GITHUB_HEAD_REF || env.GITHUB_REF_NAME;
+    const prMatch = env.GITHUB_REF?.match(/^refs\/pull\/(\d+)\/(merge|head)$/);
+    const prNumber = prMatch ? prMatch[1] : void 0;
     return {
       name: "github",
+      provider: "github",
       buildNumber: env.GITHUB_RUN_NUMBER,
-      url
+      url,
+      branch,
+      commitSha: env.GITHUB_SHA,
+      prNumber
+    };
+  }
+  if (env.GITLAB_CI === "true") {
+    return {
+      name: "gitlab",
+      provider: "gitlab",
+      buildNumber: env.CI_PIPELINE_IID,
+      url: env.CI_PIPELINE_URL,
+      branch: env.CI_COMMIT_REF_NAME,
+      commitSha: env.CI_COMMIT_SHA,
+      prNumber: env.CI_MERGE_REQUEST_IID
     };
   }
   if (env.CIRCLECI === "true") {
+    const prUrl = env.CIRCLE_PULL_REQUEST;
+    const prMatch = prUrl?.match(/\/(\d+)$/);
+    const prNumber = prMatch ? prMatch[1] : void 0;
     return {
       name: "circleci",
+      provider: "circleci",
       buildNumber: env.CIRCLE_BUILD_NUM,
-      url: env.CIRCLE_BUILD_URL
+      url: env.CIRCLE_BUILD_URL,
+      branch: env.CIRCLE_BRANCH,
+      commitSha: env.CIRCLE_SHA1,
+      prNumber
     };
   }
   if (env.JENKINS_URL !== void 0) {
     return {
       name: "jenkins",
+      provider: "jenkins",
       buildNumber: env.BUILD_NUMBER,
-      url: env.BUILD_URL
+      url: env.BUILD_URL,
+      branch: env.GIT_BRANCH,
+      commitSha: env.GIT_COMMIT
     };
   }
   if (env.TRAVIS === "true") {
+    const prRaw = env.TRAVIS_PULL_REQUEST;
+    const prNumber = prRaw && prRaw !== "false" ? prRaw : void 0;
     return {
       name: "travis",
+      provider: "travis",
       buildNumber: env.TRAVIS_BUILD_NUMBER,
-      url: env.TRAVIS_BUILD_WEB_URL
-    };
-  }
-  if (env.GITLAB_CI === "true") {
-    return {
-      name: "gitlab",
-      buildNumber: env.CI_PIPELINE_IID,
-      url: env.CI_PIPELINE_URL
+      url: env.TRAVIS_BUILD_WEB_URL,
+      branch: env.TRAVIS_BRANCH,
+      commitSha: env.TRAVIS_COMMIT,
+      prNumber
     };
   }
   if (env.CI === "true") {
     return {
-      name: "ci"
+      name: "ci",
+      provider: "unknown"
     };
   }
   return void 0;
@@ -5726,6 +5846,731 @@ function resolveTraceUrl(template, traceId) {
   return template.replace(/\{traceId\}/g, traceId);
 }
 
+// src/notifiers/ansi-strip.ts
+function stripAnsi(text) {
+  return text.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "");
+}
+
+// src/notifiers/slack.ts
+function truncate(text, maxLen) {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen - 3) + "...";
+}
+function formatDuration3(ms) {
+  const seconds = ms / 1e3;
+  if (seconds < 60) return `${seconds.toFixed(1)}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  return `${minutes}m ${remainingSeconds.toFixed(0)}s`;
+}
+function buildSlackPayload(summary, maxFailedTests) {
+  const allPassed = summary.failed === 0;
+  const emoji = allPassed ? ":white_check_mark:" : ":x:";
+  const statusText = allPassed ? "Passed" : "Failed";
+  const blocks = [];
+  blocks.push({
+    type: "header",
+    text: {
+      type: "plain_text",
+      text: `${emoji} Test Results: ${summary.passed} passed, ${summary.failed} failed`,
+      emoji: true
+    }
+  });
+  blocks.push({
+    type: "section",
+    fields: [
+      { type: "mrkdwn", text: `*Total:* ${summary.total}` },
+      { type: "mrkdwn", text: `*Passed:* ${summary.passed}` },
+      { type: "mrkdwn", text: `*Failed:* ${summary.failed}` },
+      { type: "mrkdwn", text: `*Skipped:* ${summary.skipped}` },
+      { type: "mrkdwn", text: `*Duration:* ${formatDuration3(summary.durationMs)}` },
+      { type: "mrkdwn", text: `*Status:* ${statusText}` }
+    ]
+  });
+  if (summary.failedTests.length > 0) {
+    const displayedTests = summary.failedTests.slice(0, maxFailedTests);
+    const lines = displayedTests.map((t) => {
+      const name = t.name;
+      if (t.error) {
+        const cleanError = truncate(stripAnsi(t.error), 500);
+        return `*${name}*
+\`\`\`${cleanError}\`\`\``;
+      }
+      return `*${name}*`;
+    });
+    let text = lines.join("\n\n");
+    if (summary.failedTests.length > maxFailedTests) {
+      text += `
+
+_...and ${summary.failedTests.length - maxFailedTests} more_`;
+    }
+    blocks.push({
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text
+      }
+    });
+  }
+  if (summary.ci) {
+    const elements = [];
+    if (summary.ci.displayName) {
+      elements.push({ type: "mrkdwn", text: `*CI:* ${summary.ci.displayName}` });
+    }
+    if (summary.ci.branch) {
+      elements.push({ type: "mrkdwn", text: `*Branch:* ${summary.ci.branch}` });
+    }
+    if (summary.ci.commitSha) {
+      elements.push({ type: "mrkdwn", text: `*Commit:* ${summary.ci.commitSha.slice(0, 7)}` });
+    }
+    if (summary.ci.buildNumber) {
+      elements.push({ type: "mrkdwn", text: `*Build:* #${summary.ci.buildNumber}` });
+    }
+    if (elements.length > 0) {
+      blocks.push({
+        type: "context",
+        elements
+      });
+    }
+  }
+  if (summary.reportUrl) {
+    blocks.push({
+      type: "actions",
+      elements: [
+        {
+          type: "button",
+          text: {
+            type: "plain_text",
+            text: "View Report",
+            emoji: true
+          },
+          url: summary.reportUrl,
+          action_id: "view_report"
+        }
+      ]
+    });
+  }
+  return { blocks };
+}
+async function sendSlackNotification(args, deps) {
+  const { summary, webhookUrl, maxFailedTests = 5 } = args;
+  const { fetch, logger } = deps;
+  const payload = buildSlackPayload(summary, maxFailedTests);
+  try {
+    const response = await fetch(webhookUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const requestId = response.headers.get("x-request-id") ?? void 0;
+      let bodyText = "";
+      try {
+        bodyText = await response.text();
+      } catch {
+      }
+      const truncatedBody = truncate(bodyText, 200);
+      const idPart = requestId ? ` x-request-id=${requestId}` : "";
+      const errorMsg = `Slack notifier failed: HTTP ${response.status}${idPart} ${truncatedBody}`;
+      logger.warn(errorMsg);
+      return { ok: false, error: errorMsg };
+    }
+    return { ok: true };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const errorMsg = `Slack notifier failed: ${msg}`;
+    logger.warn(errorMsg);
+    return { ok: false, error: errorMsg };
+  }
+}
+
+// src/notifiers/teams.ts
+function truncate2(text, maxLen) {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen - 3) + "...";
+}
+function formatDuration4(ms) {
+  const seconds = ms / 1e3;
+  if (seconds < 60) return `${seconds.toFixed(1)}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  return `${minutes}m ${remainingSeconds.toFixed(0)}s`;
+}
+function buildTeamsPayload(summary, maxFailedTests) {
+  const allPassed = summary.failed === 0;
+  const statusEmoji = allPassed ? "\u2705" : "\u274C";
+  const statusColor = allPassed ? "good" : "attention";
+  const bodyItems = [];
+  bodyItems.push({
+    type: "TextBlock",
+    size: "Large",
+    weight: "Bolder",
+    text: `${statusEmoji} Test Results`,
+    color: statusColor
+  });
+  bodyItems.push({
+    type: "FactSet",
+    facts: [
+      { title: "Total", value: String(summary.total) },
+      { title: "Passed", value: String(summary.passed) },
+      { title: "Failed", value: String(summary.failed) },
+      { title: "Skipped", value: String(summary.skipped) },
+      { title: "Duration", value: formatDuration4(summary.durationMs) }
+    ]
+  });
+  if (summary.failedTests.length > 0) {
+    const displayedTests = summary.failedTests.slice(0, maxFailedTests);
+    const failedItems = [
+      {
+        type: "TextBlock",
+        text: "Failed Tests",
+        weight: "Bolder",
+        spacing: "Medium"
+      }
+    ];
+    for (const t of displayedTests) {
+      failedItems.push({
+        type: "TextBlock",
+        text: `**${t.name}**`,
+        wrap: true
+      });
+      if (t.error) {
+        const cleanError = truncate2(stripAnsi(t.error), 500);
+        failedItems.push({
+          type: "TextBlock",
+          text: cleanError,
+          wrap: true,
+          fontType: "Monospace",
+          size: "Small",
+          color: "Attention"
+        });
+      }
+    }
+    if (summary.failedTests.length > maxFailedTests) {
+      failedItems.push({
+        type: "TextBlock",
+        text: `...and ${summary.failedTests.length - maxFailedTests} more`,
+        isSubtle: true,
+        spacing: "Small"
+      });
+    }
+    bodyItems.push({
+      type: "Container",
+      items: failedItems
+    });
+  }
+  if (summary.ci) {
+    const ciFacts = [];
+    if (summary.ci.displayName) {
+      ciFacts.push({ title: "CI", value: summary.ci.displayName });
+    }
+    if (summary.ci.branch) {
+      ciFacts.push({ title: "Branch", value: summary.ci.branch });
+    }
+    if (summary.ci.commitSha) {
+      ciFacts.push({ title: "Commit", value: summary.ci.commitSha.slice(0, 7) });
+    }
+    if (summary.ci.buildNumber) {
+      ciFacts.push({ title: "Build", value: `#${summary.ci.buildNumber}` });
+    }
+    if (ciFacts.length > 0) {
+      bodyItems.push({
+        type: "FactSet",
+        facts: ciFacts,
+        separator: true
+      });
+    }
+  }
+  const card = {
+    type: "AdaptiveCard",
+    $schema: "http://adaptivecards.io/schemas/adaptive-card.json",
+    version: "1.4",
+    body: bodyItems
+  };
+  if (summary.reportUrl) {
+    card.actions = [
+      {
+        type: "Action.OpenUrl",
+        title: "View Report",
+        url: summary.reportUrl
+      }
+    ];
+  }
+  return {
+    type: "message",
+    attachments: [
+      {
+        contentType: "application/vnd.microsoft.card.adaptive",
+        content: card
+      }
+    ]
+  };
+}
+async function sendTeamsNotification(args, deps) {
+  const { summary, webhookUrl, maxFailedTests = 5 } = args;
+  const { fetch, logger } = deps;
+  const payload = buildTeamsPayload(summary, maxFailedTests);
+  try {
+    const response = await fetch(webhookUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const requestId = response.headers.get("x-request-id") ?? void 0;
+      let bodyText = "";
+      try {
+        bodyText = await response.text();
+      } catch {
+      }
+      const truncatedBody = truncate2(bodyText, 200);
+      const idPart = requestId ? ` x-request-id=${requestId}` : "";
+      const errorMsg = `Teams notifier failed: HTTP ${response.status}${idPart} ${truncatedBody}`;
+      logger.warn(errorMsg);
+      return { ok: false, error: errorMsg };
+    }
+    return { ok: true };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const errorMsg = `Teams notifier failed: ${msg}`;
+    logger.warn(errorMsg);
+    return { ok: false, error: errorMsg };
+  }
+}
+
+// src/notifiers/hmac.ts
+import { createHmac } from "crypto";
+function signBody(args) {
+  let input;
+  let timestamp;
+  if (args.includeTimestamp) {
+    timestamp = args.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+    input = `${timestamp}.${args.body}`;
+  } else {
+    input = args.body;
+  }
+  const hex = createHmac("sha256", args.secret).update(input, "utf8").digest("hex");
+  return {
+    signature: `sha256=${hex}`,
+    timestamp
+  };
+}
+
+// src/notifiers/webhook.ts
+async function sendWebhookNotification(args, deps) {
+  const { summary, options } = args;
+  const { fetch, logger } = deps;
+  const payload = {
+    schemaVersion: 1,
+    event: "test_run_finished",
+    summary
+  };
+  const body = JSON.stringify(payload);
+  const headers = { "Content-Type": "application/json" };
+  if (options.headers) {
+    for (const [key, value] of Object.entries(options.headers)) {
+      headers[key] = value;
+    }
+  }
+  if (options.signer) {
+    const { secret, header, includeTimestamp, timestampHeader } = options.signer;
+    const result = signBody({ body, secret, includeTimestamp });
+    headers[header] = result.signature;
+    if (result.timestamp) {
+      headers[timestampHeader ?? "X-Timestamp"] = result.timestamp;
+    }
+  }
+  try {
+    const response = await fetch(options.url, {
+      method: options.method ?? "POST",
+      headers,
+      body
+    });
+    if (!response.ok) {
+      const requestId = response.headers.get("x-request-id") ?? void 0;
+      let snippet = "";
+      try {
+        snippet = (await response.text()).slice(0, 200);
+      } catch {
+      }
+      const idPart = requestId ? ` x-request-id=${requestId}` : "";
+      const errorMsg = `webhook: HTTP ${response.status}${idPart} ${snippet}`;
+      logger.warn(errorMsg);
+      return { ok: false, error: errorMsg };
+    }
+    return { ok: true };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const errorMsg = `webhook: ${msg}`;
+    logger.warn(errorMsg);
+    return { ok: false, error: errorMsg };
+  }
+}
+
+// src/notifiers/index.ts
+function buildSummary(run, reportUrl, toCIInfo2) {
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+  const failedTests = [];
+  for (const tc of run.testCases) {
+    switch (tc.status) {
+      case "passed":
+        passed++;
+        break;
+      case "failed":
+        failed++;
+        failedTests.push({
+          testId: tc.id,
+          name: tc.story.scenario,
+          error: tc.errorMessage
+        });
+        break;
+      case "skipped":
+      case "pending":
+        skipped++;
+        break;
+    }
+  }
+  let ci;
+  if (run.ci) {
+    ci = toCIInfo2(run.ci);
+  }
+  return {
+    total: run.testCases.length,
+    passed,
+    failed,
+    skipped,
+    durationMs: run.durationMs,
+    failedTests,
+    ci,
+    reportUrl
+  };
+}
+function shouldNotify(condition, failedCount) {
+  if (condition === "never") return false;
+  if (condition === "on-failure" && failedCount === 0) return false;
+  return true;
+}
+async function sendNotifications(args, deps) {
+  const { run, notification } = args;
+  const { logger, toCIInfo: toCIInfo2 } = deps;
+  const env = deps.env ?? process.env;
+  if (!deps.fetch) {
+    logger.warn("notifications: skipped (fetch unavailable)");
+    return;
+  }
+  const fetch = deps.fetch;
+  const slackWebhookUrl = notification?.slackWebhookUrl ?? env.SLACK_WEBHOOK_URL;
+  const teamsWebhookUrl = notification?.teamsWebhookUrl ?? env.TEAMS_WEBHOOK_URL;
+  const globalCondition = notification?.condition ?? "on-failure";
+  const reportUrl = notification?.reportUrl;
+  const maxFailedTests = notification?.maxFailedTests ?? 5;
+  const webhooks = notification?.webhooks ?? [];
+  if (!slackWebhookUrl && !teamsWebhookUrl && webhooks.length === 0) {
+    return;
+  }
+  const summary = buildSummary(run, reportUrl, toCIInfo2);
+  const promises = [];
+  if (slackWebhookUrl && shouldNotify(globalCondition, summary.failed)) {
+    promises.push(
+      sendSlackNotification(
+        { summary, webhookUrl: slackWebhookUrl, maxFailedTests },
+        { fetch, logger }
+      ).then(() => void 0)
+    );
+  }
+  if (teamsWebhookUrl && shouldNotify(globalCondition, summary.failed)) {
+    promises.push(
+      sendTeamsNotification(
+        { summary, webhookUrl: teamsWebhookUrl, maxFailedTests },
+        { fetch, logger }
+      ).then(() => void 0)
+    );
+  }
+  for (const webhook of webhooks) {
+    const effectiveCondition = webhook.condition ?? globalCondition;
+    if (!shouldNotify(effectiveCondition, summary.failed)) continue;
+    promises.push(
+      sendWebhookNotification(
+        { summary, options: webhook, maxFailedTests },
+        { fetch, logger }
+      ).then(() => void 0)
+    );
+  }
+  await Promise.allSettled(promises);
+}
+
+// src/types/ci.ts
+var DISPLAY_NAMES = {
+  github: "GitHub Actions",
+  gitlab: "GitLab CI",
+  circleci: "CircleCI",
+  jenkins: "Jenkins",
+  azure: "Azure DevOps",
+  buildkite: "Buildkite",
+  travis: "Travis CI",
+  unknown: "CI"
+};
+var NAME_TO_PROVIDER = {
+  github: "github",
+  gitlab: "gitlab",
+  circleci: "circleci",
+  jenkins: "jenkins",
+  azure: "azure",
+  buildkite: "buildkite",
+  travis: "travis",
+  ci: "unknown"
+};
+function toCIInfo(raw) {
+  if (!raw) return void 0;
+  const provider = raw.provider ?? NAME_TO_PROVIDER[raw.name] ?? "unknown";
+  return {
+    provider,
+    displayName: DISPLAY_NAMES[provider],
+    url: raw.url,
+    buildNumber: raw.buildNumber,
+    branch: raw.branch,
+    commitSha: raw.commitSha,
+    prNumber: raw.prNumber
+  };
+}
+function toRawCIInfo(ci) {
+  if (!ci) return void 0;
+  return {
+    name: ci.provider === "unknown" ? "ci" : ci.provider,
+    provider: ci.provider,
+    url: ci.url,
+    buildNumber: ci.buildNumber,
+    branch: ci.branch,
+    commitSha: ci.commitSha,
+    prNumber: ci.prNumber
+  };
+}
+
+// src/history/history-store.ts
+function emptyStore() {
+  return { version: 1, maxRuns: 10, tests: {}, lastUpdated: 0 };
+}
+function loadHistory(args, deps) {
+  const content = deps.readFile(args.filePath);
+  if (content === void 0) {
+    return emptyStore();
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    deps.logger.warn(`Failed to parse history file: ${args.filePath}`);
+    return emptyStore();
+  }
+  if (typeof parsed !== "object" || parsed === null || parsed.version !== 1) {
+    deps.logger.warn(
+      `Unknown history version in ${args.filePath}, expected version 1`
+    );
+    return emptyStore();
+  }
+  const obj = parsed;
+  if (typeof obj.tests !== "object" || obj.tests === null || Array.isArray(obj.tests)) {
+    deps.logger.warn(
+      `Malformed history store in ${args.filePath}: tests must be a non-null object`
+    );
+    return emptyStore();
+  }
+  return parsed;
+}
+function saveHistory(args, deps) {
+  deps.writeFile(args.filePath, JSON.stringify(args.store, null, 2));
+}
+function updateHistory(args) {
+  const { store, run, maxRuns } = args;
+  const newTests = { ...store.tests };
+  for (const tc of run.testCases) {
+    const entry = {
+      runId: run.runId,
+      timestamp: run.startedAtMs,
+      status: tc.status,
+      durationMs: tc.durationMs,
+      ci: run.ci ? {
+        provider: void 0,
+        branch: run.ci.branch,
+        commitSha: run.ci.commitSha
+      } : void 0
+    };
+    const existing = newTests[tc.id];
+    if (existing) {
+      const updatedEntries = [...existing.entries, entry];
+      const trimmed = updatedEntries.length > maxRuns ? updatedEntries.slice(updatedEntries.length - maxRuns) : updatedEntries;
+      newTests[tc.id] = {
+        ...existing,
+        testName: tc.story.scenario,
+        sourceFile: tc.sourceFile,
+        sourceLine: tc.sourceLine,
+        entries: trimmed
+      };
+    } else {
+      newTests[tc.id] = {
+        testId: tc.id,
+        testName: tc.story.scenario,
+        sourceFile: tc.sourceFile,
+        sourceLine: tc.sourceLine,
+        entries: [entry]
+      };
+    }
+  }
+  return {
+    version: 1,
+    maxRuns,
+    tests: newTests,
+    lastUpdated: Date.now()
+  };
+}
+
+// src/history/flakiness.ts
+function calculateFlakiness(args) {
+  const { entries } = args;
+  const countable = entries.filter(
+    (e) => e.status === "passed" || e.status === "failed"
+  );
+  if (countable.length < MIN_FLAKINESS_SAMPLES) {
+    return {
+      flakinessLevel: "stable",
+      flakinessScore: 0,
+      failureRate: 0,
+      longestPassStreak: countable.length,
+      longestFailStreak: 0
+    };
+  }
+  let transitions = 0;
+  for (let i = 1; i < countable.length; i++) {
+    if (countable[i].status !== countable[i - 1].status) {
+      transitions++;
+    }
+  }
+  const transitionScore = transitions / (countable.length - 1);
+  const failures = countable.filter((e) => e.status === "failed").length;
+  const failureRate = failures / countable.length;
+  let longestPassStreak = 0;
+  let longestFailStreak = 0;
+  let currentPassStreak = 0;
+  let currentFailStreak = 0;
+  for (const e of countable) {
+    if (e.status === "passed") {
+      currentPassStreak++;
+      currentFailStreak = 0;
+      if (currentPassStreak > longestPassStreak) {
+        longestPassStreak = currentPassStreak;
+      }
+    } else {
+      currentFailStreak++;
+      currentPassStreak = 0;
+      if (currentFailStreak > longestFailStreak) {
+        longestFailStreak = currentFailStreak;
+      }
+    }
+  }
+  let flakinessLevel;
+  if (transitionScore > 0.5 || transitionScore > 0.3 && failureRate > 0.2) {
+    flakinessLevel = "flaky";
+  } else if (transitionScore > 0.2 || failureRate > 0.3) {
+    flakinessLevel = "unstable";
+  } else {
+    flakinessLevel = "stable";
+  }
+  return {
+    flakinessLevel,
+    flakinessScore: transitionScore,
+    failureRate,
+    longestPassStreak,
+    longestFailStreak
+  };
+}
+
+// src/history/performance.ts
+function detectPerformanceTrend(args) {
+  const { entries } = args;
+  const countable = entries.filter(
+    (e) => e.status !== "skipped" && e.status !== "pending"
+  );
+  if (countable.length === 0) {
+    return { trend: "stable", avgDurationMs: 0 };
+  }
+  const avgAll = countable.reduce((sum, e) => sum + e.durationMs, 0) / countable.length;
+  if (countable.length < MIN_PERF_SAMPLES) {
+    return { trend: "stable", avgDurationMs: avgAll };
+  }
+  const mid = Math.floor(countable.length / 2);
+  const earlier = countable.slice(0, mid);
+  const recent = countable.slice(mid);
+  const earlierAvg = earlier.reduce((sum, e) => sum + e.durationMs, 0) / earlier.length;
+  const recentAvg = recent.reduce((sum, e) => sum + e.durationMs, 0) / recent.length;
+  let trend;
+  if (earlierAvg === 0) {
+    trend = "stable";
+  } else {
+    const change = (recentAvg - earlierAvg) / earlierAvg;
+    if (change > 0.1) {
+      trend = "regressing";
+    } else if (change < -0.1) {
+      trend = "improving";
+    } else {
+      trend = "stable";
+    }
+  }
+  return { trend, avgDurationMs: avgAll };
+}
+
+// src/history/stability.ts
+function calculateStability(args) {
+  const { passRate, flakinessScore, longestPassStreak, sampleSize } = args;
+  const inverseFlakiness = 1 - flakinessScore;
+  const streakNorm = longestPassStreak / Math.min(sampleSize, 10);
+  const score = passRate * 0.6 + inverseFlakiness * 0.3 + streakNorm * 0.1;
+  if (score >= 0.95) return "A";
+  if (score >= 0.85) return "B";
+  if (score >= 0.7) return "C";
+  if (score >= 0.5) return "D";
+  return "F";
+}
+
+// src/history/metrics.ts
+function computeTestMetrics(args) {
+  const { testId, entries } = args;
+  const flakiness = calculateFlakiness({ entries });
+  const perf = detectPerformanceTrend({ entries });
+  const countable = entries.filter(
+    (e) => e.status === "passed" || e.status === "failed"
+  );
+  const passRate = countable.length > 0 ? countable.filter((e) => e.status === "passed").length / countable.length : 1;
+  const stabilityGrade = calculateStability({
+    passRate,
+    flakinessScore: flakiness.flakinessScore,
+    longestPassStreak: flakiness.longestPassStreak,
+    sampleSize: entries.length
+  });
+  let consecutiveFailures = 0;
+  for (let i = entries.length - 1; i >= 0; i--) {
+    if (entries[i].status === "failed") {
+      consecutiveFailures++;
+    } else {
+      break;
+    }
+  }
+  return {
+    testId,
+    flakinessLevel: flakiness.flakinessLevel,
+    flakinessScore: flakiness.flakinessScore,
+    failureRate: flakiness.failureRate,
+    stabilityGrade,
+    performanceTrend: perf.trend,
+    avgDurationMs: perf.avgDurationMs,
+    passRate,
+    longestPassStreak: flakiness.longestPassStreak,
+    consecutiveFailures,
+    sampleSize: entries.length
+  };
+}
+
 // src/index.ts
 var FORMAT_EXTENSIONS = {
   markdown: ".md",
@@ -6074,6 +6919,9 @@ export {
   CucumberMessagesFormatter,
   HtmlFormatter,
   JUnitFormatter,
+  MIN_FLAKINESS_SAMPLES,
+  MIN_METRIC_SAMPLES,
+  MIN_PERF_SAMPLES,
   MarkdownFormatter,
   ReportGenerator,
   STORY_META_KEY,
@@ -6081,15 +6929,21 @@ export {
   adaptPlaywrightRun,
   adaptVitestRun,
   assertValidRun,
+  calculateFlakiness,
+  calculateStability,
   canonicalizeRun,
   clearVersionCache,
+  computeTestMetrics,
   createReportGenerator,
   deriveStepResults,
   detectCI4 as detectCI,
+  detectPerformanceTrend,
   findGitDir,
   formatDuration2 as formatDuration,
   generateRunId,
   generateTestCaseId,
+  hasSufficientHistory,
+  loadHistory,
   mergeStepResults,
   msToNanoseconds,
   nanosecondsToMs,
@@ -6105,8 +6959,18 @@ export {
   resolveAttachment,
   resolveAttachments,
   resolveTraceUrl,
+  saveHistory,
+  sendNotifications,
+  sendSlackNotification,
+  sendTeamsNotification,
+  sendWebhookNotification,
+  signBody,
   slugify,
+  stripAnsi,
+  toCIInfo,
+  toRawCIInfo,
   tryGetActiveOtelContext,
+  updateHistory,
   validateCanonicalRun
 };
 //# sourceMappingURL=index.js.map