versionary 1.3.0 → 1.4.1

package/dist/action/index.js

@@ -1,6 +1,6 @@
 import { execFileSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { appendFileSync } from "node:fs";
+import { appendFileSync, readFileSync } from "node:fs";
 function getInput(name) {
     const canonical = `INPUT_${name.replace(/ /g, "_").toUpperCase()}`;
     const underscoreAlias = canonical.replace(/-/g, "_");
@@ -74,9 +74,41 @@ function setOutput(name, value) {
     const delimiter = `versionary-${randomUUID()}`;
     appendFileSync(outputPath, `${name}<<${delimiter}\n${value}\n${delimiter}\n`, "utf8");
 }
+function isForkRepository() {
+    const eventPath = process.env.GITHUB_EVENT_PATH;
+    if (!eventPath) {
+        return false;
+    }
+    try {
+        const event = JSON.parse(readFileSync(eventPath, "utf8"));
+        return event?.repository?.fork === true;
+    }
+    catch {
+        // Only a confirmed fork may bypass the token requirement.
+        return false;
+    }
+}
+function skipRun(action, message) {
+    const payload = { action, message, releaseCreated: false, tagNames: [] };
+    process.stdout.write(`${JSON.stringify(payload)}\n`);
+    setOutput("action", action);
+    setOutput("message", message);
+    setOutput("release_created", "false");
+    setOutput("tag_name", "");
+    setOutput("tag_names", "[]");
+    setOutput("release_targets", "[]");
+    setOutput("review_url", "");
+    setOutput("review_requests", "[]");
+    setOutput("branch", "");
+    setOutput("title", "");
+}
 function main() {
     const token = getInput("token");
     if (!token) {
+        if (isForkRepository()) {
+            skipRun("fork-skipped", "Skipping release automation in a fork without a release token.");
+            return;
+        }
         throw new Error("Input required and not supplied: token.");
     }
     const versionaryVersion = getInput("versionary-version") || "0.7.0";
@@ -120,25 +152,8 @@ function main() {
             // recovery cycle.
             const releaseCanPublish = hasVersionaryReleaseMarker(cwd, sha) && isAncestor(cwd, sha, remoteSha);
             if (!releaseCanPublish) {
-                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("release_targets", "[]");
-                setOutput("review_url", "");
-                setOutput("review_requests", "[]");
-                setOutput("branch", "");
-                setOutput("title", "");
+                skipRun("stale-run-skipped", `Skipping stale push run for ${sha.slice(0, 7)}; ` +
+                    `${ref} now points to ${remoteSha.slice(0, 7)}.`);
                 return;
             }
         }

package/dist/cli/index.js

@@ -2,6 +2,7 @@
 import { execFileSync } from "node:child_process";
 import { loadConfig } from "../config/load-config.js";
 import { prependChangelog, renderReleasePlanChangelog, } from "../release/changelog.js";
+import { runDirectRelease } from "../release/direct.js";
 import { createReleasePlan } from "../release/plan.js";
 import { closeStaleReviewRequestIfExists, isReleaseCommitMessage, openOrUpdateReviewRequest, preparePendingReleasePr, preparePendingSeparateReleasePrs, prepareReleasePr, prepareSeparateReleasePrs, pushReleaseBranch, reconcileSeparateReviewRequests, resolveReleaseHighlights, } from "../release/pr.js";
 import { runRelease, runReleaseDetailed } from "../release/release.js";
@@ -194,6 +195,36 @@ async function main() {
     const flags = parseFlags(args);
     const logger = flags.json ? undefined : console;
     if (!command || command === "run") {
+        if (loadConfig(process.cwd()).config["review-mode"] === "direct") {
+            const release = await runDirectRelease(process.cwd(), {
+                logger,
+                "dry-run": flags["dry-run"],
+            });
+            const message = release.action === "release-skipped" ? release.reason : release.message;
+            if (flags.json) {
+                emitJson({
+                    action: release.action,
+                    message,
+                    releaseCreated: release.action === "release-published" &&
+                        release.releases.length > 0,
+                    tagNames: release.action === "release-published"
+                        ? release.releases.map((target) => target.tag)
+                        : release.action === "release-dry-run"
+                            ? release.targets.map((target) => target.tag)
+                            : [],
+                    ...("releaseTargets" in release
+                        ? { releaseTargets: release.releaseTargets }
+                        : {}),
+                    ...(release.action === "release-dry-run"
+                        ? { targets: release.targets }
+                        : {}),
+                });
+            }
+            else {
+                console.log(message);
+            }
+            return 0;
+        }
         const commitMessage = execFileSync("git", ["log", "-1", "--pretty=%B"], {
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"],

package/dist/config/load-config.js

@@ -7,6 +7,7 @@ const SUPPORTED_FILES = [
     { file: "versionary.jsonc", format: "jsonc" },
     { file: "versionary.json", format: "json" },
 ];
+const warnedDeprecatedConfigPaths = new Set();
 function parseConfig(raw, format) {
     if (format === "json" || format === "jsonc") {
         return parseJsonc(raw);
@@ -16,6 +17,43 @@ function parseConfig(raw, format) {
 function isRecord(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+function normalizeConfig(config) {
+    const { "bump-minor-pre-major": rootBumpMinorPreMajor, packages, ...rootConfig } = config;
+    let usedDeprecatedPreMajorKey = rootBumpMinorPreMajor !== undefined;
+    const normalizedPackages = packages
+        ? Object.fromEntries(Object.entries(packages).map(([packagePath, packageConfig]) => {
+            const { "bump-minor-pre-major": packageBumpMinorPreMajor, ...canonicalPackageConfig } = packageConfig;
+            usedDeprecatedPreMajorKey ||= packageBumpMinorPreMajor !== undefined;
+            return [
+                packagePath,
+                {
+                    ...canonicalPackageConfig,
+                    ...(packageBumpMinorPreMajor === undefined
+                        ? {}
+                        : { "allow-stable-major": !packageBumpMinorPreMajor }),
+                },
+            ];
+        }))
+        : undefined;
+    return {
+        config: {
+            ...rootConfig,
+            ...(rootBumpMinorPreMajor === undefined
+                ? {}
+                : { "allow-stable-major": !rootBumpMinorPreMajor }),
+            ...(normalizedPackages ? { packages: normalizedPackages } : {}),
+        },
+        usedDeprecatedPreMajorKey,
+    };
+}
+function warnForDeprecatedConfig(path) {
+    // Release commands can load the same configuration in several stages.
+    if (warnedDeprecatedConfigPaths.has(path)) {
+        return;
+    }
+    warnedDeprecatedConfigPaths.add(path);
+    console.warn('Warning: "bump-minor-pre-major" is deprecated; use "allow-stable-major" with the inverse value instead.');
+}
 function validateReleaseTypes(config) {
     try {
         resolveVersionStrategy(config);
@@ -67,10 +105,14 @@ export function loadConfig(cwd = process.cwd()) {
         throw new Error('The "plugins" config key is no longer supported. Versionary uses built-in integrations only.');
     }
     const validated = configSchema.parse(parsed);
-    validateReleaseTypes(validated);
+    const normalized = normalizeConfig(validated);
+    if (normalized.usedDeprecatedPreMajorKey) {
+        warnForDeprecatedConfig(found.path);
+    }
+    validateReleaseTypes(normalized.config);
     return {
         path: found.path,
         format: found.format,
-        config: validated,
+        config: normalized.config,
     };
 }

package/dist/config/schema.d.ts

@@ -39,6 +39,7 @@ export declare const configSchema: z.ZodObject<{
             "markdown-changelog": "markdown-changelog";
             "r-news": "r-news";
         }>>;
+        "release-draft": z.ZodOptional<z.ZodBoolean>;
         "bump-minor-pre-major": z.ZodOptional<z.ZodBoolean>;
         "allow-stable-major": z.ZodOptional<z.ZodBoolean>;
         "exclude-paths": z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/config/schema.js

@@ -56,6 +56,10 @@ const artifactRuleSchema = z
         });
     }
 });
+const deprecatedBumpMinorPreMajorSchema = z.boolean().optional().meta({
+    deprecated: true,
+    description: 'Deprecated. Use "allow-stable-major" with the inverse value instead.',
+});
 const packageSchema = z
     .object({
     "release-type": z
@@ -64,7 +68,8 @@ const packageSchema = z
     "package-name": z.string().optional(),
     "changelog-file": z.string().optional(),
     "changelog-format": z.enum(["markdown-changelog", "r-news"]).optional(),
-    "bump-minor-pre-major": z.boolean().optional(),
+    "release-draft": z.boolean().optional(),
+    "bump-minor-pre-major": deprecatedBumpMinorPreMajorSchema,
     "allow-stable-major": z.boolean().optional(),
     "exclude-paths": z.array(z.string()).optional(),
     "extra-files": z.array(artifactRuleSchema).optional(),
@@ -98,7 +103,7 @@ export const configSchema = z
     "baseline-file": z.string().optional(),
     "bootstrap-sha": z.string().optional(),
     "monorepo-mode": z.enum(["independent", "fixed"]).optional(),
-    "bump-minor-pre-major": z.boolean().optional(),
+    "bump-minor-pre-major": deprecatedBumpMinorPreMajorSchema,
     "allow-stable-major": z.boolean().optional(),
     "include-commit-authors": z.boolean().optional(),
     "exclude-paths": z.array(z.string()).optional(),

package/dist/release/direct.d.ts

@@ -0,0 +1,5 @@
+import { type RunReleaseOptions, type RunReleaseResult } from "./release.js";
+export declare function runDirectRelease(cwd?: string, options?: RunReleaseOptions): Promise<RunReleaseResult | {
+    action: "noop";
+    message: string;
+}>;

package/dist/release/direct.js

@@ -0,0 +1,80 @@
+import { execFileSync } from "node:child_process";
+import { loadConfig } from "../config/load-config.js";
+import { createReleasePlan } from "./plan.js";
+import { buildReleaseTargets, isReleaseCommitMessage, preparePendingReleasePr, prepareReleasePr, } from "./pr.js";
+import { runReleaseDetailed, } from "./release.js";
+import { hasFullyUntaggedPendingRelease, hasReleaseStateChangeAtHead, readPendingReleaseTargets, } from "./state.js";
+import { releaseTargetHandoff } from "./targets.js";
+function git(cwd, ...args) {
+    return execFileSync("git", args, {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+}
+function resolveDirectBranch(cwd) {
+    const ref = process.env.GITHUB_REF ?? "";
+    const branch = process.env.VERSIONARY_BASE_BRANCH ||
+        (ref.startsWith("refs/heads/") ? ref.slice("refs/heads/".length) : "") ||
+        git(cwd, "branch", "--show-current");
+    if (!branch) {
+        throw new Error("Direct releases require a branch. Check out the release base branch or set VERSIONARY_BASE_BRANCH.");
+    }
+    git(cwd, "check-ref-format", `refs/heads/${branch}`);
+    return branch;
+}
+function pushDirectRelease(cwd, branch) {
+    git(cwd, "fetch", "origin", `refs/heads/${branch}`);
+    try {
+        // An earlier release may finish after a newer commit has reached trunk.
+        git(cwd, "merge-base", "--is-ancestor", "HEAD", "FETCH_HEAD");
+        return;
+    }
+    catch {
+        // A normal push rejects concurrent divergent updates without rewriting trunk.
+    }
+    try {
+        git(cwd, "push", "origin", `HEAD:refs/heads/${branch}`);
+    }
+    catch (error) {
+        throw new Error(`Failed pushing direct release commit to ${branch}; no release was published. Check branch permissions and whether the branch advanced, then retry.`, { cause: error });
+    }
+}
+export async function runDirectRelease(cwd = process.cwd(), options = {}) {
+    const releaseContext = isReleaseCommitMessage(git(cwd, "log", "-1", "--pretty=%B")) ||
+        hasReleaseStateChangeAtHead(cwd);
+    if (!releaseContext) {
+        const pending = hasFullyUntaggedPendingRelease(cwd);
+        const plan = pending ? undefined : createReleasePlan(cwd);
+        if (plan && !plan.nextVersion) {
+            return {
+                action: "noop",
+                message: "No releasable commits found. Nothing to do.",
+            };
+        }
+        if (options["dry-run"]) {
+            const targets = plan
+                ? buildReleaseTargets(cwd, plan, loadConfig(cwd).config)
+                : readPendingReleaseTargets(cwd);
+            return {
+                action: "release-dry-run",
+                message: `Dry run: would ${pending ? "recover and publish" : "prepare and publish"} releases ${targets.map((target) => target.tag).join(", ")}`,
+                targets: targets.map(({ tag, version }) => ({ tag, version })),
+                releaseTargets: releaseTargetHandoff(targets, options.logger),
+            };
+        }
+        const branch = resolveDirectBranch(cwd);
+        if (pending) {
+            preparePendingReleasePr(cwd, { logger: options.logger, branch });
+        }
+        else {
+            prepareReleasePr(cwd, { logger: options.logger, branch });
+        }
+        pushDirectRelease(cwd, branch);
+    }
+    else if (!options["dry-run"]) {
+        // A retry may start at a release commit whose previous branch push failed.
+        pushDirectRelease(cwd, resolveDirectBranch(cwd));
+    }
+    return runReleaseDetailed(cwd, options);
+}

package/dist/release/plan.js

@@ -10,20 +10,11 @@ import { readBaselineSha, readReleaseTargets } from "./state.js";
 function getMode(configMode) {
     return configMode ?? "independent";
 }
-function resolveBumpMinorPreMajor(config, packageConfig) {
-    if (packageConfig?.["bump-minor-pre-major"] !== undefined) {
-        return packageConfig["bump-minor-pre-major"];
-    }
+function resolveAllowStableMajor(config, packageConfig) {
     if (packageConfig?.["allow-stable-major"] !== undefined) {
-        return !packageConfig["allow-stable-major"];
-    }
-    if (config["bump-minor-pre-major"] !== undefined) {
-        return config["bump-minor-pre-major"];
-    }
-    if (config["allow-stable-major"] !== undefined) {
-        return !config["allow-stable-major"];
+        return packageConfig["allow-stable-major"];
     }
-    return true;
+    return config["allow-stable-major"] ?? false;
 }
 export function getChangelogDefaults(config) {
     const changelogFormat = config["changelog-format"] ??
@@ -65,8 +56,8 @@ export function createReleasePlan(cwd = process.cwd()) {
     const releaseBranchPrefix = loaded.config["release-branch"] ?? "versionary/release";
     const baselineSha = readBaselineSha(cwd) ?? loaded.config["bootstrap-sha"] ?? null;
     const releaseTargetByPath = new Map(readReleaseTargets(cwd).map((target) => [target.path, target]));
-    const bumpMinorPreMajor = resolveBumpMinorPreMajor(loaded.config);
-    const bumpMinorPreMajorForPath = (packagePath) => resolveBumpMinorPreMajor(loaded.config, loaded.config.packages?.[packagePath]);
+    const allowStableMajor = resolveAllowStableMajor(loaded.config);
+    const allowStableMajorForPath = (packagePath) => resolveAllowStableMajor(loaded.config, loaded.config.packages?.[packagePath]);
     const monorepoMode = getMode(loaded.config["monorepo-mode"]);
     const buildPackagePlan = (pkg) => {
         const packageContext = resolvePackageStrategyContext(loaded.config, pkg.path, pkg.config);
@@ -109,7 +100,7 @@ export function createReleasePlan(cwd = process.cwd()) {
             releaseType = analyzedType;
             nextVersion = releaseType
                 ? bumpVersion(packageCurrentVersion, releaseType, {
-                    bumpMinorPreMajor: bumpMinorPreMajorForPath(pkg.path),
+                    allowStableMajor: allowStableMajorForPath(pkg.path),
                 })
                 : null;
             bumpReason = nextVersion ? "direct" : undefined;
@@ -184,7 +175,7 @@ export function createReleasePlan(cwd = process.cwd()) {
         const current = packageCurrentVersionByPath[target.path] ?? target.currentVersion;
         target.releaseType = "patch";
         target.nextVersion = bumpVersion(current, "patch", {
-            bumpMinorPreMajor: bumpMinorPreMajorForPath(target.path),
+            allowStableMajor: allowStableMajorForPath(target.path),
         });
         target.bumpReason = reason;
         const strategyContext = strategyContextByPath.get(target.path);
@@ -217,7 +208,7 @@ export function createReleasePlan(cwd = process.cwd()) {
         }
         const hypotheticalVersion = strategyContext.nextVersion ??
             bumpVersion(packageCurrentVersionByPath[sourcePath] ??
-                strategyContext.currentVersion, "patch", { bumpMinorPreMajor: bumpMinorPreMajorForPath(sourcePath) });
+                strategyContext.currentVersion, "patch", { allowStableMajor: allowStableMajorForPath(sourcePath) });
         return strategyGroup.strategy.propagateDependentPatchImpacts(cwd, strategyGroup.packages.map((pkg) => ({
             ...pkg,
             nextVersion: pkg.packagePath === sourcePath ? hypotheticalVersion : null,
@@ -401,7 +392,7 @@ export function createReleasePlan(cwd = process.cwd()) {
         const baseVersion = packageCurrentVersionByPath[pkgPlan.path] ?? pkgPlan.currentVersion;
         const nextVersion = combinedReleaseType
             ? bumpVersion(baseVersion, combinedReleaseType, {
-                bumpMinorPreMajor: bumpMinorPreMajorForPath(pkgPlan.path),
+                allowStableMajor: allowStableMajorForPath(pkgPlan.path),
             })
             : null;
         return {
@@ -444,7 +435,7 @@ export function createReleasePlan(cwd = process.cwd()) {
             ? rootPackagePlan.nextVersion
             : analyzedFixedType
                 ? bumpVersion(fixedBaseVersion, analyzedFixedType, {
-                    bumpMinorPreMajor,
+                    allowStableMajor,
                 })
                 : null;
         // Fixed mode can promote unchanged dependencies into the release, so the
@@ -482,7 +473,7 @@ export function createReleasePlan(cwd = process.cwd()) {
         ? rootPackagePlan.nextVersion
         : analyzedOverallType
             ? bumpVersion(overallBaseVersion, analyzedOverallType, {
-                bumpMinorPreMajor,
+                allowStableMajor,
             })
             : null;
     return {

package/dist/release/pr.d.ts

@@ -1,3 +1,4 @@
+import { loadConfig } from "../config/load-config.js";
 import type { ParsedCommit } from "../git/commits.js";
 import type { VersionaryChangelogFormat, VersionaryConfig } from "../types/config.js";
 import type { VersionaryPluginContext } from "../types/plugins.js";
@@ -21,6 +22,7 @@ export declare function splitSafeDirtyFiles(files: string[]): {
     ignored: string[];
     blocking: string[];
 };
+export declare function buildReleaseTargets(cwd: string, plan: ReleasePlan, loadedConfig: ReturnType<typeof loadConfig>["config"]): ReleaseTargetState[];
 export interface PendingReleasePrResult {
     branch: string;
     title: string;
@@ -36,6 +38,7 @@ export declare function renderPendingReleaseReviewRequestBody(targets: ReleaseTa
  */
 export declare function preparePendingReleasePr(cwd?: string, options?: {
     logger?: VersionaryPluginContext["logger"];
+    branch?: string;
 }): PendingReleasePrResult;
 /**
  * Recreate each unpublished package cohort on its own corrected-base branch.
@@ -48,6 +51,7 @@ export declare function preparePendingSeparateReleasePrs(cwd?: string, options?:
 }): SeparateReviewCandidate[];
 export declare function prepareReleasePr(cwd?: string, options?: {
     logger?: VersionaryPluginContext["logger"];
+    branch?: string;
 }): {
     branch: string;
     title: string;

package/dist/release/pr.js

@@ -133,7 +133,7 @@ function fetchRemoteReleaseBranch(cwd, branch) {
     });
     return remoteRef;
 }
-function buildReleaseTargets(cwd, plan, loadedConfig) {
+export function buildReleaseTargets(cwd, plan, loadedConfig) {
     const releasingPaths = new Set(plan.packages?.filter((pkg) => pkg.nextVersion).map((pkg) => pkg.path) ?? [
         ".",
     ]);
@@ -237,7 +237,7 @@ export function preparePendingReleasePr(cwd = process.cwd(), options = {}) {
     }
     ensureCleanWorktree(cwd, options.logger);
     const loaded = loadConfig(cwd);
-    const branch = loaded.config["release-branch"] ?? "versionary/release";
+    const branch = options.branch ?? loaded.config["release-branch"] ?? "versionary/release";
     const title = formatReleaseCommitTitle(targets);
     const releaseBaselineSha = execFileSync("git", ["rev-parse", "HEAD"], {
         cwd,
@@ -466,7 +466,7 @@ export function prepareReleasePr(cwd = process.cwd(), options = {}) {
         updatedChangelogFiles.push(packageChangelogPath);
     }
     const releaseTargets = buildReleaseTargets(cwd, plan, loaded.config);
-    const branch = plan.releaseBranchPrefix;
+    const branch = options.branch ?? plan.releaseBranchPrefix;
     const title = formatReleaseCommitTitle(releaseTargets);
     const hasRemoteReleaseBranch = remoteReleaseBranchExists(cwd, branch);
     const remoteReleaseRef = hasRemoteReleaseBranch

package/dist/release/release.d.ts

@@ -1,6 +1,7 @@
 import type { VersionaryConfig } from "../types/config.js";
 import type { VersionaryPluginContext } from "../types/plugins.js";
 export declare function resolveTargetPackageName(cwd: string, config: VersionaryConfig, targetPath: string): string | undefined;
+export declare function resolveTargetReleaseDraft(config: VersionaryConfig, targetPath: string): boolean;
 export declare function extractReleaseNotes(content: string, version: string, changelogFormat: "markdown-changelog" | "r-news"): string;
 export declare function extractClosingReferencesFromNotes(notes: string): number[];
 export declare function resolveTargetChangelogFile(config: VersionaryConfig, rootChangelogFile: string, targetPath: string): string;

package/dist/release/release.js

@@ -22,6 +22,11 @@ export function resolveTargetPackageName(cwd, config, targetPath) {
     }
     return resolved;
 }
+export function resolveTargetReleaseDraft(config, targetPath) {
+    return (config.packages?.[targetPath]?.["release-draft"] ??
+        config["release-draft"] ??
+        false);
+}
 export function extractReleaseNotes(content, version, changelogFormat) {
     const lines = content.split("\n");
     const shortVersion = version.replace(/\.\d+$/u, "");
@@ -198,7 +203,7 @@ export async function runReleaseDetailed(cwd = process.cwd(), options = {}) {
             tag: target.tag,
             version: target.version,
             notes: releaseNotes,
-            draft: loaded.config["release-draft"] ?? false,
+            draft: resolveTargetReleaseDraft(loaded.config, target.path),
             makeLatest: target.path === "." ? "true" : "false",
         }, {
             createReleaseMetadata: (input) => scmClient.createReleaseMetadata(input, {

package/dist/release/semver.d.ts

@@ -8,7 +8,7 @@ export interface ParsedVersion {
     build: string[];
 }
 export interface BumpVersionOptions {
-    bumpMinorPreMajor?: boolean;
+    allowStableMajor?: boolean;
 }
 export declare function parseVersion(version: string): ParsedVersion;
 export declare function isValidVersion(version: string): boolean;

package/dist/release/semver.js

@@ -137,9 +137,9 @@ export function compareVersions(leftRaw, rightRaw) {
 }
 export function bumpVersion(current, releaseType, options = {}) {
     const parsed = parseVersion(current);
-    const bumpMinorPreMajor = options.bumpMinorPreMajor ?? true;
+    const allowStableMajor = options.allowStableMajor ?? false;
     if (releaseType === "major") {
-        if (parsed.major === 0 && bumpMinorPreMajor) {
+        if (parsed.major === 0 && !allowStableMajor) {
             return `0.${parsed.minor + 1}.0`;
         }
         return `${parsed.major + 1}.0.0`;

package/dist/release/verify-project.js

@@ -12,32 +12,37 @@ export function verifyProject(cwd = process.cwd()) {
         details: `Loaded ${path.basename(config.path)} (${config.format})`,
         category: "config",
     });
-    const strategy = resolveVersionStrategy(config.config);
-    const versionFile = strategy.getVersionFile(config.config);
-    const exists = fs.existsSync(path.join(cwd, versionFile));
-    checks.push({
-        name: `version-file:${versionFile}`,
-        ok: exists,
-        details: exists ? "Version file exists" : `Missing ${versionFile}`,
-        category: "version-files",
-        remediation: exists
-            ? undefined
-            : `Create ${versionFile} or set "version-file" to the correct path for your release strategy.`,
-    });
-    if (exists) {
-        const validationError = strategy.validateProject?.(cwd, config.config);
+    const packages = Object.entries(config.config.packages ?? {});
+    const shouldValidateRoot = packages.length === 0 ||
+        packages.some(([packagePath]) => packagePath === ".");
+    if (shouldValidateRoot) {
+        const strategy = resolveVersionStrategy(config.config);
+        const versionFile = strategy.getVersionFile(config.config);
+        const exists = fs.existsSync(path.join(cwd, versionFile));
         checks.push({
-            name: `strategy-validate:${strategy.name}`,
-            ok: !validationError,
-            details: validationError ?? "Strategy-level validation passed",
+            name: `version-file:${versionFile}`,
+            ok: exists,
+            details: exists ? "Version file exists" : `Missing ${versionFile}`,
             category: "version-files",
-            remediation: validationError
-                ? `Fix strategy-specific version metadata in ${versionFile} for release-type "${strategy.name}".`
-                : undefined,
+            remediation: exists
+                ? 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)) {
+    if (packages.length > 0) {
+        for (const [pkgPathRaw, packageConfig] of packages) {
             const pkgPath = path.join(cwd, pkgPathRaw);
             const exists = fs.existsSync(pkgPath);
             checks.push({

package/dist/strategy/python.js

@@ -140,7 +140,7 @@ const LOCKFILE_SPECS = [
         installHint: "install PDM (https://pdm-project.org/)",
     },
 ];
-function refreshLockfile(cwd, spec) {
+function refreshLockfile(cwd, spec, lockfilePath) {
     try {
         execFileSync(spec.command, [...spec.args], {
             cwd,
@@ -149,7 +149,33 @@ function refreshLockfile(cwd, spec) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to refresh ${spec.lockfile} via "${spec.command} ${spec.args.join(" ")}". Ensure ${spec.command} is on PATH (${spec.installHint}) or remove ${spec.lockfile} from the working tree. Details: ${message}`);
+        throw new Error(`Failed to refresh ${lockfilePath} via "${spec.command} ${spec.args.join(" ")}". Ensure ${spec.command} is on PATH (${spec.installHint}) or remove ${lockfilePath} from the working tree. Details: ${message}`);
+    }
+}
+function normalizeRelativePath(base, target) {
+    return path.relative(base, target).replaceAll("\\", "/");
+}
+function findNearestLockfileDirectory(cwd, packageDirectory, lockfile) {
+    const root = path.resolve(cwd);
+    let current = path.resolve(packageDirectory);
+    const relativePackageDirectory = path.relative(root, current);
+    if (relativePackageDirectory === ".." ||
+        relativePackageDirectory.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(relativePackageDirectory)) {
+        return null;
+    }
+    while (true) {
+        if (fs.existsSync(path.join(current, lockfile))) {
+            return current;
+        }
+        if (current === root) {
+            return null;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
     }
 }
 function readPyProjectFromCwd(cwd) {
@@ -301,16 +327,25 @@ export const pythonVersionStrategy = {
         }
         return null;
     },
-    finalizeVersionWrites(cwd, _writes, _context) {
-        const refreshed = [];
-        for (const spec of LOCKFILE_SPECS) {
-            const lockPath = path.join(cwd, spec.lockfile);
-            if (!fs.existsSync(lockPath)) {
-                continue;
+    finalizeVersionWrites(cwd, writes, _context) {
+        const packageDirectories = [
+            ...new Set(writes.map((write) => path.resolve(cwd, write.packagePath === "." ? "" : write.packagePath))),
+        ].sort((a, b) => a.localeCompare(b));
+        const lockfiles = new Map();
+        for (const packageDirectory of packageDirectories) {
+            for (const spec of LOCKFILE_SPECS) {
+                const directory = findNearestLockfileDirectory(cwd, packageDirectory, spec.lockfile);
+                if (!directory) {
+                    continue;
+                }
+                const relativePath = normalizeRelativePath(cwd, path.join(directory, spec.lockfile));
+                lockfiles.set(relativePath, { directory, spec });
             }
-            refreshLockfile(cwd, spec);
-            refreshed.push(spec.lockfile);
         }
-        return refreshed.sort((a, b) => a.localeCompare(b));
+        const refreshed = [...lockfiles.entries()].sort(([left], [right]) => left.localeCompare(right));
+        for (const [relativePath, { directory, spec }] of refreshed) {
+            refreshLockfile(directory, spec, relativePath);
+        }
+        return refreshed.map(([relativePath]) => relativePath);
     },
 };

package/dist/types/config.d.ts

@@ -14,6 +14,8 @@ export interface VersionaryPackage {
     "package-name"?: string;
     "changelog-file"?: string;
     "changelog-format"?: VersionaryChangelogFormat;
+    "release-draft"?: boolean;
+    /** @deprecated Use `allow-stable-major` with the inverse value. */
     "bump-minor-pre-major"?: boolean;
     "allow-stable-major"?: boolean;
     "exclude-paths"?: string[];
@@ -33,6 +35,7 @@ export interface VersionaryConfig {
     "baseline-file"?: string;
     "bootstrap-sha"?: string;
     "monorepo-mode"?: "independent" | "fixed";
+    /** @deprecated Use `allow-stable-major` with the inverse value. */
     "bump-minor-pre-major"?: boolean;
     "allow-stable-major"?: boolean;
     "include-commit-authors"?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "versionary",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "description": "Automatic release framework based on conventional commits and semantic versioning",
   "keywords": [
     "releasing",
@@ -39,7 +39,7 @@
     "typescript": "^7.0.2",
     "vite": "^8.0.0",
     "vitepress": "^1.6.4",
-    "vitest": "^4.1.4"
+    "vitest": "^5.0.0"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",