versionary 0.27.0 → 0.28.1

package/dist/release/release.js

@@ -1,29 +1,27 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractReleaseNotes = extractReleaseNotes;
-exports.extractClosingReferencesFromNotes = extractClosingReferencesFromNotes;
-exports.resolveTargetChangelogFile = resolveTargetChangelogFile;
-exports.runRelease = runRelease;
-exports.runReleaseDetailed = runReleaseDetailed;
-exports.runSimpleRelease = runSimpleRelease;
-exports.runSimpleReleaseDetailed = runSimpleReleaseDetailed;
-const node_child_process_1 = require("node:child_process");
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const load_config_js_1 = require("../config/load-config.js");
-const client_js_1 = require("../scm/client.js");
-const resolve_js_1 = require("../strategy/resolve.js");
-const plan_js_1 = require("./plan.js");
-const pr_js_1 = require("./pr.js");
-const recovery_js_1 = require("./recovery.js");
-const state_js_1 = require("./state.js");
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { loadConfig } from "../config/load-config.js";
+import { getScmClient } from "../scm/client.js";
+import { resolvePackageStrategyContext, resolveReleaseName, } from "../strategy/package-context.js";
+import { resolveVersionStrategy } from "../strategy/resolve.js";
+import { getChangelogDefaults } from "./plan.js";
+import { isReleaseCommitMessage } from "./pr.js";
+import { executeIdempotentReleaseTarget } from "./recovery.js";
+import { readReleaseTargets } from "./state.js";
 function escapeRegExp(input) {
     return input.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
-function extractReleaseNotes(content, version, changelogFormat) {
+export function resolveTargetPackageName(cwd, config, targetPath) {
+    const packageConfig = config.packages?.[targetPath] ?? {};
+    const { strategy, config: strategyConfig } = resolvePackageStrategyContext(config, targetPath, packageConfig);
+    const resolved = resolveReleaseName(cwd, targetPath, packageConfig, strategy, strategyConfig);
+    if (!resolved || resolved === targetPath) {
+        return undefined;
+    }
+    return resolved;
+}
+export function extractReleaseNotes(content, version, changelogFormat) {
     const lines = content.split("\n");
     const shortVersion = version.replace(/\.\d+$/u, "");
     const start = changelogFormat === "r-news"
@@ -61,22 +59,22 @@ function extractReleaseNotes(content, version, changelogFormat) {
         .trim();
 }
 function getHeadCommitMessage(cwd) {
-    return (0, node_child_process_1.execFileSync)("git", ["log", "-1", "--pretty=%B"], {
+    return execFileSync("git", ["log", "-1", "--pretty=%B"], {
         cwd,
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"],
     }).trim();
 }
 function readReleaseNotes(cwd, version, changelogFile, changelogFormat) {
-    const changelogPath = node_path_1.default.join(cwd, changelogFile);
-    if (!node_fs_1.default.existsSync(changelogPath)) {
+    const changelogPath = path.join(cwd, changelogFile);
+    if (!fs.existsSync(changelogPath)) {
         return `Automated release for v${version}`;
     }
-    const content = node_fs_1.default.readFileSync(changelogPath, "utf8");
+    const content = fs.readFileSync(changelogPath, "utf8");
     const notes = extractReleaseNotes(content, version, changelogFormat);
     return notes.length > 0 ? notes : `Automated release for v${version}`;
 }
-function extractClosingReferencesFromNotes(notes) {
+export function extractClosingReferencesFromNotes(notes) {
     const refs = new Set();
     const linkedPattern = /\b(close|closes|closed|fix|fixes|fixed|resolve|resolves|resolved)\b\s+\[#(\d+)\]\([^)]+\)/giu;
     for (const match of notes.matchAll(linkedPattern)) {
@@ -94,30 +92,30 @@ function extractClosingReferencesFromNotes(notes) {
     }
     return [...refs].sort((a, b) => a - b);
 }
-function resolveTargetChangelogFile(config, rootChangelogFile, targetPath) {
+export function resolveTargetChangelogFile(config, rootChangelogFile, targetPath) {
     if (targetPath === ".") {
         return rootChangelogFile;
     }
     const packageConfig = config.packages?.[targetPath];
-    const packageStrategy = (0, resolve_js_1.resolveVersionStrategy)({
+    const packageStrategy = resolveVersionStrategy({
         ...config,
         "release-type": packageConfig?.["release-type"] ?? config["release-type"],
     });
-    const { changelogFile: packageChangelogFile } = (0, plan_js_1.getChangelogDefaults)({
+    const { changelogFile: packageChangelogFile } = getChangelogDefaults({
         "release-type": packageConfig?.["release-type"] ?? config["release-type"],
         "changelog-file": packageConfig?.["changelog-file"] ?? config["changelog-file"],
         "changelog-format": packageConfig?.["changelog-format"] ?? config["changelog-format"],
         defaultChangelogFormat: packageStrategy.getDefaultChangelogFormat?.(),
     });
-    return node_path_1.default.posix.join(targetPath, packageChangelogFile);
+    return path.posix.join(targetPath, packageChangelogFile);
 }
 function resolveTargetChangelogFormat(config, targetPath) {
     const packageConfig = config.packages?.[targetPath];
-    const packageStrategy = (0, resolve_js_1.resolveVersionStrategy)({
+    const packageStrategy = resolveVersionStrategy({
         ...config,
         "release-type": packageConfig?.["release-type"] ?? config["release-type"],
     });
-    const { changelogFormat } = (0, plan_js_1.getChangelogDefaults)({
+    const { changelogFormat } = getChangelogDefaults({
         "release-type": packageConfig?.["release-type"] ?? config["release-type"],
         "changelog-file": packageConfig?.["changelog-file"] ?? config["changelog-file"],
         "changelog-format": packageConfig?.["changelog-format"] ?? config["changelog-format"],
@@ -125,31 +123,31 @@ function resolveTargetChangelogFormat(config, targetPath) {
     });
     return changelogFormat;
 }
-async function runRelease(cwd = process.cwd()) {
+export async function runRelease(cwd = process.cwd()) {
     const result = await runReleaseDetailed(cwd, { logger: console });
     if (result.action === "release-skipped") {
         return result.reason;
     }
     return result.message;
 }
-async function runReleaseDetailed(cwd = process.cwd(), options = {}) {
+export async function runReleaseDetailed(cwd = process.cwd(), options = {}) {
     const commitMessage = getHeadCommitMessage(cwd);
-    if (!(0, pr_js_1.isReleaseCommitMessage)(commitMessage)) {
+    if (!isReleaseCommitMessage(commitMessage)) {
         return {
             action: "release-skipped",
             reason: "No release commit context detected; skipping release stage.",
         };
     }
-    const loaded = (0, load_config_js_1.loadConfig)(cwd);
-    const strategy = (0, resolve_js_1.resolveVersionStrategy)(loaded.config);
-    const { changelogFile } = (0, plan_js_1.getChangelogDefaults)({
+    const loaded = loadConfig(cwd);
+    const strategy = resolveVersionStrategy(loaded.config);
+    const { changelogFile } = getChangelogDefaults({
         ...loaded.config,
         defaultChangelogFormat: strategy.getDefaultChangelogFormat?.(),
     });
     const referenceCommentMode = loaded.config["release-reference-comments"] ?? "off";
     const version = strategy.readVersion(cwd, loaded.config);
     const defaultTag = `v${version}`;
-    const releaseTargets = (0, state_js_1.readReleaseTargets)(cwd);
+    const releaseTargets = readReleaseTargets(cwd);
     const targets = releaseTargets.length > 0
         ? releaseTargets
         : [
@@ -170,15 +168,15 @@ async function runReleaseDetailed(cwd = process.cwd(), options = {}) {
             message: `Dry run: would publish releases ${targetList.join(", ")}`,
         };
     }
-    const scmClient = (0, client_js_1.getScmClient)();
+    const scmClient = getScmClient();
     const releases = [];
-    const referencesByTag = new Map();
+    const referenceReleases = [];
     for (const target of targets) {
         const targetChangelogFile = resolveTargetChangelogFile(loaded.config, changelogFile, target.path);
         const targetChangelogFormat = resolveTargetChangelogFormat(loaded.config, target.path);
         const releaseNotes = readReleaseNotes(cwd, target.version, targetChangelogFile, targetChangelogFormat);
-        referencesByTag.set(target.tag, extractClosingReferencesFromNotes(releaseNotes));
-        const outcome = await (0, recovery_js_1.executeIdempotentReleaseTarget)(cwd, {
+        const references = extractClosingReferencesFromNotes(releaseNotes);
+        const outcome = await executeIdempotentReleaseTarget(cwd, {
             tag: target.tag,
             version: target.version,
             notes: releaseNotes,
@@ -197,21 +195,27 @@ async function runReleaseDetailed(cwd = process.cwd(), options = {}) {
             tagStatus: outcome.tagStatus,
             metadataStatus: outcome.metadataStatus,
         });
-        const references = referencesByTag.get(outcome.tag) ?? [];
-        if (references.length > 0 &&
-            referenceCommentMode !== "off" &&
-            scmClient.createReleaseReferenceComments) {
-            await scmClient.createReleaseReferenceComments({
+        if (references.length > 0) {
+            referenceReleases.push({
+                name: resolveTargetPackageName(cwd, loaded.config, target.path),
+                tag: outcome.tag,
                 version: target.version,
                 releaseUrl: outcome.url,
                 references,
-                mode: referenceCommentMode,
-            }, {
-                cwd,
-                logger: options.logger,
             });
         }
     }
+    if (referenceReleases.length > 0 &&
+        referenceCommentMode !== "off" &&
+        scmClient.createReleaseReferenceComments) {
+        await scmClient.createReleaseReferenceComments({
+            releases: referenceReleases,
+            mode: referenceCommentMode,
+        }, {
+            cwd,
+            logger: options.logger,
+        });
+    }
     const published = releases.map((outcome) => `${outcome.tag}: ${outcome.url} (tag=${outcome.tagStatus}, metadata=${outcome.metadataStatus})`);
     return {
         action: "release-published",
@@ -220,10 +224,10 @@ async function runReleaseDetailed(cwd = process.cwd(), options = {}) {
     };
 }
 /** @deprecated Use runRelease. */
-async function runSimpleRelease(cwd = process.cwd()) {
+export async function runSimpleRelease(cwd = process.cwd()) {
     return runRelease(cwd);
 }
 /** @deprecated Use runReleaseDetailed. */
-async function runSimpleReleaseDetailed(cwd = process.cwd(), options = {}) {
+export async function runSimpleReleaseDetailed(cwd = process.cwd(), options = {}) {
     return runReleaseDetailed(cwd, options);
 }

package/dist/release/semver.js

@@ -1,11 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.maxReleaseType = maxReleaseType;
-exports.parseVersion = parseVersion;
-exports.isValidVersion = isValidVersion;
-exports.compareVersions = compareVersions;
-exports.bumpVersion = bumpVersion;
-function maxReleaseType(types) {
+export function maxReleaseType(types) {
     if (types.includes("major")) {
         return "major";
     }
@@ -28,7 +21,7 @@ function normalizeVersionInput(version) {
     const [, major, minor, patch, prerelease] = compatMatch;
     return `${major}.${minor}.${patch}-${prerelease}`;
 }
-function parseVersion(version) {
+export function parseVersion(version) {
     const normalized = normalizeVersionInput(version);
     const match = normalized.match(SEMVER_PATTERN);
     if (!match) {
@@ -42,7 +35,7 @@ function parseVersion(version) {
         build: match[5] ? match[5].split(".") : [],
     };
 }
-function isValidVersion(version) {
+export function isValidVersion(version) {
     return SEMVER_PATTERN.test(normalizeVersionInput(version));
 }
 function isNumericIdentifier(identifier) {
@@ -76,7 +69,7 @@ function comparePreReleaseIdentifiers(left, right) {
     }
     return 0;
 }
-function compareVersions(leftRaw, rightRaw) {
+export function compareVersions(leftRaw, rightRaw) {
     const left = parseVersion(leftRaw);
     const right = parseVersion(rightRaw);
     if (left.major !== right.major) {
@@ -116,7 +109,7 @@ function compareVersions(leftRaw, rightRaw) {
     }
     return 0;
 }
-function bumpVersion(current, releaseType, options = {}) {
+export function bumpVersion(current, releaseType, options = {}) {
     const parsed = parseVersion(current);
     const allowStableMajor = options.allowStableMajor ?? false;
     if (releaseType === "major") {

package/dist/release/state.js

@@ -1,16 +1,7 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getBaselineStatePath = getBaselineStatePath;
-exports.readBaselineSha = readBaselineSha;
-exports.readReleaseTargets = readReleaseTargets;
-exports.writeBaselineSha = writeBaselineSha;
-const node_child_process_1 = require("node:child_process");
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const load_config_js_1 = require("../config/load-config.js");
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { loadConfig } from "../config/load-config.js";
 const MANIFEST_VERSION_KEY = "manifest-version";
 const BASELINE_SHA_KEY = "baseline-sha";
 const RELEASE_TARGETS_KEY = "release-targets";
@@ -47,48 +38,48 @@ function parseStateFile(raw, filePath) {
     }
     return manifest;
 }
-function getBaselineStatePath(cwd) {
-    const loaded = (0, load_config_js_1.loadConfig)(cwd);
+export function getBaselineStatePath(cwd) {
+    const loaded = loadConfig(cwd);
     const configured = loaded.config["baseline-file"];
     if (configured) {
-        return node_path_1.default.join(cwd, configured);
+        return path.join(cwd, configured);
     }
-    const preferred = node_path_1.default.join(cwd, ".versionary-manifest.json");
-    if (node_fs_1.default.existsSync(preferred)) {
+    const preferred = path.join(cwd, ".versionary-manifest.json");
+    if (fs.existsSync(preferred)) {
         return preferred;
     }
-    const legacy = node_path_1.default.join(cwd, "versionary.versions.json");
-    if (node_fs_1.default.existsSync(legacy)) {
+    const legacy = path.join(cwd, "versionary.versions.json");
+    if (fs.existsSync(legacy)) {
         return legacy;
     }
     return preferred;
 }
-function readBaselineSha(cwd = process.cwd()) {
+export function readBaselineSha(cwd = process.cwd()) {
     const filePath = getBaselineStatePath(cwd);
-    if (!node_fs_1.default.existsSync(filePath)) {
+    if (!fs.existsSync(filePath)) {
         return null;
     }
-    const parsed = parseStateFile(node_fs_1.default.readFileSync(filePath, "utf8"), filePath);
+    const parsed = parseStateFile(fs.readFileSync(filePath, "utf8"), filePath);
     return parsed[BASELINE_SHA_KEY] ?? null;
 }
-function readReleaseTargets(cwd = process.cwd()) {
+export function readReleaseTargets(cwd = process.cwd()) {
     const filePath = getBaselineStatePath(cwd);
-    if (!node_fs_1.default.existsSync(filePath)) {
+    if (!fs.existsSync(filePath)) {
         return [];
     }
-    const parsed = parseStateFile(node_fs_1.default.readFileSync(filePath, "utf8"), filePath);
+    const parsed = parseStateFile(fs.readFileSync(filePath, "utf8"), filePath);
     return parsed[RELEASE_TARGETS_KEY] ?? [];
 }
-function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets) {
+export function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets) {
     const baselineShaValue = sha ??
-        (0, node_child_process_1.execFileSync)("git", ["rev-parse", "HEAD"], {
+        execFileSync("git", ["rev-parse", "HEAD"], {
             cwd,
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"],
         }).trim();
     const filePath = getBaselineStatePath(cwd);
-    const existing = node_fs_1.default.existsSync(filePath)
-        ? parseStateFile(node_fs_1.default.readFileSync(filePath, "utf8"), filePath)
+    const existing = fs.existsSync(filePath)
+        ? parseStateFile(fs.readFileSync(filePath, "utf8"), filePath)
         : {};
     const existingTargets = existing[RELEASE_TARGETS_KEY] ?? [];
     const nextTargets = releaseTargets === undefined
@@ -104,5 +95,5 @@ function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets) {
         [BASELINE_SHA_KEY]: baselineShaValue,
         [RELEASE_TARGETS_KEY]: nextTargets,
     };
-    node_fs_1.default.writeFileSync(filePath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+    fs.writeFileSync(filePath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
 }

package/dist/release/verify-project.js

@@ -1,26 +1,20 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifyProject = verifyProject;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const load_config_js_1 = require("../config/load-config.js");
-const package_context_js_1 = require("../strategy/package-context.js");
-const resolve_js_1 = require("../strategy/resolve.js");
-function verifyProject(cwd = process.cwd()) {
+import fs from "node:fs";
+import path from "node:path";
+import { loadConfig } from "../config/load-config.js";
+import { resolvePackageStrategyContext } from "../strategy/package-context.js";
+import { resolveVersionStrategy } from "../strategy/resolve.js";
+export function verifyProject(cwd = process.cwd()) {
     const checks = [];
-    const config = (0, load_config_js_1.loadConfig)(cwd);
+    const config = loadConfig(cwd);
     checks.push({
         name: "config-load",
         ok: true,
-        details: `Loaded ${node_path_1.default.basename(config.path)} (${config.format})`,
+        details: `Loaded ${path.basename(config.path)} (${config.format})`,
         category: "config",
     });
-    const strategy = (0, resolve_js_1.resolveVersionStrategy)(config.config);
+    const strategy = resolveVersionStrategy(config.config);
     const versionFile = strategy.getVersionFile(config.config);
-    const exists = node_fs_1.default.existsSync(node_path_1.default.join(cwd, versionFile));
+    const exists = fs.existsSync(path.join(cwd, versionFile));
     checks.push({
         name: `version-file:${versionFile}`,
         ok: exists,
@@ -44,8 +38,8 @@ function verifyProject(cwd = process.cwd()) {
     }
     if (config.config.packages) {
         for (const [pkgPathRaw, packageConfig] of Object.entries(config.config.packages)) {
-            const pkgPath = node_path_1.default.join(cwd, pkgPathRaw);
-            const exists = node_fs_1.default.existsSync(pkgPath);
+            const pkgPath = path.join(cwd, pkgPathRaw);
+            const exists = fs.existsSync(pkgPath);
             checks.push({
                 name: `package-path:${pkgPathRaw}`,
                 ok: exists,
@@ -56,9 +50,9 @@ function verifyProject(cwd = process.cwd()) {
                     : `Create ${pkgPathRaw} or remove/rename this entry under "packages" in versionary config.`,
             });
             if (exists) {
-                const packageContext = (0, package_context_js_1.resolvePackageStrategyContext)(config.config, pkgPathRaw, packageConfig);
+                const packageContext = resolvePackageStrategyContext(config.config, pkgPathRaw, packageConfig);
                 const packageVersionFile = packageContext.versionFile;
-                const packageVersionExists = node_fs_1.default.existsSync(node_path_1.default.join(cwd, packageVersionFile));
+                const packageVersionExists = fs.existsSync(path.join(cwd, packageVersionFile));
                 checks.push({
                     name: `version-file:${packageVersionFile}`,
                     ok: packageVersionExists,

package/dist/scm/capabilities.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pluginHasCapability = pluginHasCapability;
-exports.findPluginsByCapability = findPluginsByCapability;
-function pluginHasCapability(plugin, capability) {
+export function pluginHasCapability(plugin, capability) {
     return plugin.capabilities.includes(capability);
 }
-function findPluginsByCapability(plugins, capability) {
+export function findPluginsByCapability(plugins, capability) {
     return plugins.filter((plugin) => pluginHasCapability(plugin, capability));
 }

package/dist/scm/client.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getScmClient = getScmClient;
-const github_plugin_js_1 = require("./github-plugin.js");
-function getScmClient() {
-    return (0, github_plugin_js_1.createGitHubPlugin)();
+import { createGitHubPlugin } from "./github-plugin.js";
+export function getScmClient() {
+    return createGitHubPlugin();
 }

package/dist/scm/github-plugin.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createGitHubPlugin = createGitHubPlugin;
-const rest_1 = require("@octokit/rest");
+import { Octokit } from "@octokit/rest";
 function parseRepoSlug(input) {
     const [owner, repo] = input.split("/");
     if (!owner || !repo) {
@@ -86,7 +83,43 @@ async function ensureLabels(octokit, repo, pullNumber, labels, branchContext) {
         throw new Error(`Failed applying labels to pull request #${pullNumber}: [${repoRef(repo)} base=${branchContext.baseBranch} head=${branchContext.headBranch}] ${message}`);
     }
 }
-function createGitHubPlugin() {
+function groupReleasesByIssue(releases) {
+    const byIssue = new Map();
+    for (const release of releases) {
+        for (const reference of release.references) {
+            const bucket = byIssue.get(reference) ?? [];
+            if (!bucket.some((entry) => entry.tag === release.tag)) {
+                bucket.push(release);
+            }
+            byIssue.set(reference, bucket);
+        }
+    }
+    for (const bucket of byIssue.values()) {
+        bucket.sort((a, b) => a.tag.localeCompare(b.tag));
+    }
+    return new Map([...byIssue.entries()].sort(([a], [b]) => a - b));
+}
+function renderReleaseLink(release) {
+    if (release.name) {
+        return `[\`${release.name}\` v${release.version}](${release.releaseUrl})`;
+    }
+    return `[version ${release.version}](${release.releaseUrl})`;
+}
+function renderReleaseReferenceCommentBody(releases) {
+    const footer = "Released by [Versionary](https://github.com/jolars/versionary).";
+    if (releases.length === 1) {
+        const release = releases[0];
+        if (!release) {
+            throw new Error("Expected at least one release for comment body.");
+        }
+        return `This is included in ${renderReleaseLink(release)}. :tada:\n\n${footer}`;
+    }
+    const bullets = releases
+        .map((release) => `- ${renderReleaseLink(release)}`)
+        .join("\n");
+    return `This is included in the following releases: :tada:\n\n${bullets}\n\n${footer}`;
+}
+export function createGitHubPlugin() {
     return {
         name: "github",
         capabilities: [
@@ -97,7 +130,7 @@ function createGitHubPlugin() {
         provider: "github",
         async createOrUpdateReviewRequest(input, _context) {
             const repo = getRepoFromEnv();
-            const octokit = new rest_1.Octokit({ auth: getGitHubToken() });
+            const octokit = new Octokit({ auth: getGitHubToken() });
             const listHead = resolveHeadForList(repo, input.headBranch);
             let existing;
             try {
@@ -176,7 +209,7 @@ function createGitHubPlugin() {
         },
         async closeReviewRequestIfExists(input, _context) {
             const repo = getRepoFromEnv();
-            const octokit = new rest_1.Octokit({ auth: getGitHubToken() });
+            const octokit = new Octokit({ auth: getGitHubToken() });
             const listHead = resolveHeadForList(repo, input.headBranch);
             let existing;
             try {
@@ -238,7 +271,7 @@ function createGitHubPlugin() {
         },
         async createReleaseMetadata(input, _context) {
             const repo = getRepoFromEnv();
-            const octokit = new rest_1.Octokit({ auth: getGitHubToken() });
+            const octokit = new Octokit({ auth: getGitHubToken() });
             try {
                 const existing = await octokit.repos.getReleaseByTag({
                     owner: repo.owner,
@@ -274,12 +307,12 @@ function createGitHubPlugin() {
         },
         async createReleaseReferenceComments(input, context) {
             const repo = getRepoFromEnv();
-            const octokit = new rest_1.Octokit({ auth: getGitHubToken() });
-            const uniqueReferences = [...new Set(input.references)].sort((a, b) => a - b);
-            const commented = [];
+            const octokit = new Octokit({ auth: getGitHubToken() });
             const mode = input.mode ?? "best-effort";
-            for (const reference of uniqueReferences) {
-                const body = `This is included in [version ${input.version}](${input.releaseUrl}). :tada:\n\nReleased by [Versionary](https://github.com/jolars/versionary).`;
+            const releasesByIssue = groupReleasesByIssue(input.releases);
+            const commented = [];
+            for (const [reference, releases] of releasesByIssue) {
+                const body = renderReleaseReferenceCommentBody(releases);
                 try {
                     await octokit.issues.createComment({
                         owner: repo.owner,

package/dist/scm/types.d.ts

@@ -41,10 +41,15 @@ export interface ScmReleaseMetadataResult {
     url: string;
     status?: "created" | "exists";
 }
-export interface ScmReleaseReferenceCommentsInput {
+export interface ScmReleaseReferenceCommentsRelease {
+    name?: string;
+    tag: string;
     version: string;
     releaseUrl: string;
     references: number[];
+}
+export interface ScmReleaseReferenceCommentsInput {
+    releases: ScmReleaseReferenceCommentsRelease[];
     mode?: "best-effort" | "strict";
 }
 export interface ScmReleaseReferenceCommentsResult {

package/dist/scm/types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/strategy/composite.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compositeVersionStrategy = compositeVersionStrategy;
 function configForSecondary(config) {
     if (config["version-file"] === undefined) {
         return config;
@@ -11,7 +8,7 @@ function configForSecondary(config) {
 function dedupedSorted(values) {
     return [...new Set(values)].sort((a, b) => a.localeCompare(b));
 }
-function compositeVersionStrategy(strategies) {
+export function compositeVersionStrategy(strategies) {
     if (strategies.length === 0) {
         throw new Error("compositeVersionStrategy requires at least one strategy.");
     }