versionary 1.2.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,8 @@ 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>>;
         "extra-files": z.ZodOptional<z.ZodArray<z.ZodObject<{

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,12 +68,24 @@ const packageSchema = z
     "package-name": z.string().optional(),
     "changelog-file": z.string().optional(),
     "changelog-format": z.enum(["markdown-changelog", "r-news"]).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(),
     follows: z.array(z.string().min(1)).optional(),
 })
-    .strict();
+    .strict()
+    .superRefine((value, ctx) => {
+    if (value["bump-minor-pre-major"] !== undefined &&
+        value["allow-stable-major"] !== undefined) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: '"bump-minor-pre-major" and "allow-stable-major" are inverse aliases; configure only one.',
+            path: ["bump-minor-pre-major"],
+        });
+    }
+});
 export const configSchema = z
     .object({
     $schema: z.string().optional(),
@@ -87,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(),
@@ -98,6 +114,14 @@ export const configSchema = z
 })
     .strict()
     .superRefine((value, ctx) => {
+    if (value["bump-minor-pre-major"] !== undefined &&
+        value["allow-stable-major"] !== undefined) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: '"bump-minor-pre-major" and "allow-stable-major" are inverse aliases; configure only one.',
+            path: ["bump-minor-pre-major"],
+        });
+    }
     const packages = value.packages;
     if (value["separate-release-prs"]) {
         if (!packages || Object.keys(packages).length === 0) {

package/dist/release/plan.js

@@ -10,6 +10,12 @@ import { readBaselineSha, readReleaseTargets } from "./state.js";
 function getMode(configMode) {
     return configMode ?? "independent";
 }
+function resolveAllowStableMajor(config, packageConfig) {
+    if (packageConfig?.["allow-stable-major"] !== undefined) {
+        return packageConfig["allow-stable-major"];
+    }
+    return config["allow-stable-major"] ?? false;
+}
 export function getChangelogDefaults(config) {
     const changelogFormat = config["changelog-format"] ??
         config.defaultChangelogFormat ??
@@ -50,9 +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 allowStableMajor = loaded.config["allow-stable-major"] ?? false;
-    const allowStableMajorForPath = (packagePath) => loaded.config.packages?.[packagePath]?.["allow-stable-major"] ??
-        allowStableMajor;
+    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);
@@ -429,7 +434,9 @@ export function createReleasePlan(cwd = process.cwd()) {
         const fixedNextVersion = rootOverridden
             ? rootPackagePlan.nextVersion
             : analyzedFixedType
-                ? bumpVersion(fixedBaseVersion, analyzedFixedType, { allowStableMajor })
+                ? bumpVersion(fixedBaseVersion, analyzedFixedType, {
+                    allowStableMajor,
+                })
                 : null;
         // Fixed mode can promote unchanged dependencies into the release, so the
         // final shared version set must drive dependency attribution.

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

@@ -142,9 +142,6 @@ export function bumpVersion(current, releaseType, options = {}) {
         if (parsed.major === 0 && !allowStableMajor) {
             return `0.${parsed.minor + 1}.0`;
         }
-        if (parsed.major === 0 && allowStableMajor) {
-            return "1.0.0";
-        }
         return `${parsed.major + 1}.0.0`;
     }
     if (releaseType === "minor") {

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,9 @@ 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[];
     "extra-files"?: VersionaryArtifactRule[];
@@ -32,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.2.0",
+  "version": "1.4.0",
   "description": "Automatic release framework based on conventional commits and semantic versioning",
   "keywords": [
     "releasing",