executable-stories-formatters 0.7.6 → 0.7.8

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
 import "fs";
-import * as path6 from "path";
+import * as path7 from "path";
 import * as fsPromises from "fs/promises";
 
 // src/converters/acl/status.ts
@@ -15002,8 +15002,8 @@ function extractDocAttachments(step) {
   }
   return attachments;
 }
-function guessMediaType(path7) {
-  const lower = path7.toLowerCase();
+function guessMediaType(path8) {
+  const lower = path8.toLowerCase();
   if (lower.endsWith(".png")) return "image/png";
   if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
   if (lower.endsWith(".gif")) return "image/gif";
@@ -15144,11 +15144,11 @@ var CucumberHtmlFormatter = class {
     for (const envelope of envelopes) {
       const accepted = htmlStream.write(envelope);
       if (!accepted) {
-        await new Promise((resolve5) => htmlStream.once("drain", resolve5));
+        await new Promise((resolve7) => htmlStream.once("drain", resolve7));
       }
     }
-    await new Promise((resolve5, reject) => {
-      collector.on("finish", resolve5);
+    await new Promise((resolve7, reject) => {
+      collector.on("finish", resolve7);
       collector.on("error", reject);
       htmlStream.end();
     });
@@ -16150,6 +16150,177 @@ function replaceAssetRef(html, original, replacement) {
   return html;
 }
 
+// src/formatters/astro.ts
+var AstroFormatter = class _AstroFormatter {
+  markdownFormatter;
+  title;
+  constructor(options = {}) {
+    this.title = options.markdown?.title ?? "User Stories";
+    this.markdownFormatter = new MarkdownFormatter({
+      ...options.markdown,
+      title: this.title,
+      stepStyle: "gherkin",
+      includeFrontMatter: false,
+      includeSummaryTable: false,
+      includeMetadata: false
+    });
+  }
+  format(run) {
+    const markdown = this.markdownFormatter.format(run);
+    const body = markdown.replace(/^# .+\n\n?/, "");
+    const frontmatter = this.buildFrontmatter(run);
+    return `${frontmatter}
+${body}`;
+  }
+  buildFrontmatter(run) {
+    const badge = _AstroFormatter.computeBadge(run.testCases);
+    const count = run.testCases.length;
+    const description = `${count} scenario${count !== 1 ? "s" : ""} \u2014 ${badge.text.toLowerCase()}`;
+    const lines = [
+      "---",
+      `title: ${this.title}`,
+      `description: ${description}`,
+      "sidebar:",
+      "  badge:",
+      `    text: ${badge.text}`,
+      `    variant: ${badge.variant}`,
+      "---"
+    ];
+    return lines.join("\n");
+  }
+  static computeBadge(testCases) {
+    const statuses = new Set(testCases.map((tc) => tc.status));
+    if (statuses.has("failed")) return { text: "Failed", variant: "danger" };
+    if (statuses.has("pending")) return { text: "Pending", variant: "caution" };
+    if (statuses.has("skipped") && !statuses.has("passed")) return { text: "Skipped", variant: "caution" };
+    return { text: "Passed", variant: "success" };
+  }
+};
+
+// src/formatters/astro-assets.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+var SKIP_PREFIXES = ["http://", "https://", "data:", "#"];
+function isLocalPath(src) {
+  const trimmed = src.trim();
+  if (SKIP_PREFIXES.some((prefix) => trimmed.startsWith(prefix))) {
+    return false;
+  }
+  return !path4.posix.isAbsolute(trimmed) && !path4.win32.isAbsolute(trimmed);
+}
+function stripCodeContent(markdown) {
+  let result = markdown.replace(/^[ \t]*(`{3,}|~{3,})[^\n]*\n[\s\S]*?^[ \t]*\1\s*$/gm, "");
+  result = result.replace(/(`+)(?:(?!\1).)+\1/g, "");
+  result = result.replace(/<pre\b[^>]*>[\s\S]*?<\/pre>/gi, "");
+  result = result.replace(/<code\b[^>]*>[\s\S]*?<\/code>/gi, "");
+  return result;
+}
+function scanMarkdownAssets(markdown) {
+  const found = /* @__PURE__ */ new Set();
+  const stripped = stripCodeContent(markdown);
+  const mdImageRe = /!\[[^\]]*\]\(([^)"'\s]+)(?:\s+["'][^"']*["'])?\s*\)/g;
+  let match;
+  while ((match = mdImageRe.exec(stripped)) !== null) {
+    const src = match[1].trim();
+    if (isLocalPath(src)) {
+      found.add(src);
+    }
+  }
+  const htmlSrcRe = /<(?:img|source|video)[^>]+\bsrc=["']([^"']+)["'][^>]*>/gi;
+  while ((match = htmlSrcRe.exec(stripped)) !== null) {
+    const src = match[1].trim();
+    if (isLocalPath(src)) {
+      found.add(src);
+    }
+  }
+  return Array.from(found);
+}
+function splitByCode(markdown) {
+  const codeRe = /^[ \t]*(`{3,}|~{3,})[^\n]*\n[\s\S]*?^[ \t]*\1\s*$|<pre\b[^>]*>[\s\S]*?<\/pre>|<code\b[^>]*>[\s\S]*?<\/code>|(`+)(?:(?!\2).)+\2/gim;
+  const segments = [];
+  let lastIndex = 0;
+  for (const match of markdown.matchAll(codeRe)) {
+    if (match.index > lastIndex) {
+      segments.push(markdown.slice(lastIndex, match.index));
+    }
+    segments.push(match[0]);
+    lastIndex = match.index + match[0].length;
+  }
+  if (lastIndex < markdown.length) {
+    segments.push(markdown.slice(lastIndex));
+  }
+  return segments;
+}
+function isCode(segment) {
+  const trimmed = segment.trimStart();
+  return trimmed.startsWith("`") || trimmed.startsWith("~") || trimmed.startsWith("<pre") || trimmed.startsWith("<code");
+}
+function rewriteProseSegment(prose, assetsBaseUrl, pathMap) {
+  let result = prose;
+  result = result.replace(
+    /(!\[[^\]]*\]\()([^)"'\s]+)((?:\s+["'][^"']*["'])?\s*\))/g,
+    (full, pre, src, post) => {
+      const trimmed = src.trim();
+      if (!isLocalPath(trimmed)) return full;
+      if (pathMap) {
+        const mapped = pathMap.get(trimmed);
+        if (mapped === void 0) return full;
+        return `${pre}${assetsBaseUrl}/${mapped}${post}`;
+      }
+      return `${pre}${assetsBaseUrl}/${trimmed}${post}`;
+    }
+  );
+  result = result.replace(
+    /(<(?:img|source|video)[^>]+\bsrc=["'])([^"']+)(["'][^>]*>)/gi,
+    (full, pre, src, post) => {
+      const trimmed = src.trim();
+      if (!isLocalPath(trimmed)) return full;
+      if (pathMap) {
+        const mapped = pathMap.get(trimmed);
+        if (mapped === void 0) return full;
+        return `${pre}${assetsBaseUrl}/${mapped}${post}`;
+      }
+      return `${pre}${assetsBaseUrl}/${trimmed}${post}`;
+    }
+  );
+  return result;
+}
+function rewriteAssetPaths(markdown, assetsBaseUrl, pathMap) {
+  return splitByCode(markdown).map((seg) => isCode(seg) ? seg : rewriteProseSegment(seg, assetsBaseUrl, pathMap)).join("");
+}
+function copyMarkdownAssets(options) {
+  const {
+    markdown,
+    markdownDir,
+    assetsDir,
+    assetsBaseUrl,
+    allowMissing = false
+  } = options;
+  const refs = scanMarkdownAssets(markdown);
+  const pathMap = /* @__PURE__ */ new Map();
+  const missing = [];
+  for (const ref of refs) {
+    const absPath = path4.resolve(markdownDir, ref);
+    if (!fs4.existsSync(absPath)) {
+      if (!allowMissing) {
+        throw new Error(`Asset not found: ${absPath}`);
+      }
+      missing.push(ref);
+      continue;
+    }
+    const relativeCopied = copyAsset(absPath, assetsDir);
+    const fileName = relativeCopied.replace(/^assets\//, "");
+    pathMap.set(ref, fileName);
+  }
+  const rewritten = rewriteAssetPaths(markdown, assetsBaseUrl, pathMap);
+  return {
+    markdown: rewritten,
+    copiedCount: pathMap.size,
+    missingCount: missing.length,
+    missing
+  };
+}
+
 // src/converters/adapters/jest.ts
 function mapJestStatus(status) {
   switch (status) {
@@ -16917,27 +17088,27 @@ function pickleStepArgumentToDocs(ps) {
 }
 
 // src/utils/git-info.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 function readGitSha(cwd = process.cwd()) {
   const envSha = process.env.GITHUB_SHA || process.env.GIT_COMMIT || process.env.CI_COMMIT_SHA;
   if (envSha) return envSha;
   const gitDir = findGitDir(cwd);
   if (!gitDir) return void 0;
   try {
-    const headPath = path4.join(gitDir, "HEAD");
-    const head = fs4.readFileSync(headPath, "utf8").trim();
+    const headPath = path5.join(gitDir, "HEAD");
+    const head = fs5.readFileSync(headPath, "utf8").trim();
     if (!head.startsWith("ref:")) {
       return head;
     }
     const refPath = head.replace("ref:", "").trim();
-    const refFile = path4.join(gitDir, refPath);
-    if (fs4.existsSync(refFile)) {
-      return fs4.readFileSync(refFile, "utf8").trim();
+    const refFile = path5.join(gitDir, refPath);
+    if (fs5.existsSync(refFile)) {
+      return fs5.readFileSync(refFile, "utf8").trim();
     }
-    const packedRefs = path4.join(gitDir, "packed-refs");
-    if (fs4.existsSync(packedRefs)) {
-      const content = fs4.readFileSync(packedRefs, "utf8");
+    const packedRefs = path5.join(gitDir, "packed-refs");
+    if (fs5.existsSync(packedRefs)) {
+      const content = fs5.readFileSync(packedRefs, "utf8");
       for (const line of content.split("\n")) {
         if (!line || line.startsWith("#") || line.startsWith("^")) continue;
         const [sha, ref] = line.split(" ");
@@ -16952,19 +17123,19 @@ function readGitSha(cwd = process.cwd()) {
 function findGitDir(start) {
   let current = start;
   while (true) {
-    const candidate = path4.join(current, ".git");
-    if (fs4.existsSync(candidate)) {
-      const stat = fs4.statSync(candidate);
+    const candidate = path5.join(current, ".git");
+    if (fs5.existsSync(candidate)) {
+      const stat = fs5.statSync(candidate);
       if (stat.isFile()) {
-        const content = fs4.readFileSync(candidate, "utf8").trim();
+        const content = fs5.readFileSync(candidate, "utf8").trim();
         const match = content.match(/^gitdir: (.+)$/);
         if (match) {
-          return path4.resolve(current, match[1]);
+          return path5.resolve(current, match[1]);
         }
       }
       return candidate;
     }
-    const parent = path4.dirname(current);
+    const parent = path5.dirname(current);
     if (parent === current) return void 0;
     current = parent;
   }
@@ -16975,8 +17146,8 @@ function readBranchName(cwd = process.cwd()) {
   const gitDir = findGitDir(cwd);
   if (!gitDir) return void 0;
   try {
-    const headPath = path4.join(gitDir, "HEAD");
-    const head = fs4.readFileSync(headPath, "utf8").trim();
+    const headPath = path5.join(gitDir, "HEAD");
+    const head = fs5.readFileSync(headPath, "utf8").trim();
     if (head.startsWith("ref:")) {
       const refPath = head.replace("ref:", "").trim();
       const match = refPath.match(/^refs\/heads\/(.+)$/);
@@ -17013,8 +17184,8 @@ function nanosecondsToMs(ns) {
 }
 
 // src/utils/metadata.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path6 from "path";
 var versionCache = /* @__PURE__ */ new Map();
 function readPackageVersion(root) {
   if (versionCache.has(root)) {
@@ -17025,18 +17196,18 @@ function readPackageVersion(root) {
   return version;
 }
 function findPackageVersion(startDir) {
-  let current = path5.resolve(startDir);
+  let current = path6.resolve(startDir);
   while (true) {
-    const pkgPath = path5.join(current, "package.json");
+    const pkgPath = path6.join(current, "package.json");
     try {
-      if (fs5.existsSync(pkgPath)) {
-        const raw = fs5.readFileSync(pkgPath, "utf8");
+      if (fs6.existsSync(pkgPath)) {
+        const raw = fs6.readFileSync(pkgPath, "utf8");
         const parsed = JSON.parse(raw);
         return parsed.version;
       }
     } catch {
     }
-    const parent = path5.dirname(current);
+    const parent = path6.dirname(current);
     if (parent === current) {
       return void 0;
     }
@@ -17920,6 +18091,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.";
   }
@@ -17961,6 +18163,7 @@ function listScenarios(args, _deps) {
 
 // src/index.ts
 var FORMAT_EXTENSIONS = {
+  astro: ".md",
   markdown: ".md",
   html: ".html",
   "cucumber-html": ".cucumber.html",
@@ -17993,11 +18196,11 @@ function computeOutputPath(sourceFile, format, mode, colocatedStyle, baseOutputD
   const ext = FORMAT_EXTENSIONS[format];
   const effectiveName = outputName + (outputNameSuffix ?? "");
   if (mode === "aggregated") {
-    return toPosix(path6.join(baseOutputDir, `${effectiveName}${ext}`));
+    return toPosix(path7.join(baseOutputDir, `${effectiveName}${ext}`));
   }
   const normalizedSource = toPosix(sourceFile);
-  const dirOfSource = path6.posix.dirname(normalizedSource);
-  let baseName = path6.posix.basename(normalizedSource);
+  const dirOfSource = path7.posix.dirname(normalizedSource);
+  let baseName = path7.posix.basename(normalizedSource);
   for (const testExt of TEST_EXTENSIONS) {
     if (baseName.endsWith(testExt)) {
       baseName = baseName.slice(0, -testExt.length);
@@ -18006,9 +18209,9 @@ function computeOutputPath(sourceFile, format, mode, colocatedStyle, baseOutputD
   }
   const fileName = `${baseName}.${effectiveName}${ext}`;
   if (colocatedStyle === "adjacent") {
-    return toPosix(path6.posix.join(dirOfSource, fileName));
+    return toPosix(path7.posix.join(dirOfSource, fileName));
   }
-  return toPosix(path6.posix.join(baseOutputDir, dirOfSource, fileName));
+  return toPosix(path7.posix.join(baseOutputDir, dirOfSource, fileName));
 }
 function groupTestCasesByOutput(testCases, format, options, logger, outputNameSuffix) {
   const groups = /* @__PURE__ */ new Map();
@@ -18134,6 +18337,24 @@ var ReportGenerator = class {
         includeSourceLinks: options.markdown?.includeSourceLinks ?? true,
         customRenderers: options.markdown?.customRenderers
       },
+      astro: {
+        assetsDir: options.astro?.assetsDir ?? "public/stories/assets",
+        assetsBaseUrl: options.astro?.assetsBaseUrl ?? "/stories/assets",
+        markdown: {
+          title: options.astro?.markdown?.title ?? "User Stories",
+          includeStatusIcons: options.astro?.markdown?.includeStatusIcons ?? true,
+          includeErrors: options.astro?.markdown?.includeErrors ?? true,
+          scenarioHeadingLevel: options.astro?.markdown?.scenarioHeadingLevel ?? 3,
+          groupBy: options.astro?.markdown?.groupBy ?? "file",
+          sortScenarios: options.astro?.markdown?.sortScenarios ?? "source",
+          suiteSeparator: options.astro?.markdown?.suiteSeparator ?? " - ",
+          includeSourceLinks: options.astro?.markdown?.includeSourceLinks ?? true,
+          permalinkBaseUrl: options.astro?.markdown?.permalinkBaseUrl,
+          ticketUrlTemplate: options.astro?.markdown?.ticketUrlTemplate,
+          traceUrlTemplate: options.astro?.markdown?.traceUrlTemplate,
+          customRenderers: options.astro?.markdown?.customRenderers
+        }
+      },
       assetMode: options.assetMode ?? "none",
       allowMissingAssets: options.allowMissingAssets ?? false
     };
@@ -18171,6 +18392,24 @@ var ReportGenerator = class {
           });
         }
       }
+      const astroPaths = results.get("astro");
+      if (astroPaths) {
+        for (const mdPath of astroPaths) {
+          const content = await fsPromises.readFile(mdPath, "utf8");
+          const mdDir = path7.dirname(mdPath);
+          const assetsDir = path7.resolve(this.options.astro.assetsDir);
+          const result = copyMarkdownAssets({
+            markdown: content,
+            markdownDir: mdDir,
+            assetsDir,
+            assetsBaseUrl: this.options.astro.assetsBaseUrl,
+            allowMissing: this.options.allowMissingAssets
+          });
+          if (result.copiedCount > 0 || result.missingCount > 0) {
+            await this.deps.writeFile(mdPath, result.markdown);
+          }
+        }
+      }
     }
     return results;
   }
@@ -18189,9 +18428,9 @@ var ReportGenerator = class {
     if (groups.size === 0 && this.options.output.mode === "aggregated") {
       const ext = FORMAT_EXTENSIONS[format];
       const effectiveName = this.options.outputName + (outputNameSuffix ?? "");
-      const outputPath = toPosix(path6.join(this.options.outputDir, `${effectiveName}${ext}`));
+      const outputPath = toPosix(path7.join(this.options.outputDir, `${effectiveName}${ext}`));
       const content = await this.formatContent(run, format);
-      const dir = path6.dirname(outputPath);
+      const dir = path7.dirname(outputPath);
       await fsPromises.mkdir(dir, { recursive: true });
       await this.deps.writeFile(outputPath, content);
       return [outputPath];
@@ -18203,7 +18442,7 @@ var ReportGenerator = class {
         testCases
       };
       const content = await this.formatContent(groupRun, format);
-      const dir = path6.dirname(outputPath);
+      const dir = path7.dirname(outputPath);
       await fsPromises.mkdir(dir, { recursive: true });
       await this.deps.writeFile(outputPath, content);
       writtenPaths.push(outputPath);
@@ -18266,6 +18505,13 @@ var ReportGenerator = class {
         });
         return formatter.formatToString(run);
       }
+      case "astro": {
+        const formatter = new AstroFormatter({
+          assetsBaseUrl: this.options.astro.assetsBaseUrl,
+          markdown: this.options.astro.markdown
+        });
+        return formatter.format(run);
+      }
       case "markdown": {
         const formatter = new MarkdownFormatter({
           title: this.options.markdown.title,
@@ -18303,7 +18549,7 @@ async function generateRunComparison(args) {
   await fsPromises.mkdir(outputDir, { recursive: true });
   for (const format of args.formats) {
     const ext = format === "html" ? ".html" : ".md";
-    const outputPath = toPosix(path6.join(outputDir, `${outputName}${ext}`));
+    const outputPath = toPosix(path7.join(outputDir, `${outputName}${ext}`));
     const content = format === "html" ? new RunDiffHtmlFormatter({ title: args.title }).format(diff) : new RunDiffMarkdownFormatter({ title: args.title }).format(diff);
     await fsPromises.writeFile(outputPath, content, "utf8");
     files.push(outputPath);
@@ -18323,6 +18569,7 @@ function normalizePlaywrightResults(testResults, adapterOptions, canonicalizeOpt
   return canonicalizeRun(raw, canonicalizeOptions);
 }
 export {
+  AstroFormatter,
   CucumberHtmlFormatter,
   CucumberJsonFormatter,
   CucumberMessagesFormatter,
@@ -18346,6 +18593,7 @@ export {
   canonicalizeRun,
   clearVersionCache,
   computeTestMetrics,
+  copyMarkdownAssets,
   createPrCommentSummary,
   createReportGenerator,
   deriveStepResults,
@@ -18378,6 +18626,7 @@ export {
   resolveAttachments,
   resolveTheme,
   resolveTraceUrl,
+  rewriteAssetPaths,
   saveHistory,
   sendNotifications,
   sendSlackNotification,