versionary 0.17.0 → 0.19.0

package/dist/action/index.js

@@ -36,6 +36,20 @@ function hasOriginRemote(cwd) {
         return false;
     }
 }
+function getRemoteRefSha(cwd, ref) {
+    try {
+        const output = runGit(cwd, ["ls-remote", "origin", ref]);
+        const line = output.split("\n")[0]?.trim() ?? "";
+        if (!line) {
+            return null;
+        }
+        const sha = line.split(/\s+/u)[0]?.trim() ?? "";
+        return sha.length > 0 ? sha : null;
+    }
+    catch {
+        return null;
+    }
+}
 function setOutput(name, value) {
     const outputPath = process.env.GITHUB_OUTPUT;
     if (!outputPath) {
@@ -77,6 +91,35 @@ function main() {
             `https://x-access-token:${encodedToken}@${base}/${repository}.git`,
         ]);
     }
+    const eventName = process.env.GITHUB_EVENT_NAME ?? "";
+    const ref = process.env.GITHUB_REF ?? "";
+    const sha = process.env.GITHUB_SHA?.trim() ?? "";
+    if (eventName === "push" &&
+        ref.startsWith("refs/heads/") &&
+        sha.length > 0 &&
+        hasOriginRemote(cwd)) {
+        const remoteSha = getRemoteRefSha(cwd, ref);
+        if (remoteSha && remoteSha !== sha) {
+            const staleMessage = `Skipping stale push run for ${sha.slice(0, 7)}; ` +
+                `${ref} now points to ${remoteSha.slice(0, 7)}.`;
+            const stalePayload = {
+                action: "stale-run-skipped",
+                message: staleMessage,
+                releaseCreated: false,
+                tagNames: [],
+            };
+            process.stdout.write(`${JSON.stringify(stalePayload)}\n`);
+            setOutput("action", stalePayload.action);
+            setOutput("message", stalePayload.message);
+            setOutput("release_created", "false");
+            setOutput("tag_name", "");
+            setOutput("tag_names", "[]");
+            setOutput("review_url", "");
+            setOutput("branch", "");
+            setOutput("title", "");
+            return;
+        }
+    }
     const raw = (0, node_child_process_1.execFileSync)("npx", ["--yes", `versionary@${versionaryVersion}`, "run", "--json"], {
         cwd,
         encoding: "utf8",

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/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.js

@@ -77,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()
@@ -99,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;

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;
@@ -408,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/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() });

package/dist/scm/types.d.ts

@@ -20,6 +20,16 @@ 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;
@@ -43,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/latex.js

@@ -8,6 +8,7 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const BUILD_LUA_VERSION_PATTERN = /^(\s*version\s*=\s*")([^"]+)(")/mu;
 const PROVIDES_PACKAGE_PATTERN = /\\ProvidesPackage\{([^}]+)\}\[\d{4}-\d{2}-\d{2} v([0-9]+\.[0-9]+\.[0-9]+) ([^\]]+)\]/gu;
+const PROVIDES_EXPL_PACKAGE_PATTERN = /\\ProvidesExplPackage\{([^}]+)\}\{\d{4}-\d{2}-\d{2}\}\{[^}]+\}\{([^}]*)\}/gu;
 function normalizeRelative(base, target) {
     return node_path_1.default.relative(base, target).replaceAll("\\", "/");
 }
@@ -37,9 +38,16 @@ function replaceBuildLuaVersion(content, version, versionFile) {
     return content.replace(BUILD_LUA_VERSION_PATTERN, `$1${version}$3`);
 }
 function replaceProvidesPackageMetadata(content, version, releaseDate, relativePath) {
-    const matches = [...content.matchAll(PROVIDES_PACKAGE_PATTERN)];
+    const packageMatches = [...content.matchAll(PROVIDES_PACKAGE_PATTERN)];
+    const explPackageMatches = [
+        ...content.matchAll(PROVIDES_EXPL_PACKAGE_PATTERN),
+    ];
+    const matches = [...packageMatches, ...explPackageMatches];
     if (matches.length !== 1) {
-        throw new Error(`${relativePath} must contain exactly one \\ProvidesPackage metadata entry; matched ${matches.length}.`);
+        throw new Error(`${relativePath} must contain exactly one \\ProvidesPackage or \\ProvidesExplPackage metadata entry; matched ${matches.length}.`);
+    }
+    if (explPackageMatches.length === 1) {
+        return content.replace(PROVIDES_EXPL_PACKAGE_PATTERN, (_full, pkg, desc) => `\\ProvidesExplPackage{${pkg}}{${releaseDate}}{${version}}{${desc}}`);
     }
     return content.replace(PROVIDES_PACKAGE_PATTERN, (_full, pkg, _prevVersion, desc) => `\\ProvidesPackage{${pkg}}[${releaseDate} v${version} ${desc}]`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "versionary",
-  "version": "0.17.0",
+  "version": "0.19.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": {