versionary 0.14.1 → 0.15.0

package/dist/cli/index.js

@@ -141,6 +141,23 @@ async function main() {
             return 0;
         }
         const pr = (0, pr_js_1.prepareReleasePr)(process.cwd(), { logger });
+        if (!pr.updated) {
+            const message = `Release PR branch ${pr.branch} is already up to date.`;
+            if (flags.json) {
+                emitJson({
+                    action: "pr-up-to-date",
+                    message,
+                    releaseCreated: false,
+                    tagNames: [],
+                    branch: pr.branch,
+                    title: pr.title,
+                });
+                return 0;
+            }
+            console.log(message);
+            console.log(`Title: ${pr.title}`);
+            return 0;
+        }
         (0, pr_js_1.pushReleaseBranch)(process.cwd(), pr.branch);
         const reviewResult = await (0, pr_js_1.openOrUpdateReviewRequest)(process.cwd(), pr.branch, pr.title, pr.version, pr.previousVersion, pr.commits, pr.plan, { logger });
         const message = `Prepared release PR branch ${pr.branch}`;
@@ -196,6 +213,11 @@ async function main() {
             return 0;
         }
         const pr = (0, pr_js_1.prepareReleasePr)(process.cwd(), { logger: console });
+        if (!pr.updated) {
+            console.log(`Release PR branch ${pr.branch} is already up to date.`);
+            console.log(`Title: ${pr.title}`);
+            return 0;
+        }
         (0, pr_js_1.pushReleaseBranch)(process.cwd(), pr.branch);
         const reviewResult = await (0, pr_js_1.openOrUpdateReviewRequest)(process.cwd(), pr.branch, pr.title, pr.version, pr.previousVersion, pr.commits, pr.plan);
         console.log(`Prepared release PR branch ${pr.branch}`);

package/dist/git/commits.js

@@ -222,6 +222,27 @@ function parseFooters(body) {
             });
         }
     };
+    const extractInlineSentenceReferences = (text) => {
+        const inlineMatches = text.matchAll(/\b(close|closes|closed|fix|fixes|fixed|resolve|resolves|resolved)\b\s+((?:(?<owner>[A-Za-z0-9_.-]+)\/(?<repo>[A-Za-z0-9_.-]+))?#(?<issue>\d+)|GH-(?<ghIssue>\d+))/giu);
+        for (const match of inlineMatches) {
+            const action = match[1] ?? null;
+            const raw = match[2] ?? "";
+            const owner = match.groups?.owner ?? null;
+            const repository = match.groups?.repo ?? null;
+            const issue = match.groups?.issue ?? match.groups?.ghIssue ?? null;
+            if (!issue || !/^\d+$/u.test(issue)) {
+                continue;
+            }
+            references.push({
+                action,
+                owner,
+                repository,
+                issue,
+                raw,
+                prefix: raw.startsWith("GH-") ? "GH-" : "#",
+            });
+        }
+    };
     for (const line of footerLines) {
         const footerMatch = parseFooterLine(line);
         if (footerMatch) {
@@ -248,12 +269,19 @@ function parseFooters(body) {
         }
         extractReferences(`${footer.token}: ${footer.value}`, footer.token);
     }
+    extractInlineSentenceReferences(body);
+    const dedupedReferences = [
+        ...new Map(references.map((reference) => [
+            `${reference.action ?? ""}:${reference.owner ?? ""}/${reference.repository ?? ""}:${reference.prefix}:${reference.issue ?? ""}`,
+            reference,
+        ])).values(),
+    ];
     return {
         bodyText: bodyLines.join("\n").trim() || "",
         footerText: footerLines.length > 0 ? footerLines.join("\n").trim() : null,
         footers,
         diagnostics,
-        references,
+        references: dedupedReferences,
         notes,
     };
 }

package/dist/release/plan.d.ts

@@ -28,6 +28,7 @@ export declare function getChangelogDefaults(config: {
     "release-type"?: VersionaryConfig["release-type"];
     "changelog-file"?: VersionaryConfig["changelog-file"];
     "changelog-format"?: VersionaryConfig["changelog-format"];
+    defaultChangelogFormat?: VersionaryChangelogFormat;
 }): {
     changelogFile: string;
     changelogFormat: VersionaryChangelogFormat;

package/dist/release/plan.js

@@ -19,61 +19,56 @@ function getMode(configMode) {
 }
 function getChangelogDefaults(config) {
     const changelogFormat = config["changelog-format"] ??
-        (config["release-type"] === "r" ? "r-news" : "markdown-changelog");
+        config.defaultChangelogFormat ??
+        "markdown-changelog";
     const changelogFile = config["changelog-file"] ??
         (changelogFormat === "r-news" ? "NEWS.md" : "CHANGELOG.md");
     return { changelogFile, changelogFormat };
 }
+function getNormalizedPackages(config) {
+    const configured = Object.entries(config.packages ?? {}).map(([packagePath, packageConfig]) => ({
+        path: packagePath,
+        config: packageConfig,
+        implicitRoot: false,
+    }));
+    if (configured.length === 0) {
+        return [{ path: ".", config: {}, implicitRoot: false }];
+    }
+    if (configured.some((pkg) => pkg.path === ".")) {
+        return configured;
+    }
+    return [{ path: ".", config: {}, implicitRoot: true }, ...configured];
+}
 function createReleasePlan(cwd = process.cwd()) {
     const loaded = (0, load_config_js_1.loadConfig)(cwd);
     const strategy = (0, resolve_js_1.resolveVersionStrategy)(loaded.config);
+    const configuredPackageCount = Object.keys(loaded.config.packages ?? {}).length;
+    const hasPackages = configuredPackageCount > 0;
+    const hasExplicitRootPackage = Boolean(loaded.config.packages?.["."]);
+    const normalizedPackages = getNormalizedPackages(loaded.config);
     const versionFile = strategy.getVersionFile(loaded.config);
-    const { changelogFile, changelogFormat } = getChangelogDefaults(loaded.config);
-    const packageName = loaded.config["release-type"] === "r"
-        ? (strategy.readPackageName?.(cwd, loaded.config) ?? node_path_1.default.basename(cwd))
-        : node_path_1.default.basename(cwd);
+    const { changelogFile, changelogFormat } = getChangelogDefaults({
+        ...loaded.config,
+        defaultChangelogFormat: strategy.getDefaultChangelogFormat?.(),
+    });
+    const packageName = hasPackages
+        ? node_path_1.default.basename(cwd)
+        : (strategy.readPackageName?.(cwd, loaded.config) ?? node_path_1.default.basename(cwd));
     const releaseBranchPrefix = loaded.config["release-branch"] ?? "versionary/release";
     const baselineSha = (0, state_js_1.readBaselineSha)(cwd) ?? loaded.config["bootstrap-sha"] ?? null;
     const releaseTargetByPath = new Map((0, state_js_1.readReleaseTargets)(cwd).map((target) => [target.path, target]));
     const allowStableMajor = loaded.config["allow-stable-major"] ?? false;
-    const configuredPackages = Object.entries(loaded.config.packages ?? {}).map(([pkgPath, cfg]) => ({
-        path: pkgPath,
-        ...cfg,
-    }));
     const monorepoMode = getMode(loaded.config["monorepo-mode"]);
-    const hasPackages = configuredPackages.length > 0;
-    if (!hasPackages) {
-        const versionPath = node_path_1.default.join(cwd, versionFile);
-        if (!node_fs_1.default.existsSync(versionPath)) {
-            throw new Error(`Versionary requires ${versionFile} to exist.`);
+    const buildPackagePlan = (pkg) => {
+        const packageContext = (0, package_context_js_1.resolvePackageStrategyContext)(loaded.config, pkg.path, pkg.config);
+        const currentVersionFile = node_path_1.default.join(cwd, packageContext.versionFile);
+        if (!node_fs_1.default.existsSync(currentVersionFile)) {
+            throw new Error(`Versionary requires ${packageContext.versionFile} to exist for package "${pkg.path}".`);
         }
-        const currentVersion = strategy.readVersion(cwd, loaded.config);
-        const parsedCommits = (0, commits_js_1.getParsedCommitsSinceLastTag)(cwd, baselineSha);
-        const effectiveCommits = (0, commits_js_1.applyRevertSuppression)(parsedCommits);
-        const commits = effectiveCommits;
-        const releaseType = (0, commits_js_1.analyzeParsedCommits)(parsedCommits);
-        const nextVersion = releaseType
-            ? (0, semver_js_1.bumpVersion)(currentVersion, releaseType, { allowStableMajor })
-            : null;
-        return {
-            mode: "simple",
-            releaseType,
-            currentVersion,
-            nextVersion,
-            packageName,
-            versionFile,
-            changelogFile,
-            changelogFormat,
-            releaseBranchPrefix,
-            baselineSha,
-            commits,
-        };
-    }
-    const packagePlans = configuredPackages
-        .map((pkg) => {
-        const packageContext = (0, package_context_js_1.resolvePackageStrategyContext)(loaded.config, pkg.path, pkg);
         const packageCurrentVersion = packageContext.strategy.readVersion(cwd, packageContext.config);
-        const parsedCommits = (0, commits_js_1.getParsedCommitsForPath)(cwd, releaseTargetByPath.get(pkg.path)?.tag ?? baselineSha, pkg.path, pkg["exclude-paths"] ?? []);
+        const parsedCommits = !hasPackages && pkg.path === "."
+            ? (0, commits_js_1.getParsedCommitsSinceLastTag)(cwd, baselineSha)
+            : (0, commits_js_1.getParsedCommitsForPath)(cwd, releaseTargetByPath.get(pkg.path)?.tag ?? baselineSha, pkg.path, pkg.config["exclude-paths"] ?? []);
         const effectiveCommits = (0, commits_js_1.applyRevertSuppression)(parsedCommits);
         const commits = effectiveCommits;
         const releaseType = (0, commits_js_1.analyzeParsedCommits)(parsedCommits);
@@ -82,15 +77,36 @@ function createReleasePlan(cwd = process.cwd()) {
             : null;
         return {
             path: pkg.path,
+            implicitRoot: pkg.implicitRoot,
             releaseType,
             currentVersion: packageCurrentVersion,
             nextVersion,
             bumpReason: nextVersion ? "direct" : undefined,
             commits,
             parsedCommits,
+            resolvedVersionFile: packageContext.versionFile,
         };
-    })
-        .sort((a, b) => a.path.localeCompare(b.path));
+    };
+    const explicitPackagePlans = normalizedPackages
+        .filter((pkg) => !pkg.implicitRoot)
+        .map((pkg) => buildPackagePlan(pkg));
+    const implicitRoot = normalizedPackages.find((pkg) => pkg.implicitRoot);
+    const implicitRootPlan = implicitRoot
+        ? {
+            path: ".",
+            implicitRoot: true,
+            releaseType: null,
+            currentVersion: explicitPackagePlans[0]?.currentVersion ?? "0.0.0",
+            nextVersion: null,
+            commits: [],
+            parsedCommits: [],
+            resolvedVersionFile: versionFile,
+        }
+        : null;
+    const packagePlans = [
+        ...explicitPackagePlans,
+        ...(implicitRootPlan ? [implicitRootPlan] : []),
+    ].sort((a, b) => a.path.localeCompare(b.path));
     const packageCurrentVersionByPath = {};
     const strategyPackagesByName = new Map();
     for (const packagePlan of packagePlans) {
@@ -100,7 +116,7 @@ function createReleasePlan(cwd = process.cwd()) {
         if (existingGroup) {
             existingGroup.packages.push({
                 packagePath: packagePlan.path,
-                versionFile: packageContext.versionFile,
+                versionFile: packagePlan.resolvedVersionFile,
                 currentVersion: packagePlan.currentVersion,
                 nextVersion: packagePlan.nextVersion,
             });
@@ -111,7 +127,7 @@ function createReleasePlan(cwd = process.cwd()) {
                 packages: [
                     {
                         packagePath: packagePlan.path,
-                        versionFile: packageContext.versionFile,
+                        versionFile: packagePlan.resolvedVersionFile,
                         currentVersion: packagePlan.currentVersion,
                         nextVersion: packagePlan.nextVersion,
                     },
@@ -139,12 +155,29 @@ function createReleasePlan(cwd = process.cwd()) {
             bumpReason: "dependency-propagation",
         };
     });
+    const visiblePackages = adjustedPackages.filter((pkgPlan) => !pkgPlan.implicitRoot || hasExplicitRootPackage);
+    const rootPackagePlan = adjustedPackages.find((pkgPlan) => pkgPlan.path === ".");
+    if (!rootPackagePlan) {
+        throw new Error('Internal error: normalized package list must always include root path ".".');
+    }
+    if (!hasPackages) {
+        return {
+            mode: "simple",
+            releaseType: rootPackagePlan.releaseType,
+            currentVersion: rootPackagePlan.currentVersion,
+            nextVersion: rootPackagePlan.nextVersion,
+            packageName,
+            versionFile,
+            changelogFile,
+            changelogFormat,
+            releaseBranchPrefix,
+            baselineSha,
+            commits: rootPackagePlan.commits,
+        };
+    }
     if (monorepoMode === "fixed") {
         const fixedType = (0, commits_js_1.analyzeParsedCommits)(adjustedPackages.flatMap((pkgPlan) => pkgPlan.parsedCommits));
-        const fixedBaseVersion = adjustedPackages.find((pkgPlan) => pkgPlan.path === ".")
-            ?.currentVersion ??
-            adjustedPackages[0]?.currentVersion ??
-            "0.0.0";
+        const fixedBaseVersion = rootPackagePlan.currentVersion;
         const fixedNextVersion = fixedType
             ? (0, semver_js_1.bumpVersion)(fixedBaseVersion, fixedType, { allowStableMajor })
             : null;
@@ -165,13 +198,13 @@ function createReleasePlan(cwd = process.cwd()) {
             releaseBranchPrefix,
             baselineSha,
             commits: adjusted.flatMap((pkgPlan) => pkgPlan.commits),
-            packages: adjusted,
+            packages: adjusted
+                .filter((pkgPlan) => !pkgPlan.implicitRoot || hasExplicitRootPackage)
+                .map(({ implicitRoot: _implicitRoot, ...pkgPlan }) => pkgPlan),
         };
     }
     const overallType = (0, commits_js_1.analyzeParsedCommits)(adjustedPackages.flatMap((pkgPlan) => pkgPlan.parsedCommits));
-    const overallBaseVersion = adjustedPackages.find((pkgPlan) => pkgPlan.path === ".")?.currentVersion ??
-        adjustedPackages[0]?.currentVersion ??
-        "0.0.0";
+    const overallBaseVersion = rootPackagePlan.currentVersion;
     const overallNextVersion = overallType
         ? (0, semver_js_1.bumpVersion)(overallBaseVersion, overallType, { allowStableMajor })
         : null;
@@ -187,7 +220,7 @@ function createReleasePlan(cwd = process.cwd()) {
         releaseBranchPrefix,
         baselineSha,
         commits: adjustedPackages.flatMap((pkgPlan) => pkgPlan.commits),
-        packages: adjustedPackages,
+        packages: visiblePackages.map(({ implicitRoot: _implicitRoot, ...pkgPlan }) => pkgPlan),
     };
 }
 /** @deprecated Use createReleasePlan. */

package/dist/release/pr.d.ts

@@ -14,6 +14,7 @@ export declare function prepareReleasePr(cwd?: string, options?: {
     previousVersion: string;
     commits: ParsedCommit[];
     plan: ReleasePlan;
+    updated: boolean;
 };
 export declare function renderSimpleReviewRequestBody(version: string, previousVersion: string, commits: ParsedCommit[], plan?: SimplePlan | null, cwd?: string): string;
 export declare function openOrUpdateReviewRequest(cwd: string, branch: string, title: string, version: string, previousVersion: string, commits: ParsedCommit[], plan?: SimplePlan | null, options?: {

package/dist/release/pr.js

@@ -12,12 +12,10 @@ exports.openOrUpdateSimpleReviewRequest = openOrUpdateSimpleReviewRequest;
 exports.pushReleaseBranch = pushReleaseBranch;
 exports.isReleaseCommitMessage = isReleaseCommitMessage;
 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 package_context_js_1 = require("../strategy/package-context.js");
-const resolve_js_1 = require("../strategy/resolve.js");
 const artifact_rules_js_1 = require("./artifact-rules.js");
 const changelog_js_1 = require("./changelog.js");
 const plan_js_1 = require("./plan.js");
@@ -70,61 +68,6 @@ function ensureCleanWorktree(cwd, logger) {
         logger?.warn(`Ignoring safe tracked changes before versionary pr:\n${ignored.join("\n")}`);
     }
 }
-function normalizeSlashPath(input) {
-    return input.replaceAll("\\", "/");
-}
-function listCargoLockFiles(cwd) {
-    const lockfiles = [];
-    const queue = [cwd];
-    while (queue.length > 0) {
-        const currentDir = queue.shift();
-        if (!currentDir) {
-            continue;
-        }
-        const entries = node_fs_1.default.readdirSync(currentDir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (entry.name === ".git") {
-                continue;
-            }
-            const fullPath = node_path_1.default.join(currentDir, entry.name);
-            if (entry.isDirectory()) {
-                queue.push(fullPath);
-                continue;
-            }
-            if (!entry.isFile() || entry.name !== "Cargo.lock") {
-                continue;
-            }
-            lockfiles.push(normalizeSlashPath(node_path_1.default.relative(cwd, fullPath)));
-        }
-    }
-    return lockfiles.sort((a, b) => a.localeCompare(b));
-}
-function ensureCargoLockUpToDate(cwd) {
-    const lockfiles = listCargoLockFiles(cwd);
-    if (lockfiles.length === 0) {
-        return [];
-    }
-    const updatedLockfiles = [];
-    for (const lockfile of lockfiles) {
-        const lockfilePath = node_path_1.default.join(cwd, lockfile);
-        const before = node_fs_1.default.readFileSync(lockfilePath, "utf8");
-        try {
-            (0, node_child_process_1.execFileSync)("cargo", ["generate-lockfile"], {
-                cwd: node_path_1.default.dirname(lockfilePath),
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            throw new Error(`Failed to refresh ${lockfile} via "cargo generate-lockfile". Ensure cargo is installed and available in PATH. Details: ${message}`);
-        }
-        const after = node_fs_1.default.readFileSync(lockfilePath, "utf8");
-        if (after !== before) {
-            updatedLockfiles.push(lockfile);
-        }
-    }
-    return updatedLockfiles;
-}
 function normalizeReleaseNameForTag(releaseName) {
     return releaseName
         .trim()
@@ -132,6 +75,43 @@ function normalizeReleaseNameForTag(releaseName) {
         .replaceAll("/", "-")
         .replace(/\s+/gu, "-");
 }
+function getCommitTreeSha(cwd, revision) {
+    return (0, node_child_process_1.execFileSync)("git", ["rev-parse", `${revision}^{tree}`], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+}
+function hasOriginRemote(cwd) {
+    const remotes = (0, node_child_process_1.execFileSync)("git", ["remote"], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    })
+        .split("\n")
+        .map((remote) => remote.trim())
+        .filter((remote) => remote.length > 0);
+    return remotes.includes("origin");
+}
+function remoteReleaseBranchExists(cwd, branch) {
+    if (!hasOriginRemote(cwd)) {
+        return false;
+    }
+    const output = (0, node_child_process_1.execFileSync)("git", ["ls-remote", "--heads", "origin", branch], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    return output.length > 0;
+}
+function fetchRemoteReleaseBranch(cwd, branch) {
+    const remoteRef = `refs/remotes/origin/${branch}`;
+    (0, node_child_process_1.execFileSync)("git", ["fetch", "--no-tags", "origin", `refs/heads/${branch}:${remoteRef}`], {
+        cwd,
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+    return remoteRef;
+}
 function resolveReleaseName(cwd, packagePath, packageConfig, strategy, strategyConfig) {
     const configuredName = packageConfig["package-name"]?.trim();
     if (configuredName) {
@@ -207,7 +187,6 @@ function formatReleaseCommitTitle(releaseTargets) {
 function prepareReleasePr(cwd = process.cwd(), options = {}) {
     const plan = (0, plan_js_1.createReleasePlan)(cwd);
     const loaded = (0, load_config_js_1.loadConfig)(cwd);
-    const strategy = (0, resolve_js_1.resolveVersionStrategy)(loaded.config);
     if (!plan.nextVersion) {
         throw new Error("No releasable commits found. Nothing to open a release PR for.");
     }
@@ -225,35 +204,35 @@ function prepareReleasePr(cwd = process.cwd(), options = {}) {
             writes: [write],
         });
     };
-    if (plan.packages && plan.packages.length > 0) {
-        for (const packagePlan of plan.packages) {
-            if (!packagePlan.nextVersion) {
-                continue;
-            }
-            const packageConfig = loaded.config.packages?.[packagePlan.path] ?? {};
-            const packageContext = (0, package_context_js_1.resolvePackageStrategyContext)(loaded.config, packagePlan.path, packageConfig);
-            const packageUpdated = packageContext.strategy.writeVersion(cwd, packageContext.config, packagePlan.nextVersion);
-            updatedVersionFiles.push(...packageUpdated);
-            addStrategyWrite(packageContext.strategy, {
-                packagePath: packagePlan.path,
-                versionFile: packageContext.versionFile,
-                version: packagePlan.nextVersion,
-            });
+    const versionTargets = plan.packages && plan.packages.length > 0
+        ? plan.packages
+        : [
+            {
+                path: ".",
+                releaseType: plan.releaseType,
+                currentVersion: plan.currentVersion,
+                nextVersion: plan.nextVersion,
+                commits: plan.commits,
+            },
+        ];
+    for (const packagePlan of versionTargets) {
+        if (!packagePlan.nextVersion) {
+            continue;
         }
-    }
-    else {
-        updatedVersionFiles.push(...strategy.writeVersion(cwd, loaded.config, plan.nextVersion));
-        addStrategyWrite(strategy, {
-            packagePath: ".",
-            versionFile: strategy.getVersionFile(loaded.config),
-            version: plan.nextVersion,
+        const packageConfig = loaded.config.packages?.[packagePlan.path] ?? {};
+        const packageContext = (0, package_context_js_1.resolvePackageStrategyContext)(loaded.config, packagePlan.path, packageConfig);
+        const packageUpdated = packageContext.strategy.writeVersion(cwd, packageContext.config, packagePlan.nextVersion);
+        updatedVersionFiles.push(...packageUpdated);
+        addStrategyWrite(packageContext.strategy, {
+            packagePath: packagePlan.path,
+            versionFile: packageContext.versionFile,
+            version: packagePlan.nextVersion,
         });
     }
     for (const strategyGroup of writesByStrategy.values()) {
         updatedVersionFiles.push(...(strategyGroup.strategy.finalizeVersionWrites?.(cwd, strategyGroup.writes) ?? []));
     }
     const updatedArtifactFiles = (0, artifact_rules_js_1.applyConfiguredArtifactRules)(cwd, loaded.config, plan);
-    const updatedRustLockFiles = ensureCargoLockUpToDate(cwd);
     const packageReleaseMetadata = buildPackageReleaseMetadata(cwd, plan, loaded.config);
     const section = (0, changelog_js_1.renderReleasePlanChangelog)(plan);
     (0, changelog_js_1.prependChangelog)(cwd, plan.changelogFile, section, plan.changelogFormat);
@@ -263,10 +242,12 @@ function prepareReleasePr(cwd = process.cwd(), options = {}) {
             continue;
         }
         const packageConfig = loaded.config.packages?.[packagePlan.path] ?? {};
+        const packageContext = (0, package_context_js_1.resolvePackageStrategyContext)(loaded.config, packagePlan.path, packageConfig);
         const { changelogFile: packageChangelogFile } = (0, plan_js_1.getChangelogDefaults)({
             "release-type": packageConfig["release-type"] ?? loaded.config["release-type"],
             "changelog-file": packageConfig["changelog-file"] ?? loaded.config["changelog-file"],
             "changelog-format": packageConfig["changelog-format"] ?? loaded.config["changelog-format"],
+            defaultChangelogFormat: packageContext.strategy.getDefaultChangelogFormat?.(),
         });
         const packageMetadata = packageReleaseMetadata[packagePlan.path];
         if (!packageMetadata) {
@@ -285,6 +266,15 @@ function prepareReleasePr(cwd = process.cwd(), options = {}) {
     const releaseTargets = buildReleaseTargets(cwd, plan, loaded.config);
     const branch = plan.releaseBranchPrefix;
     const title = formatReleaseCommitTitle(releaseTargets);
+    const releaseBaselineSha = (0, node_child_process_1.execFileSync)("git", ["rev-parse", "HEAD"], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    const hasRemoteReleaseBranch = remoteReleaseBranchExists(cwd, branch);
+    const remoteReleaseRef = hasRemoteReleaseBranch
+        ? fetchRemoteReleaseBranch(cwd, branch)
+        : null;
     (0, node_child_process_1.execFileSync)("git", ["checkout", "-B", branch], {
         cwd,
         stdio: ["ignore", "pipe", "ignore"],
@@ -293,7 +283,6 @@ function prepareReleasePr(cwd = process.cwd(), options = {}) {
         ...new Set([
             ...updatedVersionFiles,
             ...updatedArtifactFiles,
-            ...updatedRustLockFiles,
             ...updatedChangelogFiles,
         ]),
     ];
@@ -305,7 +294,7 @@ function prepareReleasePr(cwd = process.cwd(), options = {}) {
         cwd,
         stdio: ["ignore", "pipe", "ignore"],
     });
-    (0, state_js_1.writeBaselineSha)(cwd, undefined, releaseTargets);
+    (0, state_js_1.writeBaselineSha)(cwd, releaseBaselineSha, releaseTargets);
     (0, node_child_process_1.execFileSync)("git", ["add", (0, state_js_1.getBaselineStatePath)(cwd)], {
         cwd,
         stdio: ["ignore", "pipe", "ignore"],
@@ -314,6 +303,8 @@ function prepareReleasePr(cwd = process.cwd(), options = {}) {
         cwd,
         stdio: ["ignore", "pipe", "ignore"],
     });
+    const updated = !remoteReleaseRef ||
+        getCommitTreeSha(cwd, "HEAD") !== getCommitTreeSha(cwd, remoteReleaseRef);
     return {
         branch,
         title,
@@ -321,6 +312,7 @@ function prepareReleasePr(cwd = process.cwd(), options = {}) {
         previousVersion: plan.currentVersion,
         commits: plan.commits,
         plan,
+        updated,
     };
 }
 function renderSimpleReviewRequestBody(version, previousVersion, commits, plan = null, cwd = process.cwd()) {

package/dist/release/release.js

@@ -99,19 +99,29 @@ function resolveTargetChangelogFile(config, rootChangelogFile, targetPath) {
         return rootChangelogFile;
     }
     const packageConfig = config.packages?.[targetPath];
+    const packageStrategy = (0, resolve_js_1.resolveVersionStrategy)({
+        ...config,
+        "release-type": packageConfig?.["release-type"] ?? config["release-type"],
+    });
     const { changelogFile: packageChangelogFile } = (0, plan_js_1.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);
 }
 function resolveTargetChangelogFormat(config, targetPath) {
-    const packageConfig = targetPath === "." ? undefined : config.packages?.[targetPath];
+    const packageConfig = config.packages?.[targetPath];
+    const packageStrategy = (0, resolve_js_1.resolveVersionStrategy)({
+        ...config,
+        "release-type": packageConfig?.["release-type"] ?? config["release-type"],
+    });
     const { changelogFormat } = (0, plan_js_1.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 changelogFormat;
 }
@@ -132,7 +142,10 @@ async function runReleaseDetailed(cwd = process.cwd(), options = {}) {
     }
     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)(loaded.config);
+    const { changelogFile } = (0, plan_js_1.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}`;

package/dist/release/verify-project.js

@@ -30,6 +30,18 @@ function verifyProject(cwd = process.cwd()) {
             ? undefined
             : `Create ${versionFile} or set "version-file" to the correct path for your release strategy.`,
     });
+    if (exists) {
+        const validationError = strategy.validateProject?.(cwd, config.config);
+        checks.push({
+            name: `strategy-validate:${strategy.name}`,
+            ok: !validationError,
+            details: validationError ?? "Strategy-level validation passed",
+            category: "version-files",
+            remediation: validationError
+                ? `Fix strategy-specific version metadata in ${versionFile} for release-type "${strategy.name}".`
+                : undefined,
+        });
+    }
     if (config.config.packages) {
         for (const [pkgPathRaw, packageConfig] of Object.entries(config.config.packages)) {
             const pkgPath = node_path_1.default.join(cwd, pkgPathRaw);
@@ -58,6 +70,18 @@ function verifyProject(cwd = process.cwd()) {
                         ? undefined
                         : `Create ${packageVersionFile} or adjust package release settings ("release-type"/"version-file") for ${pkgPathRaw}.`,
                 });
+                if (packageVersionExists) {
+                    const packageValidationError = packageContext.strategy.validateProject?.(cwd, packageContext.config);
+                    checks.push({
+                        name: `strategy-validate:${packageContext.strategy.name}:${pkgPathRaw}`,
+                        ok: !packageValidationError,
+                        details: packageValidationError ?? "Strategy-level validation passed",
+                        category: "version-files",
+                        remediation: packageValidationError
+                            ? `Fix strategy-specific version metadata in ${packageVersionFile} for package "${pkgPathRaw}".`
+                            : undefined,
+                    });
+                }
             }
         }
     }

package/dist/strategy/r.js

@@ -21,9 +21,26 @@ function writeDescriptionVersion(content, versionFile, version) {
 }
 exports.rVersionStrategy = {
     name: "r",
+    getDefaultChangelogFormat() {
+        return "r-news";
+    },
     getVersionFile(config) {
         return config["version-file"] ?? "DESCRIPTION";
     },
+    validateProject(cwd, config) {
+        const versionFile = this.getVersionFile(config);
+        const versionPath = node_path_1.default.join(cwd, versionFile);
+        if (!node_fs_1.default.existsSync(versionPath)) {
+            return null;
+        }
+        try {
+            readDescriptionVersion(node_fs_1.default.readFileSync(versionPath, "utf8"), versionFile);
+            return null;
+        }
+        catch (error) {
+            return error instanceof Error ? error.message : String(error);
+        }
+    },
     readVersion(cwd, config) {
         const versionFile = this.getVersionFile(config);
         const versionPath = node_path_1.default.join(cwd, versionFile);

package/dist/strategy/rust.js

@@ -7,6 +7,7 @@ exports.rustVersionStrategy = void 0;
 exports.applyRustWorkspaceDependencyUpdates = applyRustWorkspaceDependencyUpdates;
 exports.detectRustDependencyImpact = detectRustDependencyImpact;
 exports.toCargoManifestPath = toCargoManifestPath;
+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 toml_1 = __importDefault(require("@iarna/toml"));
@@ -96,6 +97,58 @@ function collectAllCrateManifests(cwd) {
     }
     return manifests.sort((a, b) => a.localeCompare(b));
 }
+function listCargoLockFiles(cwd) {
+    const lockfiles = [];
+    const queue = [cwd];
+    while (queue.length > 0) {
+        const currentDir = queue.shift();
+        if (!currentDir) {
+            continue;
+        }
+        const entries = node_fs_1.default.readdirSync(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name === ".git") {
+                continue;
+            }
+            const fullPath = node_path_1.default.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                queue.push(fullPath);
+                continue;
+            }
+            if (!entry.isFile() || entry.name !== "Cargo.lock") {
+                continue;
+            }
+            lockfiles.push(normalizeSlashPath(node_path_1.default.relative(cwd, fullPath)));
+        }
+    }
+    return lockfiles.sort((a, b) => a.localeCompare(b));
+}
+function ensureCargoLockUpToDate(cwd) {
+    const lockfiles = listCargoLockFiles(cwd);
+    if (lockfiles.length === 0) {
+        return [];
+    }
+    const updatedLockfiles = [];
+    for (const lockfile of lockfiles) {
+        const lockfilePath = node_path_1.default.join(cwd, lockfile);
+        const before = node_fs_1.default.readFileSync(lockfilePath, "utf8");
+        try {
+            (0, node_child_process_1.execFileSync)("cargo", ["generate-lockfile"], {
+                cwd: node_path_1.default.dirname(lockfilePath),
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to refresh ${lockfile} via "cargo generate-lockfile". Ensure cargo is installed and available in PATH. Details: ${message}`);
+        }
+        const after = node_fs_1.default.readFileSync(lockfilePath, "utf8");
+        if (after !== before) {
+            updatedLockfiles.push(lockfile);
+        }
+    }
+    return updatedLockfiles;
+}
 function parseCargoManifest(versionFile, cargoTomlRaw) {
     let parsed;
     try {
@@ -556,6 +609,26 @@ exports.rustVersionStrategy = {
         const cargoTomlRaw = node_fs_1.default.readFileSync(node_path_1.default.join(cwd, selectedManifest), "utf8");
         return readResolvedCargoVersion(cwd, selectedManifest, cargoTomlRaw);
     },
+    validateProject(cwd, config) {
+        try {
+            const versionFile = this.getVersionFile(config);
+            const manifests = collectRustTargetManifests(cwd, versionFile, !config.packages);
+            const selectedManifest = manifests[0];
+            if (!selectedManifest) {
+                return null;
+            }
+            const versionPath = node_path_1.default.join(cwd, selectedManifest);
+            if (!node_fs_1.default.existsSync(versionPath)) {
+                return null;
+            }
+            const cargoTomlRaw = node_fs_1.default.readFileSync(versionPath, "utf8");
+            readResolvedCargoVersion(cwd, selectedManifest, cargoTomlRaw);
+            return null;
+        }
+        catch (error) {
+            return error instanceof Error ? error.message : String(error);
+        }
+    },
     writeVersion(cwd, config, version) {
         const versionFile = this.getVersionFile(config);
         const manifests = collectRustTargetManifests(cwd, versionFile, !config.packages);
@@ -653,6 +726,9 @@ exports.rustVersionStrategy = {
         for (const write of writes) {
             manifestToVersion[write.versionFile] = write.version;
         }
-        return applyRustWorkspaceDependencyUpdates(cwd, manifestToVersion);
+        return [
+            ...applyRustWorkspaceDependencyUpdates(cwd, manifestToVersion),
+            ...ensureCargoLockUpToDate(cwd),
+        ];
     },
 };

package/dist/strategy/types.d.ts

@@ -1,4 +1,4 @@
-import type { VersionaryConfig } from "../types/config.js";
+import type { VersionaryChangelogFormat, VersionaryConfig } from "../types/config.js";
 export interface StrategyPackagePlanContext {
     packagePath: string;
     versionFile: string;
@@ -13,8 +13,10 @@ export interface StrategyVersionWriteContext {
 export interface VersionStrategy {
     name: string;
     getVersionFile(config: VersionaryConfig): string;
+    getDefaultChangelogFormat?(): VersionaryChangelogFormat;
     readVersion(cwd: string, config: VersionaryConfig): string;
     writeVersion(cwd: string, config: VersionaryConfig, version: string): string[];
+    validateProject?(cwd: string, config: VersionaryConfig): string | null;
     readPackageName?(cwd: string, config: VersionaryConfig): string | null;
     propagateDependentPatchImpacts?(cwd: string, packages: StrategyPackagePlanContext[]): string[];
     finalizeVersionWrites?(cwd: string, writes: StrategyVersionWriteContext[]): string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "versionary",
-  "version": "0.14.1",
+  "version": "0.15.0",
   "description": "Automatic release framework based on conventional commits and semantic versioning",
   "keywords": [
     "releasing",