executable-stories-formatters 0.7.7 → 0.7.9

package/dist/index.js

@@ -32,8 +32,8 @@ function generateRunId(startedAtMs, projectRoot) {
   const input = `${startedAtMs}::${projectRoot}`;
   return createHash("sha1").update(input).digest("hex").slice(0, 16);
 }
-function slugify(text) {
-  return text.toLowerCase().replace(/[/\\]+/g, "-").replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+function slugify(text2) {
+  return text2.toLowerCase().replace(/[/\\]+/g, "-").replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
 }
 function generateFeatureId(uri) {
   const pathWithoutExt = uri.replace(/\.[^.]+$/, "");
@@ -13022,7 +13022,7 @@ function renderDocEntry(entry, deps) {
 // src/formatters/html/renderers/steps.ts
 var CONTINUATION_KEYWORDS = ["And", "But", "*"];
 function renderStep(step, stepResult, index, deps) {
-  const statusIcon = stepResult ? deps.getStatusIcon(stepResult.status) : "\u25CB";
+  const statusIcon2 = stepResult ? deps.getStatusIcon(stepResult.status) : "\u25CB";
   const statusClass = stepResult ? `status-${stepResult.status}` : "";
   const duration = stepResult && stepResult.durationMs > 0 ? `${stepResult.durationMs}ms` : "";
   const keywordTrimmed = step.keyword.trim();
@@ -13031,7 +13031,7 @@ function renderStep(step, stepResult, index, deps) {
   const stepDocs = deps.renderDocs(step.docs, "step-docs");
   const textHtml = deps.highlightStepParams ? deps.highlightStepParams(step.text) : deps.escapeHtml(step.text);
   return `<div class="${stepClass}" data-keyword="${deps.escapeHtml(keywordTrimmed)}" data-text="${deps.escapeHtml(step.text)}">
-  <span class="step-status ${statusClass}">${statusIcon}</span>
+  <span class="step-status ${statusClass}">${statusIcon2}</span>
   <span class="step-keyword">${deps.escapeHtml(step.keyword)}</span>
   <span class="step-text">${textHtml}</span>
   <span class="step-duration">${duration}</span>
@@ -13047,10 +13047,10 @@ function renderSteps(args, deps) {
 
 // src/formatters/html/renderers/step-params.ts
 var STEP_PARAM_PATTERN = /"[^"]*"|(?<![\w.\-])\d+(?:\.\d+)?(?![\w.\-])/g;
-function highlightStepParams(text, deps) {
-  const matches = Array.from(text.matchAll(STEP_PARAM_PATTERN));
+function highlightStepParams(text2, deps) {
+  const matches = Array.from(text2.matchAll(STEP_PARAM_PATTERN));
   if (matches.length === 0) {
-    return deps.escapeHtml(text);
+    return deps.escapeHtml(text2);
   }
   let result = "";
   let lastIndex = 0;
@@ -13058,13 +13058,13 @@ function highlightStepParams(text, deps) {
     const matchStart = match.index;
     const matchEnd = matchStart + match[0].length;
     if (matchStart > lastIndex) {
-      result += deps.escapeHtml(text.slice(lastIndex, matchStart));
+      result += deps.escapeHtml(text2.slice(lastIndex, matchStart));
     }
     result += `<span class="step-param">${deps.escapeHtml(match[0])}</span>`;
     lastIndex = matchEnd;
   }
-  if (lastIndex < text.length) {
-    result += deps.escapeHtml(text.slice(lastIndex));
+  if (lastIndex < text2.length) {
+    result += deps.escapeHtml(text2.slice(lastIndex));
   }
   return result;
 }
@@ -13087,7 +13087,7 @@ function renderTicket(ticket, template, escapeHtml3) {
 }
 function renderScenario(args, deps) {
   const { tc } = args;
-  const statusIcon = deps.getStatusIcon(tc.status);
+  const statusIcon2 = deps.getStatusIcon(tc.status);
   const statusClass = `status-${tc.status}`;
   const duration = tc.durationMs > 0 ? `${(tc.durationMs / 1e3).toFixed(2)}s` : "";
   const tags = tc.tags.map((t) => `<span class="tag">${deps.escapeHtml(t)}</span>`).join("");
@@ -13156,7 +13156,7 @@ function renderScenario(args, deps) {
   <div class="scenario-header" role="button" tabindex="0" aria-expanded="${ariaExpanded}">
     <div class="scenario-info">
       <div class="scenario-title">
-        <span class="status-icon ${statusClass}">${statusIcon}</span>
+        <span class="status-icon ${statusClass}">${statusIcon2}</span>
         <span class="scenario-name">${deps.escapeHtml(tc.story.scenario)}</span>
       </div>
       <div class="scenario-meta">${tags}${tickets}${sourceLink}${traceBadge}${metricBadges}</div>
@@ -13295,11 +13295,11 @@ function buildTooltip(span, escapeHtml3) {
       parts.push(`${key}=${formatted}`);
     }
   }
-  let text = parts.join("\n");
-  if (text.length > TOOLTIP_MAX_LENGTH) {
-    text = text.slice(0, TOOLTIP_MAX_LENGTH - 3) + "...";
+  let text2 = parts.join("\n");
+  if (text2.length > TOOLTIP_MAX_LENGTH) {
+    text2 = text2.slice(0, TOOLTIP_MAX_LENGTH - 3) + "...";
   }
-  return escapeHtml3(text);
+  return escapeHtml3(text2);
 }
 function renderTraceView(args, deps) {
   if (!args.spans || args.spans.length === 0) return "";
@@ -13522,11 +13522,11 @@ function renderToc(args, deps) {
     const featureName = suitePaths.length > 0 && suitePaths[0].length > 0 ? suitePaths[0][0] : file.split("/").pop()?.replace(/\.[^.]+$/, "") ?? file;
     const featureSlug = `feature-${slugify(file)}`;
     const scenarios = testCases.map((tc) => {
-      const statusIcon = deps.getStatusIcon(tc.status);
+      const statusIcon2 = deps.getStatusIcon(tc.status);
       const statusClass = `status-${tc.status}`;
       const failedClass = tc.status === "failed" ? " toc-failed" : "";
       return `<a class="toc-scenario${failedClass}" href="#scenario-${tc.id}">
-          <span class="toc-status ${statusClass}">${statusIcon}</span>
+          <span class="toc-status ${statusClass}">${statusIcon2}</span>
           ${deps.escapeHtml(tc.story.scenario)}
         </a>`;
     }).join("\n");
@@ -13584,7 +13584,7 @@ function createHtmlFormatter(options = {}) {
     escapeHtml,
     getStatusIcon,
     renderDocs,
-    highlightStepParams: (text) => highlightStepParams(text, { escapeHtml })
+    highlightStepParams: (text2) => highlightStepParams(text2, { escapeHtml })
   };
   const scenarioDeps = {
     escapeHtml,
@@ -14519,7 +14519,7 @@ function deterministicId(kind, salt, ...parts) {
 
 // src/formatters/cucumber-messages/build-gherkin-document.ts
 function buildGherkinDocumentEnvelopes(uri, testCases, synthesized, salt) {
-  const { lineMap, featureName, featureTags, text } = synthesized;
+  const { lineMap, featureName, featureTags, text: text2 } = synthesized;
   const featureTagNodes = featureTags.map((tag, i) => ({
     location: {
       line: lineMap.featureTagLine ?? 1,
@@ -14588,7 +14588,7 @@ function buildGherkinDocumentEnvelopes(uri, testCases, synthesized, salt) {
     sourceEnvelope: {
       source: {
         uri,
-        data: text,
+        data: text2,
         mediaType: "text/x.cucumber.gherkin+plain"
       }
     },
@@ -14599,8 +14599,8 @@ function buildStepArguments(step, stepLine) {
   if (!step.docs || step.docs.length === 0) return {};
   const tableDocs = step.docs.filter((d) => d.kind === "table");
   if (tableDocs.length > 0) {
-    const table = tableDocs[0];
-    return { dataTable: buildDataTable(table, stepLine + 1) };
+    const table2 = tableDocs[0];
+    return { dataTable: buildDataTable(table2, stepLine + 1) };
   }
   for (const doc of step.docs) {
     const ds = docEntryToDocString(doc, stepLine + 1);
@@ -14671,21 +14671,21 @@ function docEntryToDocString(doc, line) {
       return void 0;
   }
 }
-function buildDataTable(table, line) {
+function buildDataTable(table2, line) {
   const rows = [];
   rows.push({
     location: { line },
-    cells: table.columns.map((col) => ({
+    cells: table2.columns.map((col) => ({
       location: { line },
       value: col
     })),
     id: ""
   });
-  for (let r = 0; r < table.rows.length; r++) {
+  for (let r = 0; r < table2.rows.length; r++) {
     const rowLine = line + 1 + r;
     rows.push({
       location: { line: rowLine },
-      cells: table.rows[r].map((cell) => ({
+      cells: table2.rows[r].map((cell) => ({
         location: { line: rowLine },
         value: cell
       })),
@@ -14776,12 +14776,12 @@ function docEntryToPickleDocString(doc) {
       return void 0;
   }
 }
-function buildPickleTable(table) {
+function buildPickleTable(table2) {
   const rows = [];
   rows.push({
-    cells: table.columns.map((col) => ({ value: col }))
+    cells: table2.columns.map((col) => ({ value: col }))
   });
-  for (const row of table.rows) {
+  for (const row of table2.rows) {
     rows.push({
       cells: row.map((cell) => ({ value: cell }))
     });
@@ -16197,6 +16197,414 @@ ${body}`;
   }
 };
 
+// src/formatters/confluence.ts
+var ConfluenceFormatter = class {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      title: options.title ?? "User Stories",
+      includeStatusIcons: options.includeStatusIcons ?? true,
+      includeMetadata: options.includeMetadata ?? true,
+      includeSummaryTable: options.includeSummaryTable ?? true,
+      includeErrors: options.includeErrors ?? true,
+      scenarioHeadingLevel: options.scenarioHeadingLevel ?? 3,
+      groupBy: options.groupBy ?? "file",
+      sortScenarios: options.sortScenarios ?? "source",
+      pretty: options.pretty ?? true,
+      permalinkBaseUrl: options.permalinkBaseUrl,
+      ticketUrlTemplate: options.ticketUrlTemplate
+    };
+  }
+  /** Build the ADF document tree. Returns the JS object (not stringified). */
+  formatToAdf(run) {
+    const content = [];
+    content.push(heading(1, [text(this.options.title)]));
+    if (this.options.includeMetadata) {
+      const metaTable = this.renderMetadataTable(run);
+      if (metaTable) content.push(metaTable);
+    }
+    if (this.options.includeSummaryTable) {
+      content.push(this.renderSummaryTable(run));
+    }
+    switch (this.options.groupBy) {
+      case "none":
+        this.renderFlat(content, run.testCases);
+        break;
+      case "suite":
+        this.renderBySuite(content, run.testCases);
+        break;
+      case "file":
+      default:
+        this.renderByFile(content, run.testCases);
+        break;
+    }
+    return { version: 1, type: "doc", content };
+  }
+  /** Format a test run as an ADF JSON string. */
+  format(run) {
+    const adf = this.formatToAdf(run);
+    return this.options.pretty ? JSON.stringify(adf, null, 2) : JSON.stringify(adf);
+  }
+  // --------------------------------------------------------------------------
+  // Metadata / summary tables
+  // --------------------------------------------------------------------------
+  renderMetadataTable(run) {
+    const rows = [];
+    rows.push(["Date", new Date(run.startedAtMs).toISOString()]);
+    if (run.packageVersion) rows.push(["Version", run.packageVersion]);
+    if (run.gitSha) {
+      const shortSha = run.gitSha.length > 7 ? run.gitSha.slice(0, 7) : run.gitSha;
+      rows.push(["Git SHA", shortSha]);
+    }
+    if (rows.length === 0) return null;
+    return table([
+      tableRow([tableHeader("Key"), tableHeader("Value")]),
+      ...rows.map(([k, v]) => tableRow([tableCell(k), tableCell(v)]))
+    ]);
+  }
+  renderSummaryTable(run) {
+    const total = run.testCases.length;
+    const steps = run.testCases.reduce(
+      (acc, tc) => acc + tc.story.steps.length,
+      0
+    );
+    const passed = run.testCases.filter((tc) => tc.status === "passed").length;
+    const failed = run.testCases.filter((tc) => tc.status === "failed").length;
+    const skipped = run.testCases.filter((tc) => tc.status === "skipped").length;
+    const pending = run.testCases.filter((tc) => tc.status === "pending").length;
+    return table([
+      tableRow([
+        tableHeader("Scenarios"),
+        tableHeader("Steps"),
+        tableHeader("Passed"),
+        tableHeader("Failed"),
+        tableHeader("Skipped"),
+        tableHeader("Pending"),
+        tableHeader("Duration")
+      ]),
+      tableRow([
+        tableCell(String(total)),
+        tableCell(String(steps)),
+        tableCell(String(passed)),
+        tableCell(String(failed)),
+        tableCell(String(skipped)),
+        tableCell(String(pending)),
+        tableCell(formatDuration2(run.durationMs))
+      ])
+    ]);
+  }
+  // --------------------------------------------------------------------------
+  // Grouping
+  // --------------------------------------------------------------------------
+  renderByFile(content, testCases) {
+    const byFile = groupBy7(testCases, (tc) => tc.sourceFile);
+    for (const [file, fileCases] of byFile) {
+      content.push(heading(2, [codeInline(file)]));
+      this.renderSuiteGroups(content, fileCases, 3);
+    }
+  }
+  renderBySuite(content, testCases) {
+    this.renderSuiteGroups(content, testCases, 2);
+  }
+  renderFlat(content, testCases) {
+    const sorted = this.sortCases(testCases);
+    for (const tc of sorted) this.renderScenario(content, tc);
+  }
+  renderSuiteGroups(content, testCases, baseLevel) {
+    const bySuite = groupBy7(testCases, (tc) => tc.titlePath.join(" - "));
+    const entries = this.sortSuiteGroups([...bySuite.entries()]);
+    for (const [suitePath, cases] of entries) {
+      if (suitePath) {
+        content.push(
+          heading(clampHeadingLevel(baseLevel), [text(suitePath)])
+        );
+      }
+      for (const tc of this.sortCases(cases)) {
+        this.renderScenario(content, tc);
+      }
+    }
+  }
+  // --------------------------------------------------------------------------
+  // Scenario
+  // --------------------------------------------------------------------------
+  renderScenario(content, tc) {
+    const level = clampHeadingLevel(this.options.scenarioHeadingLevel);
+    const headingNodes = [];
+    if (this.options.includeStatusIcons) {
+      headingNodes.push(text(`${statusIcon(tc.status)} `));
+    }
+    headingNodes.push(text(tc.story.scenario));
+    content.push(heading(level, headingNodes));
+    const metaChildren = [];
+    if (tc.tags.length > 0) {
+      metaChildren.push(text("Tags: ", strong()));
+      tc.tags.forEach((t, i) => {
+        if (i > 0) metaChildren.push(text(", "));
+        metaChildren.push(codeInline(t));
+      });
+    }
+    if (tc.story.tickets && tc.story.tickets.length > 0) {
+      if (metaChildren.length > 0) metaChildren.push(text(" | "));
+      metaChildren.push(text("Tickets: ", strong()));
+      tc.story.tickets.forEach((ticket, i) => {
+        if (i > 0) metaChildren.push(text(", "));
+        const url = ticket.url ?? (this.options.ticketUrlTemplate ? this.options.ticketUrlTemplate.replace("{ticket}", ticket.id) : void 0);
+        metaChildren.push(
+          url ? link(ticket.id, url) : codeInline(ticket.id)
+        );
+      });
+    }
+    if (this.options.permalinkBaseUrl && tc.sourceFile !== "unknown" && tc.sourceFile) {
+      if (metaChildren.length > 0) metaChildren.push(text(" | "));
+      metaChildren.push(text("Source: ", strong()));
+      const base = this.options.permalinkBaseUrl.replace(/\/$/, "");
+      const url = `${base}/${tc.sourceFile}${tc.sourceLine > 0 ? `#L${tc.sourceLine}` : ""}`;
+      metaChildren.push(link(tc.sourceFile, url));
+    }
+    if (metaChildren.length > 0) {
+      content.push(paragraph(metaChildren));
+    }
+    if (tc.story.docs && tc.story.docs.length > 0) {
+      for (const doc of tc.story.docs) this.renderDocEntry(content, doc);
+    }
+    if (tc.story.steps.length > 0) {
+      content.push(this.renderStepsList(tc.story.steps));
+      for (const step of tc.story.steps) {
+        if (step.docs && step.docs.length > 0) {
+          for (const doc of step.docs) this.renderDocEntry(content, doc);
+        }
+      }
+    }
+    if (tc.status === "failed" && tc.errorMessage && this.options.includeErrors) {
+      const errorContent = (tc.errorMessage ?? "") + (tc.errorStack ? `
+
+${tc.errorStack}` : "");
+      content.push(
+        panel("warning", [paragraph([text("Failure", strong())])])
+      );
+      content.push(codeBlock(errorContent, "text"));
+    }
+  }
+  renderStepsList(steps) {
+    return {
+      type: "bulletList",
+      content: steps.map((step) => {
+        const children = [text(`${step.keyword} `, strong()), text(step.text)];
+        if (step.mode && step.mode !== "normal") {
+          children.push(text(` (${step.mode})`, em()));
+        }
+        return {
+          type: "listItem",
+          content: [paragraph(children)]
+        };
+      })
+    };
+  }
+  // --------------------------------------------------------------------------
+  // Doc entries
+  // --------------------------------------------------------------------------
+  renderDocEntry(content, entry) {
+    switch (entry.kind) {
+      case "note":
+        content.push(panel("info", [paragraph([text(entry.text)])]));
+        break;
+      case "tag": {
+        const kids = [];
+        entry.names.forEach((name, i) => {
+          if (i > 0) kids.push(text(" "));
+          kids.push(codeInline(name));
+        });
+        if (kids.length > 0) content.push(paragraph(kids));
+        break;
+      }
+      case "kv": {
+        const val = typeof entry.value === "string" ? entry.value : JSON.stringify(entry.value);
+        content.push(
+          paragraph([text(`${entry.label}: `, strong()), codeInline(val)])
+        );
+        break;
+      }
+      case "code":
+        if (entry.label) {
+          content.push(paragraph([text(entry.label, strong())]));
+        }
+        content.push(codeBlock(entry.content ?? "", entry.lang));
+        break;
+      case "table":
+        if (entry.label) {
+          content.push(paragraph([text(entry.label, strong())]));
+        }
+        content.push(
+          table([
+            tableRow(entry.columns.map((c) => tableHeader(c))),
+            ...entry.rows.map(
+              (row) => tableRow(row.map((cell) => tableCell(cell)))
+            )
+          ])
+        );
+        break;
+      case "link":
+        content.push(paragraph([link(entry.label, entry.url)]));
+        break;
+      case "section":
+        if (entry.title) {
+          content.push(paragraph([text(entry.title, strong())]));
+        }
+        if (entry.markdown) {
+          for (const para of entry.markdown.split(/\n{2,}/)) {
+            const trimmed = para.trim();
+            if (trimmed) content.push(paragraph([text(trimmed)]));
+          }
+        }
+        break;
+      case "mermaid":
+        if (entry.title) {
+          content.push(paragraph([text(entry.title, strong())]));
+        }
+        content.push(codeBlock(entry.code ?? "", "mermaid"));
+        break;
+      case "screenshot":
+        content.push(
+          paragraph([
+            text(entry.alt ?? "Screenshot", strong()),
+            text(": "),
+            link(entry.path, entry.path)
+          ])
+        );
+        break;
+      case "custom":
+        content.push(paragraph([text(`[${entry.type}]`, strong())]));
+        content.push(codeBlock(JSON.stringify(entry.data ?? null, null, 2), "json"));
+        break;
+    }
+    if (entry.children && entry.children.length > 0) {
+      for (const child of entry.children) {
+        this.renderDocEntry(content, child);
+      }
+    }
+  }
+  // --------------------------------------------------------------------------
+  // Sorting
+  // --------------------------------------------------------------------------
+  sortCases(cases) {
+    if (this.options.sortScenarios === "alpha") {
+      return [...cases].sort(
+        (a, b) => a.story.scenario.localeCompare(b.story.scenario)
+      );
+    }
+    if (this.options.sortScenarios === "source") {
+      return [...cases].sort(
+        (a, b) => (a.story.sourceOrder ?? 0) - (b.story.sourceOrder ?? 0)
+      );
+    }
+    return cases;
+  }
+  sortSuiteGroups(entries) {
+    if (this.options.sortScenarios === "alpha") {
+      return entries.sort(([a], [b]) => a.localeCompare(b));
+    }
+    if (this.options.sortScenarios === "source") {
+      return entries.sort(([, a], [, b]) => {
+        const minA = Math.min(...a.map((s) => s.story.sourceOrder ?? Infinity));
+        const minB = Math.min(...b.map((s) => s.story.sourceOrder ?? Infinity));
+        return minA - minB;
+      });
+    }
+    return entries;
+  }
+};
+function text(value, mark) {
+  const node = { type: "text", text: value };
+  if (mark) {
+    node.marks = Array.isArray(mark) ? mark : [mark];
+  }
+  return node;
+}
+function strong() {
+  return { type: "strong" };
+}
+function em() {
+  return { type: "em" };
+}
+function codeMark() {
+  return { type: "code" };
+}
+function codeInline(value) {
+  return text(value, codeMark());
+}
+function link(label, href) {
+  return text(label, { type: "link", attrs: { href } });
+}
+function paragraph(content) {
+  return { type: "paragraph", content };
+}
+function heading(level, content) {
+  return {
+    type: "heading",
+    attrs: { level: clampHeadingLevel(level) },
+    content
+  };
+}
+function codeBlock(content, lang) {
+  return {
+    type: "codeBlock",
+    attrs: lang ? { language: lang } : {},
+    content: content ? [{ type: "text", text: content }] : []
+  };
+}
+function panel(panelType, content) {
+  return { type: "panel", attrs: { panelType }, content };
+}
+function table(rows) {
+  return {
+    type: "table",
+    attrs: { isNumberColumnEnabled: false, layout: "default" },
+    content: rows
+  };
+}
+function tableRow(cells) {
+  return { type: "tableRow", content: cells };
+}
+function tableHeader(value) {
+  return { type: "tableHeader", content: [paragraph([text(value)])] };
+}
+function tableCell(value) {
+  return { type: "tableCell", content: [paragraph([text(value)])] };
+}
+function clampHeadingLevel(level) {
+  if (level < 1) return 1;
+  if (level > 6) return 6;
+  return level;
+}
+function statusIcon(status) {
+  switch (status) {
+    case "passed":
+      return "\u2705";
+    case "failed":
+      return "\u274C";
+    case "skipped":
+      return "\u23E9";
+    case "pending":
+      return "\u{1F4DD}";
+    default:
+      return "\u26A0\uFE0F";
+  }
+}
+function formatDuration2(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  return `${(ms / 1e3).toFixed(2)}s`;
+}
+function groupBy7(items, keyFn) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = keyFn(item);
+    const existing = map.get(key);
+    if (existing) existing.push(item);
+    else map.set(key, [item]);
+  }
+  return map;
+}
+
 // src/formatters/astro-assets.ts
 import * as fs4 from "fs";
 import * as path4 from "path";
@@ -16722,6 +17130,235 @@ ${result.errors.join("\n")}`);
   }
 }
 
+// src/publishers/confluence.ts
+function parseAdf(adf) {
+  let parsed;
+  try {
+    parsed = JSON.parse(adf);
+  } catch (err) {
+    throw new Error(
+      `ADF payload is not valid JSON: ${err.message}`
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || parsed.type !== "doc" || !Array.isArray(parsed.content)) {
+    throw new Error(
+      `ADF payload must be an object with { version, type: "doc", content: [...] }`
+    );
+  }
+  return parsed;
+}
+function basicAuthHeader(auth) {
+  const raw = `${auth.email}:${auth.token}`;
+  const encoded = typeof Buffer !== "undefined" ? Buffer.from(raw, "utf8").toString("base64") : btoa(raw);
+  return `Basic ${encoded}`;
+}
+async function parseErrorBody(response) {
+  try {
+    const body = await response.text();
+    return body ? body.slice(0, 800) : "";
+  } catch {
+    return "";
+  }
+}
+async function publishConfluencePage(args, deps) {
+  parseAdf(args.adf);
+  if (!args.pageId && !args.spaceId) {
+    throw new Error(
+      "publishConfluencePage requires either pageId (update) or spaceId (create)"
+    );
+  }
+  if (!args.pageId && !args.title) {
+    throw new Error("Creating a new page requires a title");
+  }
+  const base = args.baseUrl.replace(/\/$/, "");
+  const fetchFn = deps.fetch ?? globalThis.fetch;
+  if (!fetchFn) {
+    throw new Error("No fetch implementation available (Node >= 22 expected)");
+  }
+  const headers = {
+    Authorization: basicAuthHeader(deps.auth),
+    Accept: "application/json",
+    "Content-Type": "application/json"
+  };
+  if (args.pageId) {
+    return updatePage(args, base, headers, fetchFn);
+  }
+  return createPage(args, base, headers, fetchFn);
+}
+async function updatePage(args, base, headers, fetchFn) {
+  const getUrl = `${base}/api/v2/pages/${encodeURIComponent(args.pageId)}`;
+  const getResp = await fetchFn(getUrl, { method: "GET", headers });
+  if (!getResp.ok) {
+    const body = await parseErrorBody(getResp);
+    throw new Error(
+      `GET ${getUrl} failed with ${getResp.status} ${getResp.statusText}${body ? `: ${body}` : ""}`
+    );
+  }
+  const current = await getResp.json();
+  const nextVersion = current.version.number + 1;
+  const title = args.title ?? current.title;
+  const putUrl = `${base}/api/v2/pages/${encodeURIComponent(args.pageId)}`;
+  const putResp = await fetchFn(putUrl, {
+    method: "PUT",
+    headers,
+    body: JSON.stringify({
+      id: args.pageId,
+      status: "current",
+      title,
+      body: {
+        representation: "atlas_doc_format",
+        value: args.adf
+      },
+      version: { number: nextVersion }
+    })
+  });
+  if (!putResp.ok) {
+    const body = await parseErrorBody(putResp);
+    throw new Error(
+      `PUT ${putUrl} failed with ${putResp.status} ${putResp.statusText}${body ? `: ${body}` : ""}`
+    );
+  }
+  const updated = await putResp.json();
+  return {
+    id: updated.id,
+    title: updated.title,
+    version: updated.version.number,
+    url: buildPageUrl(base, updated._links?.webui, updated.id),
+    action: "updated"
+  };
+}
+async function createPage(args, base, headers, fetchFn) {
+  const body = {
+    spaceId: args.spaceId,
+    status: "current",
+    title: args.title,
+    body: {
+      representation: "atlas_doc_format",
+      value: args.adf
+    }
+  };
+  if (args.parentId) body.parentId = args.parentId;
+  const postUrl = `${base}/api/v2/pages`;
+  const resp = await fetchFn(postUrl, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body)
+  });
+  if (!resp.ok) {
+    const errBody = await parseErrorBody(resp);
+    throw new Error(
+      `POST ${postUrl} failed with ${resp.status} ${resp.statusText}${errBody ? `: ${errBody}` : ""}`
+    );
+  }
+  const created = await resp.json();
+  return {
+    id: created.id,
+    title: created.title,
+    version: created.version.number,
+    url: buildPageUrl(base, created._links?.webui, created.id),
+    action: "created"
+  };
+}
+function buildPageUrl(base, webui, id) {
+  if (webui) {
+    return webui.startsWith("http") ? webui : `${base}${webui}`;
+  }
+  return `${base}/pages/${id}`;
+}
+
+// src/publishers/jira.ts
+function parseAdf2(adf) {
+  let parsed;
+  try {
+    parsed = JSON.parse(adf);
+  } catch (err) {
+    throw new Error(
+      `ADF payload is not valid JSON: ${err.message}`
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || parsed.type !== "doc" || !Array.isArray(parsed.content)) {
+    throw new Error(
+      `ADF payload must be an object with { version, type: "doc", content: [...] }`
+    );
+  }
+  return parsed;
+}
+function basicAuthHeader2(auth) {
+  const raw = `${auth.email}:${auth.token}`;
+  const encoded = typeof Buffer !== "undefined" ? Buffer.from(raw, "utf8").toString("base64") : btoa(raw);
+  return `Basic ${encoded}`;
+}
+async function parseErrorBody2(resp) {
+  try {
+    const body = await resp.text();
+    return body ? body.slice(0, 800) : "";
+  } catch {
+    return "";
+  }
+}
+async function publishJiraIssue(args, deps) {
+  const adfObject = parseAdf2(args.adf);
+  if (!args.issueKey) {
+    throw new Error("publishJiraIssue requires an issueKey, e.g. PROJ-123");
+  }
+  const base = args.baseUrl.replace(/\/$/, "");
+  const fetchFn = deps.fetch ?? globalThis.fetch;
+  if (!fetchFn) {
+    throw new Error("No fetch implementation available (Node >= 22 expected)");
+  }
+  const headers = {
+    Authorization: basicAuthHeader2(deps.auth),
+    Accept: "application/json",
+    "Content-Type": "application/json"
+  };
+  const mode = args.mode ?? "comment";
+  if (mode === "description") {
+    return updateDescription(args.issueKey, base, adfObject, headers, fetchFn);
+  }
+  return addComment(args.issueKey, base, adfObject, headers, fetchFn);
+}
+async function addComment(issueKey, base, adf, headers, fetchFn) {
+  const url = `${base}/rest/api/3/issue/${encodeURIComponent(issueKey)}/comment`;
+  const resp = await fetchFn(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ body: adf })
+  });
+  if (!resp.ok) {
+    const body = await parseErrorBody2(resp);
+    throw new Error(
+      `POST ${url} failed with ${resp.status} ${resp.statusText}${body ? `: ${body}` : ""}`
+    );
+  }
+  const comment = await resp.json();
+  const issueUrl = `${base}/browse/${encodeURIComponent(issueKey)}`;
+  return {
+    issueKey,
+    action: "comment-added",
+    url: `${issueUrl}?focusedCommentId=${encodeURIComponent(comment.id)}`,
+    commentId: comment.id
+  };
+}
+async function updateDescription(issueKey, base, adf, headers, fetchFn) {
+  const url = `${base}/rest/api/3/issue/${encodeURIComponent(issueKey)}`;
+  const resp = await fetchFn(url, {
+    method: "PUT",
+    headers,
+    body: JSON.stringify({ fields: { description: adf } })
+  });
+  if (!resp.ok) {
+    const body = await parseErrorBody2(resp);
+    throw new Error(
+      `PUT ${url} failed with ${resp.status} ${resp.statusText}${body ? `: ${body}` : ""}`
+    );
+  }
+  return {
+    issueKey,
+    action: "description-updated",
+    url: `${base}/browse/${encodeURIComponent(issueKey)}`
+  };
+}
+
 // src/converters/ndjson-parser.ts
 function parseNdjson(ndjson) {
   const lines = ndjson.trim().split("\n").filter(Boolean);
@@ -17022,10 +17659,10 @@ function pickleStepArgumentToDocs(ps) {
   const docs = [];
   const phase = "static";
   if (ps.argument.dataTable) {
-    const table = ps.argument.dataTable;
-    if (table.rows.length > 0) {
-      const columns = table.rows[0].cells.map((c) => c.value);
-      const rows = table.rows.slice(1).map((r) => r.cells.map((c) => c.value));
+    const table2 = ps.argument.dataTable;
+    if (table2.rows.length > 0) {
+      const columns = table2.rows[0].cells.map((c) => c.value);
+      const rows = table2.rows.slice(1).map((r) => r.cells.map((c) => c.value));
       docs.push({
         kind: "table",
         label: "",
@@ -17160,7 +17797,7 @@ function readBranchName(cwd = process.cwd()) {
 }
 
 // src/utils/duration.ts
-function formatDuration2(ms) {
+function formatDuration3(ms) {
   if (ms < 1e3) {
     return `${Math.round(ms)} ms`;
   }
@@ -17347,16 +17984,16 @@ function resolveTraceUrl(template, traceId) {
 }
 
 // src/notifiers/ansi-strip.ts
-function stripAnsi(text) {
-  return text.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "");
+function stripAnsi(text2) {
+  return text2.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 truncate(text2, maxLen) {
+  if (text2.length <= maxLen) return text2;
+  return text2.slice(0, maxLen - 3) + "...";
 }
-function formatDuration3(ms) {
+function formatDuration4(ms) {
   const seconds = ms / 1e3;
   if (seconds < 60) return `${seconds.toFixed(1)}s`;
   const minutes = Math.floor(seconds / 60);
@@ -17383,7 +18020,7 @@ function buildSlackPayload(summary, maxFailedTests) {
       { 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: `*Duration:* ${formatDuration4(summary.durationMs)}` },
       { type: "mrkdwn", text: `*Status:* ${statusText}` }
     ]
   });
@@ -17398,9 +18035,9 @@ function buildSlackPayload(summary, maxFailedTests) {
       }
       return `*${name}*`;
     });
-    let text = lines.join("\n\n");
+    let text2 = lines.join("\n\n");
     if (summary.failedTests.length > maxFailedTests) {
-      text += `
+      text2 += `
 
 _...and ${summary.failedTests.length - maxFailedTests} more_`;
     }
@@ -17408,7 +18045,7 @@ _...and ${summary.failedTests.length - maxFailedTests} more_`;
       type: "section",
       text: {
         type: "mrkdwn",
-        text
+        text: text2
       }
     });
   }
@@ -17485,11 +18122,11 @@ async function sendSlackNotification(args, deps) {
 }
 
 // src/notifiers/teams.ts
-function truncate2(text, maxLen) {
-  if (text.length <= maxLen) return text;
-  return text.slice(0, maxLen - 3) + "...";
+function truncate2(text2, maxLen) {
+  if (text2.length <= maxLen) return text2;
+  return text2.slice(0, maxLen - 3) + "...";
 }
-function formatDuration4(ms) {
+function formatDuration5(ms) {
   const seconds = ms / 1e3;
   if (seconds < 60) return `${seconds.toFixed(1)}s`;
   const minutes = Math.floor(seconds / 60);
@@ -17515,7 +18152,7 @@ function buildTeamsPayload(summary, maxFailedTests) {
       { title: "Passed", value: String(summary.passed) },
       { title: "Failed", value: String(summary.failed) },
       { title: "Skipped", value: String(summary.skipped) },
-      { title: "Duration", value: formatDuration4(summary.durationMs) }
+      { title: "Duration", value: formatDuration5(summary.durationMs) }
     ]
   });
   if (summary.failedTests.length > 0) {
@@ -18091,6 +18728,37 @@ function listScenarios(args, _deps) {
     }));
     return JSON.stringify(items, null, 2);
   }
+  if (format === "csv") {
+    const header = "id,scenario,status,sourceFile,sourceLine,tags";
+    const rows = testCases.map((tc) => {
+      const fields = [
+        tc.id,
+        tc.story.scenario,
+        tc.status,
+        tc.sourceFile,
+        String(tc.sourceLine),
+        tc.tags.join(" ")
+      ];
+      return fields.map((f) => {
+        if (f.includes(",") || f.includes('"') || f.includes("\n")) {
+          return `"${f.replace(/"/g, '""')}"`;
+        }
+        return f;
+      }).join(",");
+    });
+    return [header, ...rows].join("\n");
+  }
+  if (format === "markdown-table") {
+    const header = "| Status | Scenario | Location | Tags |";
+    const divider = "|--------|----------|----------|------|";
+    const rows = testCases.map((tc) => {
+      const icon = STATUS_ICONS[tc.status] ?? "?";
+      const location = `${tc.sourceFile}:${tc.sourceLine}`;
+      const tags = tc.tags.map((t) => `@${t}`).join(" ");
+      return `| ${icon} | ${tc.story.scenario} | ${location} | ${tags} |`;
+    });
+    return [header, divider, ...rows].join("\n");
+  }
   if (testCases.length === 0) {
     return "No scenarios found.";
   }
@@ -18138,7 +18806,8 @@ var FORMAT_EXTENSIONS = {
   "cucumber-html": ".cucumber.html",
   junit: ".junit.xml",
   "cucumber-json": ".cucumber.json",
-  "cucumber-messages": ".ndjson"
+  "cucumber-messages": ".ndjson",
+  confluence: ".adf.json"
 };
 var TEST_EXTENSIONS = [
   ".test.ts",
@@ -18306,6 +18975,19 @@ var ReportGenerator = class {
         includeSourceLinks: options.markdown?.includeSourceLinks ?? true,
         customRenderers: options.markdown?.customRenderers
       },
+      confluence: {
+        title: options.confluence?.title ?? "User Stories",
+        includeStatusIcons: options.confluence?.includeStatusIcons ?? true,
+        includeMetadata: options.confluence?.includeMetadata ?? true,
+        includeSummaryTable: options.confluence?.includeSummaryTable ?? true,
+        includeErrors: options.confluence?.includeErrors ?? true,
+        scenarioHeadingLevel: options.confluence?.scenarioHeadingLevel ?? 3,
+        groupBy: options.confluence?.groupBy ?? "file",
+        sortScenarios: options.confluence?.sortScenarios ?? "source",
+        pretty: options.confluence?.pretty ?? true,
+        permalinkBaseUrl: options.confluence?.permalinkBaseUrl,
+        ticketUrlTemplate: options.confluence?.ticketUrlTemplate
+      },
       astro: {
         assetsDir: options.astro?.assetsDir ?? "public/stories/assets",
         assetsBaseUrl: options.astro?.assetsBaseUrl ?? "/stories/assets",
@@ -18481,6 +19163,22 @@ var ReportGenerator = class {
         });
         return formatter.format(run);
       }
+      case "confluence": {
+        const formatter = new ConfluenceFormatter({
+          title: this.options.confluence.title,
+          includeStatusIcons: this.options.confluence.includeStatusIcons,
+          includeMetadata: this.options.confluence.includeMetadata,
+          includeSummaryTable: this.options.confluence.includeSummaryTable,
+          includeErrors: this.options.confluence.includeErrors,
+          scenarioHeadingLevel: this.options.confluence.scenarioHeadingLevel,
+          groupBy: this.options.confluence.groupBy,
+          sortScenarios: this.options.confluence.sortScenarios,
+          pretty: this.options.confluence.pretty,
+          permalinkBaseUrl: this.options.confluence.permalinkBaseUrl,
+          ticketUrlTemplate: this.options.confluence.ticketUrlTemplate
+        });
+        return formatter.format(run);
+      }
       case "markdown": {
         const formatter = new MarkdownFormatter({
           title: this.options.markdown.title,
@@ -18539,6 +19237,7 @@ function normalizePlaywrightResults(testResults, adapterOptions, canonicalizeOpt
 }
 export {
   AstroFormatter,
+  ConfluenceFormatter,
   CucumberHtmlFormatter,
   CucumberJsonFormatter,
   CucumberMessagesFormatter,
@@ -18570,7 +19269,7 @@ export {
   detectPerformanceTrend,
   diffRuns,
   findGitDir,
-  formatDuration2 as formatDuration,
+  formatDuration3 as formatDuration,
   generateRunComparison,
   generateRunId,
   generateTestCaseId,
@@ -18588,6 +19287,8 @@ export {
   normalizeVitestResults,
   parseEnvelopes,
   parseNdjson,
+  publishConfluencePage,
+  publishJiraIssue,
   readBranchName,
   readGitSha,
   readPackageVersion,