versionary 1.3.0 → 1.4.0

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/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/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.0",
   "description": "Automatic release framework based on conventional commits and semantic versioning",
   "keywords": [
     "releasing",