executable-stories-formatters 0.11.0 → 0.11.1

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
 import "fs";
-import * as path10 from "path";
+import * as path11 from "path";
 import * as fsPromises from "fs/promises";
 
 // src/converters/acl/status.ts
@@ -889,23 +889,23 @@ function buildFeature(relSourceFile, group) {
 function ensureUniqueFeatureIds(features) {
   const seen = /* @__PURE__ */ new Map();
   for (const f of features) {
-    const count = seen.get(f.id) ?? 0;
-    if (count > 0) f.id = `${f.id}-${count + 1}`;
-    seen.set(f.id, count + 1);
+    const count2 = seen.get(f.id) ?? 0;
+    if (count2 > 0) f.id = `${f.id}-${count2 + 1}`;
+    seen.set(f.id, count2 + 1);
   }
 }
 function ensureUniqueScenarioIds(feature) {
   const seen = /* @__PURE__ */ new Map();
   for (const s of feature.scenarios) {
-    const count = seen.get(s.id) ?? 0;
-    if (count > 0) {
-      const newId = `${s.id}-${count + 1}`;
+    const count2 = seen.get(s.id) ?? 0;
+    if (count2 > 0) {
+      const newId = `${s.id}-${count2 + 1}`;
       for (const step of s.steps) {
         step.id = step.id.replace(s.id, newId);
       }
       s.id = newId;
     }
-    seen.set(s.id, count + 1);
+    seen.set(s.id, count2 + 1);
   }
 }
 function toStoryReport(run) {
@@ -15437,6 +15437,88 @@ function groupBy6(items, keyFn) {
   return map;
 }
 
+// src/formatters/release-manifest.ts
+import { createHash as createHash2 } from "crypto";
+var ReleaseManifestFormatter = class {
+  format(run) {
+    const manifest = toReleaseManifest(run);
+    const lines = [];
+    lines.push("# Release Manifest");
+    lines.push("");
+    lines.push(`Generated: ${manifest.generatedAt}`);
+    lines.push(`Run: ${manifest.run.startedAt} to ${manifest.run.finishedAt}`);
+    if (manifest.run.branch) lines.push(`Branch: ${manifest.run.branch}`);
+    if (manifest.run.gitSha) lines.push(`Commit: ${manifest.run.gitSha}`);
+    lines.push(`Tested-together hash: \`${manifest.testedTogetherHash}\``);
+    lines.push("");
+    lines.push("| Scenarios | Passed | Failed | Skipped | Pending |");
+    lines.push("| ---: | ---: | ---: | ---: | ---: |");
+    lines.push(`| ${manifest.run.total} | ${manifest.run.passed} | ${manifest.run.failed} | ${manifest.run.skipped} | ${manifest.run.pending} |`);
+    lines.push("");
+    lines.push("## Scenarios");
+    lines.push("");
+    lines.push("| Status | Scenario | Source | Tags |");
+    lines.push("| --- | --- | --- | --- |");
+    for (const scenario of manifest.scenarios) {
+      const source = `${scenario.sourceFile}:${scenario.sourceLine}`;
+      const tags = scenario.tags.length > 0 ? scenario.tags.map((tag) => `\`${tag}\``).join(", ") : "";
+      lines.push(`| ${renderStatus(scenario.status)} | ${escapePipe(scenario.title)} | \`${source}\` | ${tags} |`);
+    }
+    return lines.join("\n");
+  }
+};
+function toReleaseManifest(run) {
+  const scenarios = [...run.testCases].sort((a, b) => a.id.localeCompare(b.id)).map((tc) => ({
+    id: tc.id,
+    title: tc.story.scenario,
+    status: tc.status,
+    sourceFile: tc.sourceFile,
+    sourceLine: tc.sourceLine,
+    tags: tc.tags
+  }));
+  const fingerprint = scenarios.map((scenario) => `${scenario.id}:${scenario.status}`).join("\n");
+  return {
+    schemaVersion: "1.0",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    run: {
+      startedAt: new Date(run.startedAtMs).toISOString(),
+      finishedAt: new Date(run.finishedAtMs).toISOString(),
+      gitSha: run.gitSha,
+      branch: getBranch(run),
+      total: run.testCases.length,
+      passed: count(run.testCases, "passed"),
+      failed: count(run.testCases, "failed"),
+      skipped: count(run.testCases, "skipped"),
+      pending: count(run.testCases, "pending")
+    },
+    testedTogetherHash: createHash2("sha256").update(fingerprint).digest("hex"),
+    scenarios
+  };
+}
+function getBranch(run) {
+  return run.ci?.branch;
+}
+function count(testCases, status) {
+  return testCases.filter((tc) => tc.status === status).length;
+}
+function renderStatus(status) {
+  switch (status) {
+    case "passed":
+      return "passed";
+    case "failed":
+      return "failed";
+    case "skipped":
+      return "skipped";
+    case "pending":
+      return "pending";
+    default:
+      return status;
+  }
+}
+function escapePipe(value) {
+  return value.replace(/\|/g, "\\|");
+}
+
 // src/formatters/cucumber-messages/synthesize-feature.ts
 function extractFeatureName(testCases, uri) {
   for (const tc of testCases) {
@@ -15503,7 +15585,7 @@ function synthesizeFeature(uri, testCases) {
 }
 
 // src/utils/cucumber-messages.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 function msToTimestamp(ms) {
   const seconds = Math.floor(ms / 1e3);
   const nanos = Math.round(ms % 1e3 * 1e6);
@@ -15569,7 +15651,7 @@ function statusToCucumberStatus(status) {
 }
 function deterministicId(kind, salt, ...parts) {
   const input = [salt, kind, ...parts].join("::");
-  return createHash2("sha1").update(input).digest("hex").slice(0, 36);
+  return createHash3("sha1").update(input).digest("hex").slice(0, 36);
 }
 
 // src/formatters/cucumber-messages/build-gherkin-document.ts
@@ -16057,8 +16139,8 @@ function extractDocAttachments(step) {
   }
   return attachments;
 }
-function guessMediaType(path11) {
-  const lower = path11.toLowerCase();
+function guessMediaType(path12) {
+  const lower = path12.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";
@@ -16199,11 +16281,11 @@ var CucumberHtmlFormatter = class {
     for (const envelope of envelopes) {
       const accepted = htmlStream.write(envelope);
       if (!accepted) {
-        await new Promise((resolve8) => htmlStream.once("drain", resolve8));
+        await new Promise((resolve9) => htmlStream.once("drain", resolve9));
       }
     }
-    await new Promise((resolve8, reject) => {
-      collector.on("finish", resolve8);
+    await new Promise((resolve9, reject) => {
+      collector.on("finish", resolve9);
       collector.on("error", reject);
       htmlStream.end();
     });
@@ -17267,8 +17349,8 @@ ${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 count2 = run.testCases.length;
+    const description = `${count2} scenario${count2 !== 1 ? "s" : ""} \u2014 ${badge.text.toLowerCase()}`;
     const lines = [
       "---",
       `title: ${yamlScalar(this.deriveTitle(run))}`,
@@ -18266,14 +18348,14 @@ ${result.errors.join("\n")}`);
 }
 
 // src/coverage-index.ts
-function normalizePath(path11) {
-  return path11.replace(/^\.\//, "");
+function normalizePath(path12) {
+  return path12.replace(/^\.\//, "");
 }
 function scenariosCoveringPaths(index, paths) {
   const queries = paths.map(normalizePath);
   return index.scenarios.filter(
     (scenario) => scenario.covers.some(
-      (glob) => queries.some((path11) => matchesPattern(normalizePath(glob), path11))
+      (glob) => queries.some((path12) => matchesPattern(normalizePath(glob), path12))
     )
   );
 }
@@ -20190,18 +20272,18 @@ function deriveChangeType(tags) {
   }
   return "unknown";
 }
-function extensionOf(path11) {
-  const base = path11.split("/").pop() ?? path11;
+function extensionOf(path12) {
+  const base = path12.split("/").pop() ?? path12;
   const dot = base.lastIndexOf(".");
   return dot === -1 ? "" : base.slice(dot + 1).toLowerCase();
 }
-function isTestFile(path11) {
-  return TEST_INFIX.test(path11);
+function isTestFile(path12) {
+  return TEST_INFIX.test(path12);
 }
-function isReviewableSource(path11) {
-  if (isTestFile(path11)) return false;
-  if (path11.endsWith(".d.ts")) return false;
-  return CODE_EXTENSIONS.has(extensionOf(path11));
+function isReviewableSource(path12) {
+  if (isTestFile(path12)) return false;
+  if (path12.endsWith(".d.ts")) return false;
+  return CODE_EXTENSIONS.has(extensionOf(path12));
 }
 function testBaseKey(testFile) {
   return testFile.replace(TEST_INFIX, "");
@@ -20305,7 +20387,7 @@ function toClaim(testCase, changedSourcePaths) {
   const { strength, reasons } = gradeEvidence(testCase, audience);
   const key = testBaseKey(testCase.sourceFile);
   const coversFiles = changedSourcePaths.filter(
-    (path11) => sourceBaseKey(path11) === key
+    (path12) => sourceBaseKey(path12) === key
   );
   return {
     id: testCase.id,
@@ -20835,11 +20917,116 @@ applyTheme(getEffectiveTheme());` : "";
   }
 };
 
+// src/deploy/ledger.ts
+import * as fs9 from "fs";
+import * as path10 from "path";
+function createEmptyLedger() {
+  return {
+    deployments: [],
+    schemaVersion: 1
+  };
+}
+function loadLedger(ledgerPath) {
+  const resolved = path10.resolve(ledgerPath);
+  if (!fs9.existsSync(resolved)) {
+    return createEmptyLedger();
+  }
+  try {
+    const raw = JSON.parse(fs9.readFileSync(resolved, "utf8"));
+    if (raw.schemaVersion !== 1) {
+      throw new Error(`Unsupported ledger schemaVersion: ${raw.schemaVersion}`);
+    }
+    return raw;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to load deployment ledger at ${resolved}: ${msg}`);
+  }
+}
+function saveLedger(ledger, ledgerPath) {
+  const resolved = path10.resolve(ledgerPath);
+  const dir = path10.dirname(resolved);
+  fs9.mkdirSync(dir, { recursive: true });
+  fs9.writeFileSync(resolved, JSON.stringify(ledger, null, 2), "utf8");
+}
+function getLatestDeployment(ledger, environment) {
+  return [...ledger.deployments].reverse().find((d) => d.environment === environment);
+}
+
+// src/deploy/index.ts
+function recordDeployment(args) {
+  const ledger = loadLedger(args.ledgerPath);
+  const previous = getLatestDeployment(ledger, args.environment);
+  const entry = {
+    environment: args.environment,
+    tag: args.tag,
+    sha: args.run.gitSha,
+    runFile: args.runFilePath,
+    scenarioIds: args.run.testCases.map((tc) => tc.id),
+    scenarioStatuses: Object.fromEntries(args.run.testCases.map((tc) => [tc.id, tc.status])),
+    timestamp: new Date(args.run.finishedAtMs).toISOString(),
+    summary: countStatuses(args.run)
+  };
+  ledger.deployments.push(entry);
+  if (previous) {
+    const previousIds = new Set(previous.scenarioIds);
+    const added = entry.scenarioIds.filter((id) => !previousIds.has(id)).length;
+    const removed = previous.scenarioIds.filter((id) => !entry.scenarioIds.includes(id)).length;
+    if (added > 0 || removed > 0) {
+    }
+  }
+  saveLedger(ledger, args.ledgerPath);
+  return { entry, ledgerPath: args.ledgerPath };
+}
+function getDeploymentStatus(ledgerPath) {
+  const ledger = loadLedger(ledgerPath);
+  const environments = {};
+  for (const entry of ledger.deployments) {
+    environments[entry.environment] = {
+      latest: entry,
+      previousDeployment: environments[entry.environment]?.latest
+    };
+  }
+  return { environments, ledgerPath };
+}
+function getEnvironmentDrift(ledgerPath, envA, envB) {
+  const ledger = loadLedger(ledgerPath);
+  const aEntry = getLatestDeployment(ledger, envA);
+  const bEntry = getLatestDeployment(ledger, envB);
+  if (!aEntry) {
+    throw new Error(`No deployment found for environment "${envA}"`);
+  }
+  if (!bEntry) {
+    throw new Error(`No deployment found for environment "${envB}"`);
+  }
+  const aIds = new Set(aEntry.scenarioIds);
+  const bIds = new Set(bEntry.scenarioIds);
+  const onlyInA = aEntry.scenarioIds.filter((id) => !bIds.has(id));
+  const onlyInB = bEntry.scenarioIds.filter((id) => !aIds.has(id));
+  const inBoth = aEntry.scenarioIds.filter((id) => bIds.has(id));
+  const statusChanged = inBoth.map((id) => ({
+    id,
+    statusA: aEntry.scenarioStatuses?.[id] ?? "unknown",
+    statusB: bEntry.scenarioStatuses?.[id] ?? "unknown"
+  })).filter((item) => item.statusA !== item.statusB);
+  return { environmentA: envA, environmentB: envB, onlyInA, onlyInB, inBoth, statusChanged, aEntry, bEntry };
+}
+function countStatuses(run) {
+  const summary = { total: 0, passed: 0, failed: 0, skipped: 0, pending: 0 };
+  for (const tc of run.testCases) {
+    summary.total++;
+    if (tc.status in summary) {
+      summary[tc.status]++;
+    }
+  }
+  return summary;
+}
+
 // src/index.ts
 var FORMAT_EXTENSIONS = {
   astro: ".md",
   "behavior-manifest-json": ".behavior-manifest.json",
   markdown: ".md",
+  "release-manifest": ".release-manifest.md",
   html: ".html",
   "cucumber-html": ".cucumber.html",
   junit: ".junit.xml",
@@ -20878,11 +21065,11 @@ function computeOutputPath(sourceFile, format, mode, colocatedStyle, baseOutputD
   const ext = FORMAT_EXTENSIONS[format];
   const effectiveName = outputName + (outputNameSuffix ?? "");
   if (mode === "aggregated") {
-    return toPosix(path10.join(baseOutputDir, joinNameAndExt(effectiveName, ext)));
+    return toPosix(path11.join(baseOutputDir, joinNameAndExt(effectiveName, ext)));
   }
   const normalizedSource = toPosix(sourceFile);
-  const dirOfSource = path10.posix.dirname(normalizedSource);
-  let baseName = path10.posix.basename(normalizedSource);
+  const dirOfSource = path11.posix.dirname(normalizedSource);
+  let baseName = path11.posix.basename(normalizedSource);
   for (const testExt of TEST_EXTENSIONS) {
     if (baseName.endsWith(testExt)) {
       baseName = baseName.slice(0, -testExt.length);
@@ -20891,12 +21078,12 @@ function computeOutputPath(sourceFile, format, mode, colocatedStyle, baseOutputD
   }
   const fileName = `${baseName}.${effectiveName}${ext}`;
   if (colocatedStyle === "adjacent") {
-    return toPosix(path10.posix.join(dirOfSource, fileName));
+    return toPosix(path11.posix.join(dirOfSource, fileName));
   }
   if (colocatedStyle === "flat") {
-    return toPosix(path10.posix.join(baseOutputDir, `${cleanTestStem(normalizedSource)}${ext}`));
+    return toPosix(path11.posix.join(baseOutputDir, `${cleanTestStem(normalizedSource)}${ext}`));
   }
-  return toPosix(path10.posix.join(baseOutputDir, dirOfSource, fileName));
+  return toPosix(path11.posix.join(baseOutputDir, dirOfSource, fileName));
 }
 function groupTestCasesByOutput(testCases, format, options, logger, outputNameSuffix) {
   const groups = /* @__PURE__ */ new Map();
@@ -21103,8 +21290,8 @@ var ReportGenerator = class {
       if (astroPaths) {
         for (const mdPath of astroPaths) {
           const content = await fsPromises.readFile(mdPath, "utf8");
-          const mdDir = path10.dirname(mdPath);
-          const assetsDir = path10.resolve(this.options.astro.assetsDir);
+          const mdDir = path11.dirname(mdPath);
+          const assetsDir = path11.resolve(this.options.astro.assetsDir);
           const result = copyMarkdownAssets({
             markdown: content,
             markdownDir: mdDir,
@@ -21135,9 +21322,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(path10.join(this.options.outputDir, joinNameAndExt(effectiveName, ext)));
+      const outputPath = toPosix(path11.join(this.options.outputDir, joinNameAndExt(effectiveName, ext)));
       const content = await this.formatContent(run, format);
-      const dir = path10.dirname(outputPath);
+      const dir = path11.dirname(outputPath);
       await fsPromises.mkdir(dir, { recursive: true });
       await this.deps.writeFile(outputPath, content);
       return [outputPath];
@@ -21149,7 +21336,7 @@ var ReportGenerator = class {
         testCases
       };
       const content = await this.formatContent(groupRun, format);
-      const dir = path10.dirname(outputPath);
+      const dir = path11.dirname(outputPath);
       await fsPromises.mkdir(dir, { recursive: true });
       await this.deps.writeFile(outputPath, content);
       writtenPaths.push(outputPath);
@@ -21258,6 +21445,10 @@ var ReportGenerator = class {
         });
         return formatter.format(run);
       }
+      case "release-manifest": {
+        const formatter = new ReleaseManifestFormatter();
+        return formatter.format(run);
+      }
       case "story-report-json": {
         const formatter = new StoryReportJsonFormatter({
           pretty: this.options.storyReportJson.pretty
@@ -21292,7 +21483,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(path10.join(outputDir, `${outputName}${ext}`));
+    const outputPath = toPosix(path11.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);
@@ -21326,6 +21517,7 @@ export {
   MIN_METRIC_SAMPLES,
   MIN_PERF_SAMPLES,
   MarkdownFormatter,
+  ReleaseManifestFormatter,
   ReportGenerator,
   ReviewHtmlFormatter,
   ReviewMarkdownFormatter,
@@ -21365,6 +21557,8 @@ export {
   generateTestCaseId,
   getAvailableThemes,
   getCssOnlyThemes,
+  getDeploymentStatus,
+  getEnvironmentDrift,
   gradeEvidence,
   hasSufficientHistory,
   isReviewableSource,
@@ -21386,6 +21580,7 @@ export {
   readBranchName,
   readGitSha,
   readPackageVersion,
+  recordDeployment,
   regenerateArtifacts,
   resolveAttachment,
   resolveAttachments,
@@ -21405,6 +21600,7 @@ export {
   toBehaviorManifest,
   toCIInfo,
   toRawCIInfo,
+  toReleaseManifest,
   toScenarioIndex,
   toStoryReport,
   tryGetActiveOtelContext,