versionary 0.16.0 → 0.18.0

package/dist/cli/index.js

@@ -99,6 +99,9 @@ async function main() {
         }
         const plan = (0, plan_js_1.createReleasePlan)();
         if (!plan.nextVersion) {
+            if (!flags["dry-run"]) {
+                await (0, pr_js_1.closeStaleReviewRequestIfExists)(process.cwd(), { logger });
+            }
             const message = "No releasable commits found. Nothing to do.";
             if (flags.json) {
                 emitJson({
@@ -203,12 +206,17 @@ async function main() {
         return 0;
     }
     if (command === "pr") {
-        if (flags["dry-run"]) {
-            const plan = (0, plan_js_1.createReleasePlan)();
-            if (!plan.nextVersion) {
-                console.log("No releasable commits found. Nothing to do.");
-                return 0;
+        const plan = (0, plan_js_1.createReleasePlan)();
+        if (!plan.nextVersion) {
+            if (!flags["dry-run"]) {
+                await (0, pr_js_1.closeStaleReviewRequestIfExists)(process.cwd(), {
+                    logger: console,
+                });
             }
+            console.log("No releasable commits found. Nothing to do.");
+            return 0;
+        }
+        if (flags["dry-run"]) {
             console.log(`Dry run: would prepare release PR branch ${plan.releaseBranchPrefix} for ${plan.nextVersion}`);
             return 0;
         }

package/dist/config/load-config.js

@@ -8,6 +8,7 @@ exports.loadConfig = loadConfig;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const jsonc_parser_1 = require("jsonc-parser");
+const resolve_js_1 = require("../strategy/resolve.js");
 const schema_js_1 = require("./schema.js");
 const SUPPORTED_FILES = [
     { file: "versionary.jsonc", format: "jsonc" },
@@ -22,6 +23,34 @@ function parseConfig(raw, format) {
 function isRecord(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+function validateReleaseTypes(config) {
+    try {
+        (0, resolve_js_1.resolveVersionStrategy)(config);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw error;
+        }
+        const known = (0, resolve_js_1.listKnownReleaseTypes)().join(", ");
+        throw new Error(`Unsupported release-type. Supported release types: ${known}.`);
+    }
+    for (const [packagePath, packageConfig] of Object.entries(config.packages ?? {})) {
+        const packageReleaseType = packageConfig["release-type"];
+        if (!packageReleaseType) {
+            continue;
+        }
+        try {
+            (0, resolve_js_1.resolveVersionStrategy)({ ...config, "release-type": packageReleaseType });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw new Error(`${error.message} (in packages["${packagePath}"])`);
+            }
+            const known = (0, resolve_js_1.listKnownReleaseTypes)().join(", ");
+            throw new Error(`Unsupported release-type in packages["${packagePath}"]. Supported release types: ${known}.`);
+        }
+    }
+}
 function findConfigFile(cwd) {
     for (const candidate of SUPPORTED_FILES) {
         const candidatePath = node_path_1.default.join(cwd, candidate.file);
@@ -45,6 +74,7 @@ function loadConfig(cwd = process.cwd()) {
         throw new Error('The "plugins" config key is no longer supported. Versionary uses built-in integrations only.');
     }
     const validated = schema_js_1.configSchema.parse(parsed);
+    validateReleaseTypes(validated);
     return {
         path: found.path,
         format: found.format,

package/dist/git/commits.js

@@ -437,17 +437,26 @@ function applyRevertSuppression(commits) {
     }
     const presentShas = new Set(commits.map((commit) => commit.hash.toLowerCase()));
     const reverted = new Set();
+    const suppressedReverts = new Set();
     for (const commit of commits) {
         if (!commit.isRevert) {
             continue;
         }
+        const revertsOnlyInWindow = commit.revertedShas.length > 0 &&
+            commit.revertedShas.every((sha) => presentShas.has(sha));
+        if (revertsOnlyInWindow) {
+            suppressedReverts.add(commit.hash.toLowerCase());
+        }
         for (const sha of commit.revertedShas) {
             if (presentShas.has(sha)) {
                 reverted.add(sha);
             }
         }
     }
-    return commits.filter((commit) => !reverted.has(commit.hash.toLowerCase()));
+    return commits.filter((commit) => {
+        const hash = commit.hash.toLowerCase();
+        return !reverted.has(hash) && !suppressedReverts.has(hash);
+    });
 }
 function analyzeParsedCommits(commits) {
     let result = null;

package/dist/release/changelog.d.ts

@@ -12,8 +12,14 @@ export declare function renderSimpleReleaseNotes(input: {
     }>;
 }, options?: {
     includeFooter?: boolean;
+    headerLabel?: string;
+}): string;
+export declare function renderReviewRequestFooter(): string;
+export declare function renderReleasePlanChangelog(plan: ReleasePlan, options?: {
+    headerLabel?: string;
+    includeFooter?: boolean;
+    cwd?: string;
 }): string;
-export declare function renderReleasePlanChangelog(plan: ReleasePlan): string;
 /** @deprecated Use renderReleasePlanChangelog. */
 export declare function renderSimpleChangelog(plan: SimplePlan): string;
 export declare function renderPackageChangelogSection(input: {

package/dist/release/changelog.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderSimpleReleaseNotes = renderSimpleReleaseNotes;
+exports.renderReviewRequestFooter = renderReviewRequestFooter;
 exports.renderReleasePlanChangelog = renderReleasePlanChangelog;
 exports.renderSimpleChangelog = renderSimpleChangelog;
 exports.renderPackageChangelogSection = renderPackageChangelogSection;
@@ -13,6 +14,7 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const commits_js_1 = require("../git/commits.js");
 const repo_url_js_1 = require("../git/repo-url.js");
+const REVIEW_REQUEST_FOOTER = "---\n\nThis PR was generated by [Versionary](https://github.com/jolars/versionary).";
 function formatDate() {
     return new Date().toISOString().slice(0, 10);
 }
@@ -75,6 +77,7 @@ function groupCommitLines(commits, repoUrl) {
     const features = [];
     const fixes = [];
     const reverts = [];
+    const effectiveCommits = (0, commits_js_1.applyRevertSuppression)(commits);
     const getRevertedSubject = (commit) => {
         const normalizedDescription = (commit.description ?? "")
             .trim()
@@ -97,7 +100,7 @@ function groupCommitLines(commits, repoUrl) {
         const revertedCommit = (0, commits_js_1.parseConventionalCommitMessage)(revertedSubject);
         return (0, commits_js_1.inferReleaseTypeFromParsedCommit)(revertedCommit) !== null;
     };
-    for (const commit of commits) {
+    for (const commit of effectiveCommits) {
         const type = (0, commits_js_1.inferReleaseTypeFromParsedCommit)(commit);
         if (!type) {
             continue;
@@ -136,9 +139,10 @@ function groupCommitLines(commits, repoUrl) {
 }
 function renderSimpleReleaseNotes(input, options = {}) {
     const repoUrl = (0, repo_url_js_1.resolveRepositoryWebBaseUrl)(input.cwd ?? process.cwd());
+    const headerLabel = options.headerLabel ?? input.nextVersion;
     const header = repoUrl
-        ? `## [${input.nextVersion}](${repoUrl}/compare/v${input.currentVersion}...v${input.nextVersion}) (${formatDate()})`
-        : `## ${input.nextVersion} (${formatDate()})`;
+        ? `## [${headerLabel}](${repoUrl}/compare/v${input.currentVersion}...v${input.nextVersion}) (${formatDate()})`
+        : `## ${headerLabel} (${formatDate()})`;
     const grouped = groupCommitLines(input.commits, repoUrl);
     const sections = [];
     if (grouped.breaking.length > 0) {
@@ -156,13 +160,16 @@ function renderSimpleReleaseNotes(input, options = {}) {
     if (input.dependencies && input.dependencies.length > 0) {
         sections.push("### Dependencies", ...input.dependencies.map((dependency) => `- updated ${dependency.name} to v${dependency.version}`), "");
     }
-    const lines = [header, "", ...sections];
+    const body = [header, "", ...sections].join("\n").trimEnd();
     if (options.includeFooter) {
-        lines.push("\n---\n\nThis PR was generated by [Versionary](https://github.com/jolars/versionary).");
+        return `${body}\n\n${renderReviewRequestFooter()}`;
     }
-    return lines.join("\n");
+    return body;
+}
+function renderReviewRequestFooter() {
+    return REVIEW_REQUEST_FOOTER;
 }
-function renderReleasePlanChangelog(plan) {
+function renderReleasePlanChangelog(plan, options = {}) {
     if (!plan.nextVersion) {
         return "";
     }
@@ -194,8 +201,11 @@ function renderReleasePlanChangelog(plan) {
         currentVersion: plan.currentVersion,
         nextVersion: plan.nextVersion,
         commits: dedupedCommits,
-        cwd: process.cwd(),
+        cwd: options.cwd ?? process.cwd(),
         dependencies,
+    }, {
+        includeFooter: options.includeFooter,
+        headerLabel: options.headerLabel,
     });
 }
 /** @deprecated Use renderReleasePlanChangelog. */

package/dist/release/pr.d.ts

@@ -20,6 +20,13 @@ export declare function renderSimpleReviewRequestBody(version: string, previousV
 export declare function openOrUpdateReviewRequest(cwd: string, branch: string, title: string, version: string, previousVersion: string, commits: ParsedCommit[], plan?: SimplePlan | null, options?: {
     logger?: VersionaryPluginContext["logger"];
 }): Promise<string>;
+export declare function closeStaleReviewRequestIfExists(cwd?: string, options?: {
+    logger?: VersionaryPluginContext["logger"];
+}): Promise<{
+    closed: boolean;
+    url?: string;
+    number?: number;
+}>;
 /** @deprecated Use prepareReleasePr. */
 export declare function prepareSimpleReleasePr(cwd?: string, options?: {
     logger?: VersionaryPluginContext["logger"];

package/dist/release/pr.js

@@ -7,6 +7,7 @@ exports.splitSafeDirtyFiles = splitSafeDirtyFiles;
 exports.prepareReleasePr = prepareReleasePr;
 exports.renderSimpleReviewRequestBody = renderSimpleReviewRequestBody;
 exports.openOrUpdateReviewRequest = openOrUpdateReviewRequest;
+exports.closeStaleReviewRequestIfExists = closeStaleReviewRequestIfExists;
 exports.prepareSimpleReleasePr = prepareSimpleReleasePr;
 exports.openOrUpdateSimpleReviewRequest = openOrUpdateSimpleReviewRequest;
 exports.pushReleaseBranch = pushReleaseBranch;
@@ -348,25 +349,15 @@ function renderSimpleReviewRequestBody(version, previousVersion, commits, plan =
             .sort((a, b) => a.name.localeCompare(b.name));
         return directSources;
     };
-    const relabelSectionHeader = (notes, packageLabel, nextVersion) => {
-        const linkedHeader = notes.match(/^##\s+\[([^\]]+)\]\(([^)]+)\)\s+\(([^)]+)\)/u);
-        if (linkedHeader) {
-            const [, , compareUrl, date] = linkedHeader;
-            return notes.replace(/^##\s+\[[^\]]+\]\([^)]+\)\s+\([^)]+\)/u, `## [${packageLabel}: ${nextVersion}](${compareUrl}) (${date})`);
-        }
-        const plainHeader = notes.match(/^##\s+([^\s]+)\s+\(([^)]+)\)/u);
-        if (plainHeader) {
-            const [, , date] = plainHeader;
-            return notes.replace(/^##\s+[^\s]+\s+\([^)]+\)/u, `## ${packageLabel}: ${nextVersion} (${date})`);
-        }
-        return notes;
-    };
     if (plan?.packages && plan.packages.length > 1) {
         const sections = [];
         const rootPackage = plan.packages.find((pkg) => pkg.path === "." && pkg.nextVersion);
         if (rootPackage?.nextVersion) {
-            const rootNotes = (0, changelog_js_1.renderReleasePlanChangelog)(plan);
-            sections.push(relabelSectionHeader(rootNotes, formatPackageLabel("."), rootPackage.nextVersion));
+            const rootNotes = (0, changelog_js_1.renderReleasePlanChangelog)(plan, {
+                headerLabel: `${formatPackageLabel(".")}: ${rootPackage.nextVersion}`,
+                cwd,
+            });
+            sections.push(rootNotes);
         }
         const packageSections = plan.packages
             .filter((pkg) => pkg.path !== "." && pkg.nextVersion)
@@ -379,15 +370,18 @@ function renderSimpleReviewRequestBody(version, previousVersion, commits, plan =
                 commits: pkg.commits,
                 cwd,
                 dependencies: propagatedDependencies,
-            }, { includeFooter: false });
-            return relabelSectionHeader(notes, packageLabel, pkg.nextVersion ?? "");
+            }, {
+                includeFooter: false,
+                headerLabel: `${packageLabel}: ${pkg.nextVersion ?? ""}`,
+            });
+            return notes;
         });
         sections.push(...packageSections);
         const bodySections = sections.join("\n\n");
         if (bodySections.length === 0) {
-            return "This PR was generated by Versionary.";
+            return (0, changelog_js_1.renderReviewRequestFooter)();
         }
-        return `${bodySections}\n\nThis PR was generated by Versionary.`;
+        return `${bodySections}\n\n${(0, changelog_js_1.renderReviewRequestFooter)()}`;
     }
     return (0, changelog_js_1.renderSimpleReleaseNotes)({
         currentVersion: previousVersion,
@@ -415,6 +409,32 @@ async function openOrUpdateReviewRequest(cwd, branch, title, version, previousVe
     });
     return result.url;
 }
+function hasScmRuntimeContext() {
+    const hasRepository = Boolean(process.env.GITHUB_REPOSITORY);
+    const hasToken = Boolean(process.env.VERSIONARY_PR_TOKEN ??
+        process.env.GH_TOKEN ??
+        process.env.GITHUB_TOKEN);
+    return hasRepository && hasToken;
+}
+async function closeStaleReviewRequestIfExists(cwd = process.cwd(), options = {}) {
+    if (!hasScmRuntimeContext()) {
+        return { closed: false };
+    }
+    const plan = (0, plan_js_1.createReleasePlan)(cwd);
+    const scmClient = (0, client_js_1.getScmClient)();
+    const result = await scmClient.closeReviewRequestIfExists({
+        baseBranch: process.env.VERSIONARY_BASE_BRANCH ?? "main",
+        headBranch: plan.releaseBranchPrefix,
+        reason: "Closing stale release PR because no releasable commits remain for the current baseline/tag state.",
+    }, {
+        cwd,
+        logger: options.logger,
+    });
+    if (result.closed && result.number) {
+        options.logger?.info(`Closed stale release review request #${result.number} for ${plan.releaseBranchPrefix}.`);
+    }
+    return result;
+}
 /** @deprecated Use prepareReleasePr. */
 function prepareSimpleReleasePr(cwd = process.cwd(), options = {}) {
     return prepareReleasePr(cwd, options);

package/dist/release/recovery.d.ts

@@ -5,6 +5,7 @@ export interface ReleaseTargetInput {
     version: string;
     notes: string;
     draft?: boolean;
+    makeLatest?: "true" | "false" | "legacy";
 }
 export interface ReleaseExecutionContext {
     createReleaseMetadata: (input: ReleaseTargetInput) => Promise<VersionaryScmReleaseMetadataResult>;

package/dist/release/release.js

@@ -183,6 +183,7 @@ async function runReleaseDetailed(cwd = process.cwd(), options = {}) {
             version: target.version,
             notes: releaseNotes,
             draft: loaded.config["release-draft"] ?? false,
+            makeLatest: target.path === "." ? "true" : "false",
         }, {
             createReleaseMetadata: (input) => scmClient.createReleaseMetadata(input, {
                 cwd,

package/dist/scm/github-plugin.js

@@ -174,6 +174,68 @@ function createGitHubPlugin() {
                 state: toReviewRequestState(created, `pull request #${created.number} in ${repoRef(repo)}`),
             };
         },
+        async closeReviewRequestIfExists(input, _context) {
+            const repo = getRepoFromEnv();
+            const octokit = new rest_1.Octokit({ auth: getGitHubToken() });
+            const listHead = resolveHeadForList(repo, input.headBranch);
+            let existing;
+            try {
+                const response = await octokit.pulls.list({
+                    owner: repo.owner,
+                    repo: repo.repo,
+                    state: "open",
+                    head: listHead,
+                    base: input.baseBranch,
+                    per_page: 100,
+                });
+                existing = response.data;
+            }
+            catch (error) {
+                const { message } = parseGitHubError(error);
+                throw new Error(`Failed listing open pull requests for branch "${input.headBranch}" into "${input.baseBranch}": [${repoRef(repo)}] ${message}`);
+            }
+            if (existing.length > 1) {
+                const matches = existing.map((item) => `#${item.number}`).join(", ");
+                throw new Error(`Ambiguous open pull request matches for "${input.headBranch}" into "${input.baseBranch}": [${repoRef(repo)}] ${matches}`);
+            }
+            if (existing.length === 0) {
+                return { closed: false };
+            }
+            const pr = existing[0];
+            let updated;
+            try {
+                const response = await octokit.pulls.update({
+                    owner: repo.owner,
+                    repo: repo.repo,
+                    pull_number: pr.number,
+                    state: "closed",
+                });
+                updated = response.data;
+            }
+            catch (error) {
+                const { message } = parseGitHubError(error);
+                throw new Error(`Failed closing pull request #${pr.number}: [${repoRef(repo)} base=${input.baseBranch} head=${input.headBranch}] ${message}`);
+            }
+            try {
+                await octokit.issues.createComment({
+                    owner: repo.owner,
+                    repo: repo.repo,
+                    issue_number: pr.number,
+                    body: input.reason,
+                });
+            }
+            catch (error) {
+                const { status, message } = parseGitHubError(error);
+                if (status !== 404 && status !== 410) {
+                    throw new Error(`Failed commenting on closed pull request #${pr.number}: [${repoRef(repo)} base=${input.baseBranch} head=${input.headBranch}] ${message}`);
+                }
+            }
+            return {
+                closed: true,
+                number: updated.number,
+                url: updated.html_url,
+            };
+        },
         async createReleaseMetadata(input, _context) {
             const repo = getRepoFromEnv();
             const octokit = new rest_1.Octokit({ auth: getGitHubToken() });
@@ -200,6 +262,7 @@ function createGitHubPlugin() {
                     name: input.tag,
                     body: input.notes,
                     draft: input.draft ?? false,
+                    make_latest: input.makeLatest,
                 });
                 data = response.data;
             }

package/dist/scm/types.d.ts

@@ -20,11 +20,22 @@ export interface ScmReviewRequestResult {
     url: string;
     state: "open" | "closed" | "merged";
 }
+export interface ScmCloseReviewRequestInput {
+    baseBranch: string;
+    headBranch: string;
+    reason: string;
+}
+export interface ScmCloseReviewRequestResult {
+    closed: boolean;
+    number?: number;
+    url?: string;
+}
 export interface ScmReleaseMetadataInput {
     tag: string;
     version: string;
     notes: string;
     draft?: boolean;
+    makeLatest?: "true" | "false" | "legacy";
 }
 export interface ScmReleaseMetadataResult {
     url: string;
@@ -42,6 +53,7 @@ export interface ScmReleaseReferenceCommentsResult {
 export interface ScmClient {
     provider: ScmProvider;
     createOrUpdateReviewRequest: (input: ScmReviewRequestInput, context: ScmClientContext) => Promise<ScmReviewRequestResult>;
+    closeReviewRequestIfExists: (input: ScmCloseReviewRequestInput, context: ScmClientContext) => Promise<ScmCloseReviewRequestResult>;
     createReleaseMetadata: (input: ScmReleaseMetadataInput, context: ScmClientContext) => Promise<ScmReleaseMetadataResult>;
     createReleaseReferenceComments?: (input: ScmReleaseReferenceCommentsInput, context: ScmClientContext) => Promise<ScmReleaseReferenceCommentsResult>;
 }

package/dist/strategy/resolve.js

@@ -19,5 +19,10 @@ function listKnownReleaseTypes() {
 }
 function resolveVersionStrategy(config) {
     const releaseType = config["release-type"] ?? "simple";
-    return strategyRegistry[releaseType] ?? simple_js_1.simpleVersionStrategy;
+    const strategy = strategyRegistry[releaseType];
+    if (!strategy) {
+        const known = listKnownReleaseTypes().join(", ");
+        throw new Error(`Unsupported release-type "${releaseType}". Supported release types: ${known}.`);
+    }
+    return strategy;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "versionary",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "description": "Automatic release framework based on conventional commits and semantic versioning",
   "keywords": [
     "releasing",
@@ -34,9 +34,9 @@
     "zod": "^4.1.12"
   },
   "devDependencies": {
-    "@types/node": "^24.7.2",
+    "@types/node": "^25.6.0",
     "tsx": "^4.20.6",
-    "typescript": "^5.9.3",
+    "typescript": "^6.0.3",
     "vitest": "^4.1.4"
   },
   "scripts": {