executable-stories-formatters 0.7.6 → 0.7.8

package/dist/cli.js

@@ -2,8 +2,8 @@
 
 // src/cli.ts
 import { parseArgs } from "util";
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs7 from "fs";
+import * as path7 from "path";
 
 // src/validation/schema-validator.ts
 import Ajv from "ajv/dist/2020.js";
@@ -492,17 +492,17 @@ function validateRawRun(data) {
     return { valid: true, errors: [] };
   }
   const errors = (validate.errors ?? []).map((err) => {
-    const path6 = err.instancePath || "/";
+    const path8 = err.instancePath || "/";
     const message = err.message ?? "unknown error";
     if (err.keyword === "additionalProperties") {
       const extra = err.params.additionalProperty;
-      return `${path6}: ${message} \u2014 '${extra}'`;
+      return `${path8}: ${message} \u2014 '${extra}'`;
     }
     if (err.keyword === "enum") {
       const allowed = err.params.allowedValues;
-      return `${path6}: ${message} \u2014 allowed: ${JSON.stringify(allowed)}`;
+      return `${path8}: ${message} \u2014 allowed: ${JSON.stringify(allowed)}`;
     }
-    return `${path6}: ${message}`;
+    return `${path8}: ${message}`;
   });
   return { valid: false, errors };
 }
@@ -966,7 +966,7 @@ ${result.errors.join("\n")}`);
 
 // src/index.ts
 import "fs";
-import * as path4 from "path";
+import * as path5 from "path";
 import * as fsPromises from "fs/promises";
 
 // src/converters/acl/lines.ts
@@ -15671,8 +15671,8 @@ function extractDocAttachments(step) {
   }
   return attachments;
 }
-function guessMediaType(path6) {
-  const lower = path6.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";
@@ -15813,11 +15813,11 @@ var CucumberHtmlFormatter = class {
     for (const envelope of envelopes) {
       const accepted = htmlStream.write(envelope);
       if (!accepted) {
-        await new Promise((resolve4) => htmlStream.once("drain", resolve4));
+        await new Promise((resolve8) => htmlStream.once("drain", resolve8));
       }
     }
-    await new Promise((resolve4, reject) => {
-      collector.on("finish", resolve4);
+    await new Promise((resolve8, reject) => {
+      collector.on("finish", resolve8);
       collector.on("error", reject);
       htmlStream.end();
     });
@@ -16849,6 +16849,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/ndjson-parser.ts
 function parseNdjson(ndjson) {
   const lines = ndjson.trim().split("\n").filter(Boolean);
@@ -17802,6 +17973,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.";
   }
@@ -17843,6 +18045,7 @@ function listScenarios(args, _deps) {
 
 // src/index.ts
 var FORMAT_EXTENSIONS = {
+  astro: ".md",
   markdown: ".md",
   html: ".html",
   "cucumber-html": ".cucumber.html",
@@ -17875,11 +18078,11 @@ function computeOutputPath(sourceFile, format, mode, colocatedStyle, baseOutputD
   const ext = FORMAT_EXTENSIONS[format];
   const effectiveName = outputName + (outputNameSuffix ?? "");
   if (mode === "aggregated") {
-    return toPosix(path4.join(baseOutputDir, `${effectiveName}${ext}`));
+    return toPosix(path5.join(baseOutputDir, `${effectiveName}${ext}`));
   }
   const normalizedSource = toPosix(sourceFile);
-  const dirOfSource = path4.posix.dirname(normalizedSource);
-  let baseName = path4.posix.basename(normalizedSource);
+  const dirOfSource = path5.posix.dirname(normalizedSource);
+  let baseName = path5.posix.basename(normalizedSource);
   for (const testExt of TEST_EXTENSIONS) {
     if (baseName.endsWith(testExt)) {
       baseName = baseName.slice(0, -testExt.length);
@@ -17888,9 +18091,9 @@ function computeOutputPath(sourceFile, format, mode, colocatedStyle, baseOutputD
   }
   const fileName = `${baseName}.${effectiveName}${ext}`;
   if (colocatedStyle === "adjacent") {
-    return toPosix(path4.posix.join(dirOfSource, fileName));
+    return toPosix(path5.posix.join(dirOfSource, fileName));
   }
-  return toPosix(path4.posix.join(baseOutputDir, dirOfSource, fileName));
+  return toPosix(path5.posix.join(baseOutputDir, dirOfSource, fileName));
 }
 function groupTestCasesByOutput(testCases, format, options, logger, outputNameSuffix) {
   const groups = /* @__PURE__ */ new Map();
@@ -18016,6 +18219,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
     };
@@ -18053,6 +18274,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 = path5.dirname(mdPath);
+          const assetsDir = path5.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;
   }
@@ -18071,9 +18310,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(path4.join(this.options.outputDir, `${effectiveName}${ext}`));
+      const outputPath = toPosix(path5.join(this.options.outputDir, `${effectiveName}${ext}`));
       const content = await this.formatContent(run, format);
-      const dir = path4.dirname(outputPath);
+      const dir = path5.dirname(outputPath);
       await fsPromises.mkdir(dir, { recursive: true });
       await this.deps.writeFile(outputPath, content);
       return [outputPath];
@@ -18085,7 +18324,7 @@ var ReportGenerator = class {
         testCases
       };
       const content = await this.formatContent(groupRun, format);
-      const dir = path4.dirname(outputPath);
+      const dir = path5.dirname(outputPath);
       await fsPromises.mkdir(dir, { recursive: true });
       await this.deps.writeFile(outputPath, content);
       writtenPaths.push(outputPath);
@@ -18148,6 +18387,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,
@@ -18182,7 +18428,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(path4.join(outputDir, `${outputName}${ext}`));
+    const outputPath = toPosix(path5.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);
@@ -18190,6 +18436,61 @@ async function generateRunComparison(args) {
   return { files, diff };
 }
 
+// src/init-astro.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+import { fileURLToPath } from "url";
+var __dirname = path6.dirname(fileURLToPath(import.meta.url));
+function initAstro(options = {}) {
+  const targetDir = options.targetDir ?? "./story-docs";
+  const force = options.force ?? false;
+  if (fs6.existsSync(targetDir)) {
+    const entries = fs6.readdirSync(targetDir);
+    if (entries.length > 0 && !force) {
+      throw new Error(
+        `Directory "${targetDir}" already exists and is not empty. Use --force to overwrite.`
+      );
+    }
+  }
+  const templateDir = path6.resolve(__dirname, "..", "templates", "astro-starlight");
+  if (!fs6.existsSync(templateDir)) {
+    throw new Error(
+      `Template directory not found at ${templateDir}. Ensure the package is installed correctly.`
+    );
+  }
+  copyDirRecursive(templateDir, targetDir);
+  return { targetDir };
+}
+function copyDirRecursive(src, dest) {
+  fs6.mkdirSync(dest, { recursive: true });
+  const entries = fs6.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path6.join(src, entry.name);
+    const destPath = path6.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs6.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+// src/config.ts
+import { existsSync as existsSync6 } from "fs";
+import { resolve as resolve6 } from "path";
+async function loadConfig(configPath) {
+  const resolved = configPath ? resolve6(configPath) : resolve6(process.cwd(), "executable-stories.config.js");
+  if (!existsSync6(resolved)) return {};
+  const mod = await import(resolved);
+  const config = mod.default;
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw new Error(
+      `Config file at ${resolved} must export a default object. Got: ${typeof config}`
+    );
+  }
+  return config;
+}
+
 // src/cli.ts
 var EXIT_SUCCESS = 0;
 var EXIT_SCHEMA_VALIDATION = 1;
@@ -18206,21 +18507,25 @@ USAGE
   executable-stories list <file> [options]
   executable-stories validate <file>
   executable-stories validate --stdin
+  executable-stories init-astro [directory]
 
 SUBCOMMANDS
   format     Read raw test results and generate reports
   compare    Compare two runs and generate a diff report
   list       List scenarios from a test run (text table or JSON)
   validate   Validate a JSON file against the schema (no output generated)
+  init-astro Scaffold an Astro Starlight docs site for story output
 
 OPTIONS
-  --format <formats>            Comma-separated formats (default: html)
+  --format <formats>            Comma-separated formats: html, markdown, junit, cucumber-json, cucumber-messages, cucumber-html, astro, or custom names from config (default: html)
+                                  astro             Starlight-compatible Markdown (for Astro docs sites)
                                   html              Custom HTML report (accessible, dark mode, mermaid)
                                   cucumber-html     Official Cucumber HTML report
                                   markdown          Markdown documentation
                                   junit             JUnit XML
                                   cucumber-json     Cucumber JSON
                                   cucumber-messages Raw NDJSON (Cucumber Messages)
+  --config <path>               Path to executable-stories.config.js (default: ./executable-stories.config.js)
   --input-type <type>           Input type: raw, canonical, or ndjson (default: raw)
   --output-dir <dir>            Output directory (default: reports)
   --output-name <name>          Base filename (default: index)
@@ -18244,7 +18549,8 @@ OPTIONS
   --asset-mode <mode>         Asset bundling: "none" (default) or "copy"
   --allow-missing-assets      Warn on missing assets instead of failing
   --stdin                       Read JSON from stdin instead of file
-  --json-summary                Print machine-parsable JSON summary
+  --list-format <format>        list output format: text (default), json, csv, markdown-table
+  --json-summary                Deprecated alias for --list-format json
   --baseline <path|auto>        Compare baseline file, or auto-pick a prior run for compare
   --baseline-dir <dir>          Directory to scan when --baseline auto is used
   --pr-summary                  Print a PR-friendly markdown summary after compare
@@ -18253,7 +18559,8 @@ OPTIONS
   --help                        Show this help message
 
 LIST
-  list prints one scenario per line (text by default, JSON with --json-summary)
+  list prints one scenario per line (--list-format text by default)
+  list --list-format json outputs machine-parsable JSON (--json-summary is a deprecated alias)
   list supports --include-tags, --exclude-tags for filtering
   list supports --input-type and --stdin
 
@@ -18261,6 +18568,10 @@ COMPARE
   compare supports --format html,markdown
   compare uses the same --input-type for both baseline and current files
 
+INIT-ASTRO
+  executable-stories init-astro [directory]   Scaffold into directory (default: ./story-docs)
+  --force                                      Overwrite existing directory
+
 NOTIFICATIONS
   --slack-webhook <url>         Slack incoming webhook URL (fallback: SLACK_WEBHOOK_URL env var)
   --teams-webhook <url>         Teams incoming webhook URL (fallback: TEAMS_WEBHOOK_URL env var)
@@ -18288,17 +18599,38 @@ EXIT CODES
   3  Formatter/generation failure
   4  Bad arguments / usage error
 `.trim();
-function parseCliArgs(argv) {
+async function parseCliArgs(argv) {
   const args = argv.slice(2);
   if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
     console.log(HELP_TEXT);
     process.exit(EXIT_SUCCESS);
   }
   const subcommand = args[0];
-  if (subcommand !== "format" && subcommand !== "compare" && subcommand !== "list" && subcommand !== "validate") {
-    console.error(`Unknown subcommand: "${subcommand}". Use "format", "compare", "list", or "validate".`);
+  if (subcommand !== "format" && subcommand !== "compare" && subcommand !== "list" && subcommand !== "validate" && subcommand !== "init-astro") {
+    console.error(`Unknown subcommand: "${subcommand}". Use "format", "compare", "list", "validate", or "init-astro".`);
     process.exit(EXIT_USAGE);
   }
+  if (subcommand === "init-astro") {
+    const initArgs = args.slice(1);
+    const targetDir = initArgs.find((a) => !a.startsWith("--")) ?? "./story-docs";
+    const force = initArgs.includes("--force");
+    try {
+      const result = initAstro({ targetDir, force });
+      console.log(`Scaffolded Astro Starlight project at ${result.targetDir}`);
+      console.log("");
+      console.log("Next steps:");
+      console.log(`  cd ${result.targetDir}`);
+      console.log("  pnpm install    # or npm install");
+      console.log("  pnpm dev        # start the dev server");
+      console.log("");
+      console.log("Generate story docs with:");
+      console.log(`  executable-stories format run.json --format astro --output-dir ${result.targetDir}/src/content/docs/stories --asset-mode copy`);
+      process.exit(EXIT_SUCCESS);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(EXIT_USAGE);
+    }
+  }
   const { values, positionals } = parseArgs({
     args: args.slice(1),
     options: {
@@ -18327,6 +18659,7 @@ function parseCliArgs(argv) {
       "html-theme-picker": { type: "boolean", default: false },
       stdin: { type: "boolean", default: false },
       "json-summary": { type: "boolean", default: false },
+      "list-format": { type: "string", default: "text" },
       "emit-canonical": { type: "string" },
       "slack-webhook": { type: "string" },
       "teams-webhook": { type: "string" },
@@ -18345,6 +18678,7 @@ function parseCliArgs(argv) {
       "allow-missing-assets": { type: "boolean", default: false },
       "pr-summary": { type: "boolean", default: false },
       "pr-summary-file": { type: "string" },
+      "config": { type: "string" },
       help: { type: "boolean", default: false }
     },
     allowPositionals: true,
@@ -18382,15 +18716,20 @@ function parseCliArgs(argv) {
     console.error(`Error: --input-type must be "raw", "canonical", or "ndjson", got "${inputType}".`);
     process.exit(EXIT_USAGE);
   }
-  const validFormats = /* @__PURE__ */ new Set(["html", "markdown", "junit", "cucumber-json", "cucumber-messages", "cucumber-html"]);
+  const pluginConfig = await loadConfig(values["config"]);
+  const customFormatterNames = new Set(Object.keys(pluginConfig.formatters ?? {}));
+  const builtInFormats = /* @__PURE__ */ new Set(["astro", "html", "markdown", "junit", "cucumber-json", "cucumber-messages", "cucumber-html"]);
   const formatStr = values.format;
-  const formats = formatStr.split(",").map((f) => f.trim());
-  for (const f of formats) {
-    if (!validFormats.has(f)) {
-      console.error(`Error: Unknown format "${f}". Valid: html, markdown, junit, cucumber-json, cucumber-messages, cucumber-html.`);
-      process.exit(EXIT_USAGE);
-    }
+  const allRequestedFormats = formatStr.split(",").map((f) => f.trim());
+  const builtInRequested = allRequestedFormats.filter((f) => builtInFormats.has(f));
+  const customRequested = allRequestedFormats.filter((f) => customFormatterNames.has(f));
+  const unknownFormats = allRequestedFormats.filter((f) => !builtInFormats.has(f) && !customFormatterNames.has(f));
+  if (unknownFormats.length > 0) {
+    const knownCustom = customFormatterNames.size > 0 ? `, ${[...customFormatterNames].join(", ")}` : "";
+    console.error(`Error: Unknown format(s): ${unknownFormats.join(", ")}. Valid built-in: astro, html, markdown, junit, cucumber-json, cucumber-messages, cucumber-html${knownCustom}.`);
+    process.exit(EXIT_USAGE);
   }
+  const formats = builtInRequested;
   const htmlTheme = values["html-theme"];
   const validThemes = /* @__PURE__ */ new Set(["default", "corporate", "terminal", "minimal", "dashboard", "playful"]);
   if (!validThemes.has(htmlTheme)) {
@@ -18458,7 +18797,7 @@ function parseCliArgs(argv) {
     console.error(`Error: --asset-mode must be "none" or "copy", got "${assetModeRaw}".`);
     process.exit(EXIT_USAGE);
   }
-  return {
+  const cliArgs = {
     subcommand,
     inputFile,
     baselineFile,
@@ -18487,6 +18826,7 @@ function parseCliArgs(argv) {
     htmlNoToc: values["html-no-toc"],
     htmlThemePicker: values["html-theme-picker"],
     jsonSummary: values["json-summary"],
+    listFormat: values["list-format"],
     emitCanonical: values["emit-canonical"],
     slackWebhook,
     teamsWebhook,
@@ -18504,34 +18844,36 @@ function parseCliArgs(argv) {
     assetMode: assetModeRaw,
     allowMissingAssets: values["allow-missing-assets"],
     prSummary: values["pr-summary"],
-    prSummaryFile: values["pr-summary-file"]
+    prSummaryFile: values["pr-summary-file"],
+    config: values["config"]
   };
+  return { args: cliArgs, pluginConfig, customRequested };
 }
 async function readInput(args) {
   if (args.stdin) {
     return readStdin();
   }
-  const filePath = path5.resolve(args.inputFile);
-  if (!fs5.existsSync(filePath)) {
+  const filePath = path7.resolve(args.inputFile);
+  if (!fs7.existsSync(filePath)) {
     console.error(`Error: File not found: ${filePath}`);
     process.exit(EXIT_USAGE);
   }
-  return fs5.readFileSync(filePath, "utf8");
+  return fs7.readFileSync(filePath, "utf8");
 }
 function readFileInput(filePath) {
-  const resolved = path5.resolve(filePath);
-  if (!fs5.existsSync(resolved)) {
+  const resolved = path7.resolve(filePath);
+  if (!fs7.existsSync(resolved)) {
     console.error(`Error: File not found: ${resolved}`);
     process.exit(EXIT_USAGE);
   }
-  return fs5.readFileSync(resolved, "utf8");
+  return fs7.readFileSync(resolved, "utf8");
 }
 function readStdin() {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve8, reject) => {
     const chunks = [];
     process.stdin.setEncoding("utf8");
     process.stdin.on("data", (chunk) => chunks.push(chunk));
-    process.stdin.on("end", () => resolve4(chunks.join("")));
+    process.stdin.on("end", () => resolve8(chunks.join("")));
     process.stdin.on("error", reject);
   });
 }
@@ -18657,14 +18999,14 @@ function tryNormalizeRunFromText(text, args) {
   }
 }
 function listBaselineCandidates(currentFile, args) {
-  const baselineDir = path5.resolve(args.baselineDir ?? path5.dirname(currentFile));
-  const currentResolved = path5.resolve(currentFile);
-  if (!fs5.existsSync(baselineDir)) {
+  const baselineDir = path7.resolve(args.baselineDir ?? path7.dirname(currentFile));
+  const currentResolved = path7.resolve(currentFile);
+  if (!fs7.existsSync(baselineDir)) {
     console.error(`Error: baseline directory not found: ${baselineDir}`);
     process.exit(EXIT_USAGE);
   }
-  const entries = fs5.readdirSync(baselineDir, { withFileTypes: true });
-  return entries.filter((entry) => entry.isFile()).map((entry) => path5.join(baselineDir, entry.name)).filter((candidate) => path5.resolve(candidate) !== currentResolved).filter(
+  const entries = fs7.readdirSync(baselineDir, { withFileTypes: true });
+  return entries.filter((entry) => entry.isFile()).map((entry) => path7.join(baselineDir, entry.name)).filter((candidate) => path7.resolve(candidate) !== currentResolved).filter(
     (candidate) => args.inputType === "ndjson" ? candidate.endsWith(".ndjson") : candidate.endsWith(".json")
   );
 }
@@ -18672,14 +19014,14 @@ function resolveBaselineAuto(currentFile, currentRun, args) {
   const candidates = listBaselineCandidates(currentFile, args);
   const comparable = [];
   for (const candidate of candidates) {
-    const run = tryNormalizeRunFromText(fs5.readFileSync(candidate, "utf8"), args);
+    const run = tryNormalizeRunFromText(fs7.readFileSync(candidate, "utf8"), args);
     if (run) {
       comparable.push({ file: candidate, run });
     }
   }
   if (comparable.length === 0) {
     console.error(
-      `Error: no compatible baseline files found in ${path5.resolve(args.baselineDir ?? path5.dirname(currentFile))}.`
+      `Error: no compatible baseline files found in ${path7.resolve(args.baselineDir ?? path7.dirname(currentFile))}.`
     );
     process.exit(EXIT_USAGE);
   }
@@ -18691,7 +19033,7 @@ function resolveBaselineAuto(currentFile, currentRun, args) {
   return picked.file;
 }
 async function main() {
-  const args = parseCliArgs(process.argv);
+  const { args, pluginConfig, customRequested } = await parseCliArgs(process.argv);
   const startMs = Date.now();
   if (args.subcommand === "compare") {
     const currentText = readFileInput(args.currentFile);
@@ -18712,8 +19054,16 @@ async function main() {
   if (args.subcommand === "list") {
     const text2 = await readInput(args);
     const run = applySelection(normalizeRunFromText(text2, args).run, args);
-    const outputFormat = args.jsonSummary ? "json" : "text";
-    const output = listScenarios({ testCases: run.testCases, format: outputFormat }, {});
+    const resolvedFormat = args.jsonSummary ? "json" : args.listFormat;
+    const validListFormats = /* @__PURE__ */ new Set(["text", "json", "csv", "markdown-table"]);
+    if (!validListFormats.has(resolvedFormat)) {
+      console.error(`Error: Unknown list format "${resolvedFormat}". Valid: text, json, csv, markdown-table.`);
+      process.exit(EXIT_USAGE);
+    }
+    const output = listScenarios(
+      { testCases: run.testCases, format: resolvedFormat },
+      {}
+    );
     console.log(output);
     process.exit(EXIT_SUCCESS);
   }
@@ -18760,12 +19110,13 @@ async function main() {
       process.exit(EXIT_SCHEMA_VALIDATION);
     }
     if (args.emitCanonical) {
-      const outPath = path5.resolve(args.emitCanonical);
-      fs5.mkdirSync(path5.dirname(outPath), { recursive: true });
-      fs5.writeFileSync(outPath, JSON.stringify(run, null, 2), "utf8");
+      const outPath = path7.resolve(args.emitCanonical);
+      fs7.mkdirSync(path7.dirname(outPath), { recursive: true });
+      fs7.writeFileSync(outPath, JSON.stringify(run, null, 2), "utf8");
     }
     try {
       const result = await generateReports(run, args);
+      runCustomFormatters(run, customRequested, pluginConfig.formatters ?? {}, args);
       await dispatchNotifications(run, args);
       runHistoryPipeline(run, args);
       printResult(result, args, startMs);
@@ -18818,12 +19169,13 @@ ${msg}`);
     }
     const run = data;
     if (args.emitCanonical) {
-      const outPath = path5.resolve(args.emitCanonical);
-      fs5.mkdirSync(path5.dirname(outPath), { recursive: true });
-      fs5.writeFileSync(outPath, JSON.stringify(run, null, 2), "utf8");
+      const outPath = path7.resolve(args.emitCanonical);
+      fs7.mkdirSync(path7.dirname(outPath), { recursive: true });
+      fs7.writeFileSync(outPath, JSON.stringify(run, null, 2), "utf8");
     }
     try {
       const result = await generateReports(run, args);
+      runCustomFormatters(run, customRequested, pluginConfig.formatters ?? {}, args);
       await dispatchNotifications(run, args);
       runHistoryPipeline(run, args);
       printResult(result, args, startMs);
@@ -18875,12 +19227,13 @@ ${msg}`);
     process.exit(EXIT_CANONICAL_VALIDATION);
   }
   if (args.emitCanonical) {
-    const outPath = path5.resolve(args.emitCanonical);
-    fs5.mkdirSync(path5.dirname(outPath), { recursive: true });
-    fs5.writeFileSync(outPath, JSON.stringify(canonical, null, 2), "utf8");
+    const outPath = path7.resolve(args.emitCanonical);
+    fs7.mkdirSync(path7.dirname(outPath), { recursive: true });
+    fs7.writeFileSync(outPath, JSON.stringify(canonical, null, 2), "utf8");
   }
   try {
     const result = await generateReports(canonical, args, droppedMissingStory);
+    runCustomFormatters(canonical, customRequested, pluginConfig.formatters ?? {}, args);
     await dispatchNotifications(canonical, args);
     runHistoryPipeline(canonical, args);
     printResult(result, args, startMs, droppedMissingStory);
@@ -18891,6 +19244,25 @@ ${msg}`);
     process.exit(EXIT_GENERATION);
   }
 }
+function runCustomFormatters(run, customRequested, formatters, args) {
+  if (customRequested.length === 0) return;
+  const outputDir = args.outputDir ?? ".";
+  for (const formatName of customRequested) {
+    const formatter = formatters[formatName];
+    try {
+      const content = formatter.format(run);
+      const ext = formatter.fileExtension ?? formatName;
+      const baseName = args.outputName ?? "report";
+      const filename = args.outputNameTimestamp ? `${baseName}-${Math.floor(run.startedAtMs / 1e3)}.${ext}` : `${baseName}.${ext}`;
+      const filepath = path7.join(outputDir, filename);
+      fs7.mkdirSync(outputDir, { recursive: true });
+      fs7.writeFileSync(filepath, content, "utf8");
+      console.log(`Generated: ${filepath}`);
+    } catch (err) {
+      console.error(`Error running custom formatter "${formatName}": ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+}
 async function dispatchNotifications(run, args) {
   const webhooks = args.webhookUrls.map((url) => {
     const opts = { url };
@@ -18934,13 +19306,13 @@ async function dispatchNotifications(run, args) {
 }
 function runHistoryPipeline(run, args) {
   if (!args.historyFile) return;
-  const historyPath = path5.resolve(args.historyFile);
+  const historyPath = path7.resolve(args.historyFile);
   const store = loadHistory(
     { filePath: historyPath },
     {
       readFile: (p) => {
         try {
-          return fs5.readFileSync(p, "utf8");
+          return fs7.readFileSync(p, "utf8");
         } catch {
           return void 0;
         }
@@ -18953,11 +19325,11 @@ function runHistoryPipeline(run, args) {
     run,
     maxRuns: args.maxHistoryRuns
   });
-  const dir = path5.dirname(historyPath);
-  fs5.mkdirSync(dir, { recursive: true });
+  const dir = path7.dirname(historyPath);
+  fs7.mkdirSync(dir, { recursive: true });
   saveHistory(
     { filePath: historyPath, store: updated },
-    { writeFile: (p, content) => fs5.writeFileSync(p, content, "utf8") }
+    { writeFile: (p, content) => fs7.writeFileSync(p, content, "utf8") }
   );
   let metricsCount = 0;
   for (const testId of Object.keys(updated.tests)) {
@@ -19055,9 +19427,9 @@ function printResult(result, args, startMs, droppedMissingStory = 0) {
 function printCompareResult(result, args, startMs) {
   const durationMs = Date.now() - startMs;
   if (result.prSummary && args.prSummaryFile) {
-    const outputPath = path5.resolve(args.prSummaryFile);
-    fs5.mkdirSync(path5.dirname(outputPath), { recursive: true });
-    fs5.writeFileSync(outputPath, result.prSummary, "utf8");
+    const outputPath = path7.resolve(args.prSummaryFile);
+    fs7.mkdirSync(path7.dirname(outputPath), { recursive: true });
+    fs7.writeFileSync(outputPath, result.prSummary, "utf8");
   }
   if (args.jsonSummary) {
     console.log(