versionary 0.5.0 → 0.7.0

package/README.md

@@ -100,6 +100,7 @@ For a quick trial, use:
 - optional monorepo planning with `monorepo-mode` and `packages`:
   - `independent` computes package bumps per path
   - `fixed` computes one shared bump across configured package paths
+  - per-package `package-name` can override release identity (labels + tag base)
 
 Rust strategy examples:
 
@@ -124,6 +125,8 @@ Current rust auto-update behavior (phase scope):
 - updates crate versions in each targeted crate `[package].version`
 - updates internal workspace dependency versions when the dependency name
   matches another targeted crate name
+- refreshes `Cargo.lock` via `cargo generate-lockfile` when `Cargo.lock` exists
+  in repo root
 - applies dependency version rewrites in:
   - `[dependencies]`, `[dev-dependencies]`, `[build-dependencies]`
   - `[target.*.dependencies]`, `[target.*.dev-dependencies]`,
@@ -136,6 +139,28 @@ Current rust non-goals/limits:
 - does not add missing `version = ...` fields to dependency inline tables
 - does not perform Cargo publish/release to crates.io
 
+If `Cargo.lock` exists, `cargo` must be available in PATH during PR preparation.
+
+### Monorepo release names and tag naming
+
+For independent monorepo targets, Versionary derives release tags as:
+
+- root package (`"."`): `v<version>`
+- non-root package: `<release-name>-v<version>`
+
+`release-name` precedence is:
+
+1. `packages.<path>.package-name` (explicit override)
+2. strategy-native package name from version file:
+   - Node: `package.json` `name`
+   - Rust: `Cargo.toml` `[package].name`
+   - R: `DESCRIPTION` `Package:`
+3. package path fallback
+
+When multiple packages resolve to the same `<release-name>` and version, the run
+fails fast with a duplicate-tag error and suggests setting unique
+`package-name` values.
+
 ## Commit parsing and release analysis
 
 Release planning is based on Conventional Commit parsing semantics:
@@ -231,7 +256,7 @@ steps:
   - id: versionary
     uses: jolars/versionary@v1
     with:
-      github-token: ${{ secrets.RELEASE_TOKEN }}
+      token: ${{ secrets.RELEASE_TOKEN }}
 ```
 
 ```yaml
@@ -247,11 +272,16 @@ steps:
   - id: versionary
     uses: jolars/versionary@v1
     with:
-      github-token: ${{ secrets.RELEASE_TOKEN }}
+      token: ${{ secrets.RELEASE_TOKEN }}
   - if: ${{ steps.versionary.outputs.release_created == 'true' }}
     run: echo "Released ${{ steps.versionary.outputs.tag_name }}"
 ```
 
+`token` is used for both GitHub API calls and git push authentication in
+the composite action. This means release-branch force-pushes are attributed to
+that token and can trigger downstream workflows when using a PAT/App token.
+(`github-token` remains as a deprecated alias for backward compatibility.)
+
 Action outputs:
 
 - `action`: `noop`, `pr-prepared`, `release-published`, `release-skipped`

package/dist/app/release/artifact-rules.js

@@ -11,25 +11,25 @@ const yaml_1 = __importDefault(require("yaml"));
 function isRecord(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
-function parseJsonPath(jsonpath) {
-    if (!jsonpath.startsWith("$")) {
-        throw new Error(`Invalid jsonpath "${jsonpath}". Must start with "$".`);
+function parseFieldPath(fieldPath) {
+    if (!fieldPath.startsWith("$")) {
+        throw new Error(`Invalid field-path "${fieldPath}". Must start with "$".`);
     }
     const tokens = [];
     let index = 1;
-    while (index < jsonpath.length) {
-        const current = jsonpath[index];
+    while (index < fieldPath.length) {
+        const current = fieldPath[index];
         if (current === ".") {
-            const keyMatch = jsonpath.slice(index + 1).match(/^[A-Za-z0-9_-]+/u);
+            const keyMatch = fieldPath.slice(index + 1).match(/^[A-Za-z0-9_-]+/u);
             if (!keyMatch) {
-                throw new Error(`Invalid jsonpath "${jsonpath}" near index ${index}.`);
+                throw new Error(`Invalid field-path "${fieldPath}" near index ${index}.`);
             }
             tokens.push(keyMatch[0]);
             index += 1 + keyMatch[0].length;
             continue;
         }
         if (current === "[") {
-            const rest = jsonpath.slice(index + 1);
+            const rest = fieldPath.slice(index + 1);
             const numberMatch = rest.match(/^(\d+)\]/u);
             if (numberMatch) {
                 tokens.push(Number(numberMatch[1]));
@@ -42,53 +42,60 @@ function parseJsonPath(jsonpath) {
                 index += 4 + keyMatch[1].length;
                 continue;
             }
-            throw new Error(`Invalid jsonpath "${jsonpath}" near index ${index}.`);
+            throw new Error(`Invalid field-path "${fieldPath}" near index ${index}.`);
         }
-        throw new Error(`Invalid jsonpath "${jsonpath}" near index ${index}.`);
+        throw new Error(`Invalid field-path "${fieldPath}" near index ${index}.`);
     }
     if (tokens.length === 0) {
-        throw new Error(`Invalid jsonpath "${jsonpath}". Path must target a field.`);
+        throw new Error(`Invalid field-path "${fieldPath}". Path must target a field.`);
     }
     return tokens;
 }
-function setVersionAtJsonPath(document, jsonpath, version) {
-    const tokens = parseJsonPath(jsonpath);
+function setVersionAtJsonPath(document, fieldPath, version) {
+    const tokens = parseFieldPath(fieldPath);
     let cursor = document;
     for (let index = 0; index < tokens.length - 1; index += 1) {
         const token = tokens[index];
         if (typeof token === "number") {
             if (!Array.isArray(cursor) || token >= cursor.length) {
-                throw new Error(`jsonpath "${jsonpath}" does not resolve to an existing field.`);
+                throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
             }
             cursor = cursor[token];
             continue;
         }
         if (!isRecord(cursor) || !(token in cursor)) {
-            throw new Error(`jsonpath "${jsonpath}" does not resolve to an existing field.`);
+            throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
         }
         cursor = cursor[token];
     }
     const leaf = tokens.at(-1);
     if (typeof leaf === "number") {
         if (!Array.isArray(cursor) || leaf >= cursor.length) {
-            throw new Error(`jsonpath "${jsonpath}" does not resolve to an existing field.`);
+            throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
         }
         const current = cursor[leaf];
         if (typeof current !== "string" && typeof current !== "number") {
-            throw new Error(`jsonpath "${jsonpath}" must point to a string or number field for version updates.`);
+            throw new Error(`field-path "${fieldPath}" must point to a string or number field for version updates.`);
         }
         cursor[leaf] = version;
         return;
     }
     if (!isRecord(cursor) || !(leaf in cursor)) {
-        throw new Error(`jsonpath "${jsonpath}" does not resolve to an existing field.`);
+        throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
     }
     const current = cursor[leaf];
     if (typeof current !== "string" && typeof current !== "number") {
-        throw new Error(`jsonpath "${jsonpath}" must point to a string or number field for version updates.`);
+        throw new Error(`field-path "${fieldPath}" must point to a string or number field for version updates.`);
     }
     cursor[leaf] = version;
 }
+function resolveFieldPath(rule) {
+    const fieldPath = rule["field-path"] ?? rule.jsonpath;
+    if (!fieldPath) {
+        throw new Error(`${rule.type} artifact rules require "field-path" (or deprecated "jsonpath").`);
+    }
+    return fieldPath;
+}
 function parseRegexPattern(pattern) {
     const slashPattern = pattern.match(/^\/((?:\\\/|[^/])+)\/([a-z]*)$/u);
     if (slashPattern) {
@@ -116,22 +123,36 @@ function applyRegexRule(content, pattern, version) {
     const replacement = typeof groupOne === "string" ? full.replace(groupOne, version) : version;
     return `${content.slice(0, start)}${replacement}${content.slice(start + full.length)}`;
 }
+function applyTomlRulePreservingFormatting(content, fieldPath, version) {
+    const simplePath = fieldPath.match(/^\$\.([A-Za-z0-9_-]+)$/u);
+    if (!simplePath) {
+        const parsed = toml_1.default.parse(content);
+        setVersionAtJsonPath(parsed, fieldPath, version);
+        return `${toml_1.default.stringify(parsed)}\n`;
+    }
+    const key = simplePath[1];
+    const linePattern = new RegExp(`^(\\s*${key}\\s*=\\s*)(["'])([^"']*)(\\2)(\\s*(?:#.*)?)$`, "mu");
+    const match = content.match(linePattern);
+    if (!match) {
+        throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
+    }
+    const [, prefix = "", quote = '"', , , suffix = ""] = match;
+    return content.replace(linePattern, `${prefix}${quote}${version}${quote}${suffix}`);
+}
 function applyArtifactRuleToContent(content, rule, version) {
     if (rule.type === "regex") {
         return applyRegexRule(content, rule.pattern, version);
     }
     if (rule.type === "json") {
         const parsed = JSON.parse(content);
-        setVersionAtJsonPath(parsed, rule.jsonpath, version);
+        setVersionAtJsonPath(parsed, resolveFieldPath(rule), version);
         return `${JSON.stringify(parsed, null, 2)}\n`;
     }
     if (rule.type === "toml") {
-        const parsed = toml_1.default.parse(content);
-        setVersionAtJsonPath(parsed, rule.jsonpath, version);
-        return `${toml_1.default.stringify(parsed)}\n`;
+        return applyTomlRulePreservingFormatting(content, resolveFieldPath(rule), version);
     }
     const parsed = yaml_1.default.parse(content);
-    setVersionAtJsonPath(parsed, rule.jsonpath, version);
+    setVersionAtJsonPath(parsed, resolveFieldPath(rule), version);
     return `${yaml_1.default.stringify(parsed)}`;
 }
 function normalizeRelative(base, target) {

package/dist/app/release/pr.js

@@ -10,7 +10,9 @@ 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 toml_1 = __importDefault(require("@iarna/toml"));
 const load_config_js_1 = require("../../config/load-config.js");
 const changelog_js_1 = require("../../domain/release/changelog.js");
 const plan_js_1 = require("../../domain/release/plan.js");
@@ -68,6 +70,120 @@ function ensureCleanWorktree(cwd, logger) {
         logger?.warn(`Ignoring safe tracked changes before versionary pr:\n${ignored.join("\n")}`);
     }
 }
+function ensureCargoLockUpToDate(cwd) {
+    const lockfilePath = node_path_1.default.join(cwd, "Cargo.lock");
+    if (!node_fs_1.default.existsSync(lockfilePath)) {
+        return [];
+    }
+    const before = node_fs_1.default.readFileSync(lockfilePath, "utf8");
+    try {
+        (0, node_child_process_1.execFileSync)("cargo", ["generate-lockfile"], {
+            cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to refresh Cargo.lock via "cargo generate-lockfile". Ensure cargo is installed and available in PATH. Details: ${message}`);
+    }
+    const after = node_fs_1.default.readFileSync(lockfilePath, "utf8");
+    return after !== before ? ["Cargo.lock"] : [];
+}
+function normalizeReleaseNameForTag(releaseName) {
+    return releaseName
+        .trim()
+        .replace(/^@/u, "")
+        .replaceAll("/", "-")
+        .replace(/\s+/gu, "-");
+}
+function readNodePackageName(versionPath) {
+    const raw = JSON.parse(node_fs_1.default.readFileSync(versionPath, "utf8"));
+    const name = raw.name;
+    if (typeof name !== "string" || name.trim().length === 0) {
+        return null;
+    }
+    return name.trim();
+}
+function readRustPackageName(versionPath) {
+    const parsed = toml_1.default.parse(node_fs_1.default.readFileSync(versionPath, "utf8"));
+    const name = parsed.package?.name;
+    if (typeof name !== "string" || name.trim().length === 0) {
+        return null;
+    }
+    return name.trim();
+}
+function readRPackageName(versionPath) {
+    const content = node_fs_1.default.readFileSync(versionPath, "utf8");
+    const match = content.match(/^Package:\s*(.+)\s*$/mu);
+    if (!match?.[1]) {
+        return null;
+    }
+    const name = match[1].trim();
+    return name.length > 0 ? name : null;
+}
+function resolveReleaseName(cwd, packagePath, packageConfig, strategyName, versionFile) {
+    const configuredName = packageConfig["package-name"]?.trim();
+    if (configuredName) {
+        return configuredName;
+    }
+    const versionPath = node_path_1.default.join(cwd, versionFile);
+    if (strategyName === "node") {
+        return readNodePackageName(versionPath) ?? packagePath;
+    }
+    if (strategyName === "rust") {
+        return readRustPackageName(versionPath) ?? packagePath;
+    }
+    if (strategyName === "r") {
+        return readRPackageName(versionPath) ?? packagePath;
+    }
+    return packagePath;
+}
+function buildReleaseTargets(cwd, plan, loadedConfig) {
+    const releaseTargets = plan.packages
+        ? plan.packages
+            .filter((pkg) => pkg.nextVersion)
+            .map((pkg) => {
+            if (pkg.path === ".") {
+                return {
+                    path: pkg.path,
+                    version: pkg.nextVersion ?? "",
+                    tag: `v${pkg.nextVersion ?? ""}`,
+                };
+            }
+            const packageConfig = loadedConfig.packages?.[pkg.path] ?? {};
+            const packageContext = (0, package_context_js_1.resolvePackageStrategyContext)(loadedConfig, pkg.path, packageConfig);
+            const releaseName = resolveReleaseName(cwd, pkg.path, packageConfig, packageContext.strategy.name, packageContext.versionFile);
+            const tagPrefix = normalizeReleaseNameForTag(releaseName);
+            return {
+                path: pkg.path,
+                version: pkg.nextVersion ?? "",
+                tag: `${tagPrefix}-v${pkg.nextVersion ?? ""}`,
+            };
+        })
+        : [
+            {
+                path: ".",
+                version: plan.nextVersion ?? "",
+                tag: `v${plan.nextVersion ?? ""}`,
+            },
+        ];
+    const seenTags = new Map();
+    for (const target of releaseTargets) {
+        const existingPath = seenTags.get(target.tag);
+        if (existingPath) {
+            throw new Error(`Duplicate release tag "${target.tag}" for packages "${existingPath}" and "${target.path}". Configure unique "package-name" values.`);
+        }
+        seenTags.set(target.tag, target.path);
+    }
+    return releaseTargets;
+}
+function formatReleaseCommitTitle(releaseTargets) {
+    if (releaseTargets.length === 0) {
+        return "chore(release): v0.0.0";
+    }
+    const tags = releaseTargets.map((target) => target.tag);
+    return `chore(release): ${tags.join(", ")}`;
+}
 function prepareSimpleReleasePr(cwd = process.cwd(), options = {}) {
     const plan = (0, plan_js_1.createSimplePlan)(cwd);
     const loaded = (0, load_config_js_1.loadConfig)(cwd);
@@ -98,10 +214,12 @@ function prepareSimpleReleasePr(cwd = process.cwd(), options = {}) {
         updatedVersionFiles.push(...strategy.writeVersion(cwd, loaded.config, plan.nextVersion));
     }
     const updatedArtifactFiles = (0, artifact_rules_js_1.applyConfiguredArtifactRules)(cwd, loaded.config, plan);
+    const updatedRustLockFiles = ensureCargoLockUpToDate(cwd);
     const section = (0, changelog_js_1.renderSimpleChangelog)(plan);
     (0, changelog_js_1.prependChangelog)(cwd, plan.changelogFile, section);
+    const releaseTargets = buildReleaseTargets(cwd, plan, loaded.config);
     const branch = plan.releaseBranchPrefix;
-    const title = `chore(release): v${plan.nextVersion}`;
+    const title = formatReleaseCommitTitle(releaseTargets);
     (0, node_child_process_1.execFileSync)("git", ["checkout", "-B", branch], {
         cwd,
         stdio: ["ignore", "pipe", "ignore"],
@@ -110,6 +228,7 @@ function prepareSimpleReleasePr(cwd = process.cwd(), options = {}) {
         ...new Set([
             ...updatedVersionFiles,
             ...updatedArtifactFiles,
+            ...updatedRustLockFiles,
             plan.changelogFile,
         ]),
     ];
@@ -121,23 +240,6 @@ function prepareSimpleReleasePr(cwd = process.cwd(), options = {}) {
         cwd,
         stdio: ["ignore", "pipe", "ignore"],
     });
-    const releaseTargets = plan.packages
-        ? plan.packages
-            .filter((pkg) => pkg.nextVersion)
-            .map((pkg) => ({
-            path: pkg.path,
-            version: pkg.nextVersion ?? "",
-            tag: pkg.path === "."
-                ? `v${pkg.nextVersion ?? ""}`
-                : `${pkg.path.replaceAll("/", "-")}-v${pkg.nextVersion ?? ""}`,
-        }))
-        : [
-            {
-                path: ".",
-                version: plan.nextVersion,
-                tag: `v${plan.nextVersion}`,
-            },
-        ];
     (0, state_js_1.writeBaselineSha)(cwd, undefined, releaseTargets);
     (0, node_child_process_1.execFileSync)("git", ["add", (0, state_js_1.getBaselineStatePath)(cwd)], {
         cwd,
@@ -157,10 +259,13 @@ function prepareSimpleReleasePr(cwd = process.cwd(), options = {}) {
     };
 }
 function renderSimpleReviewRequestBody(version, previousVersion, commits, plan = null, cwd = process.cwd()) {
+    const rootPackageLabel = node_path_1.default.basename(cwd);
+    const formatPackageLabel = (packagePath) => packagePath === "." ? rootPackageLabel : packagePath;
     if (plan?.packages && plan.packages.length > 1) {
         const sections = plan.packages
             .filter((pkg) => pkg.nextVersion)
             .map((pkg) => {
+            const packageLabel = formatPackageLabel(pkg.path);
             const notes = (0, changelog_js_1.renderSimpleReleaseNotes)({
                 currentVersion: pkg.currentVersion,
                 nextVersion: pkg.nextVersion ?? "",
@@ -170,12 +275,12 @@ function renderSimpleReviewRequestBody(version, previousVersion, commits, plan =
             const linkedHeader = notes.match(/^##\s+\[([^\]]+)\]\(([^)]+)\)\s+\(([^)]+)\)/u);
             if (linkedHeader) {
                 const [, , compareUrl, date] = linkedHeader;
-                return notes.replace(/^##\s+\[[^\]]+\]\([^)]+\)\s+\([^)]+\)/u, `## [${pkg.path}: ${pkg.nextVersion ?? ""}](${compareUrl}) (${date})`);
+                return notes.replace(/^##\s+\[[^\]]+\]\([^)]+\)\s+\([^)]+\)/u, `## [${packageLabel}: ${pkg.nextVersion ?? ""}](${compareUrl}) (${date})`);
             }
             const plainHeader = notes.match(/^##\s+([^\s]+)\s+\(([^)]+)\)/u);
             if (plainHeader) {
                 const [, , date] = plainHeader;
-                return notes.replace(/^##\s+[^\s]+\s+\([^)]+\)/u, `## ${pkg.path}: ${pkg.nextVersion ?? ""} (${date})`);
+                return notes.replace(/^##\s+[^\s]+\s+\([^)]+\)/u, `## ${packageLabel}: ${pkg.nextVersion ?? ""} (${date})`);
             }
             return notes;
         })
@@ -223,5 +328,5 @@ function pushReleaseBranch(cwd, branch) {
     });
 }
 function isReleaseCommitMessage(subject) {
-    return /^chore\(release\):\sv\d+\.\d+\.\d+/u.test(subject);
+    return /^chore\(release\):\s+(?:v\d+\.\d+\.\d+|\S+-v\d+\.\d+\.\d+)(?:,\s+(?:v\d+\.\d+\.\d+|\S+-v\d+\.\d+\.\d+))*(?:\s+\(#\d+\))?$/u.test(subject);
 }

package/dist/app/release/state.js

@@ -11,26 +11,29 @@ 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 MANIFEST_VERSION_KEY = "manifest-version";
+const BASELINE_SHA_KEY = "baseline-sha";
+const RELEASE_TARGETS_KEY = "release-targets";
 function parseStateFile(raw, filePath) {
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
         throw new Error(`Invalid release manifest at ${filePath}: expected an object.`);
     }
     const manifest = parsed;
-    if (manifest.manifestVersion !== undefined &&
-        manifest.manifestVersion !== 1) {
-        throw new Error(`Unsupported manifestVersion in ${filePath}: ${String(manifest.manifestVersion)}.`);
+    if (manifest[MANIFEST_VERSION_KEY] !== undefined &&
+        manifest[MANIFEST_VERSION_KEY] !== 1) {
+        throw new Error(`Unsupported ${MANIFEST_VERSION_KEY} in ${filePath}: ${String(manifest[MANIFEST_VERSION_KEY])}.`);
     }
-    if (manifest.baselineSha !== undefined &&
-        typeof manifest.baselineSha !== "string") {
-        throw new Error(`Invalid release manifest at ${filePath}: baselineSha must be a string.`);
+    if (manifest[BASELINE_SHA_KEY] !== undefined &&
+        typeof manifest[BASELINE_SHA_KEY] !== "string") {
+        throw new Error(`Invalid release manifest at ${filePath}: ${BASELINE_SHA_KEY} must be a string.`);
     }
-    if (manifest.releaseTargets !== undefined &&
-        !Array.isArray(manifest.releaseTargets)) {
-        throw new Error(`Invalid release manifest at ${filePath}: releaseTargets must be an array.`);
+    if (manifest[RELEASE_TARGETS_KEY] !== undefined &&
+        !Array.isArray(manifest[RELEASE_TARGETS_KEY])) {
+        throw new Error(`Invalid release manifest at ${filePath}: ${RELEASE_TARGETS_KEY} must be an array.`);
     }
-    if (Array.isArray(manifest.releaseTargets)) {
-        for (const target of manifest.releaseTargets) {
+    if (Array.isArray(manifest[RELEASE_TARGETS_KEY])) {
+        for (const target of manifest[RELEASE_TARGETS_KEY]) {
             if (!target || typeof target !== "object" || Array.isArray(target)) {
                 throw new Error(`Invalid release manifest at ${filePath}: each release target must be an object.`);
             }
@@ -38,7 +41,7 @@ function parseStateFile(raw, filePath) {
             if (typeof record.path !== "string" ||
                 typeof record.version !== "string" ||
                 typeof record.tag !== "string") {
-                throw new Error(`Invalid release manifest at ${filePath}: releaseTargets must contain string path, version, and tag.`);
+                throw new Error(`Invalid release manifest at ${filePath}: ${RELEASE_TARGETS_KEY} must contain string path, version, and tag.`);
             }
         }
     }
@@ -66,7 +69,7 @@ function readBaselineSha(cwd = process.cwd()) {
         return null;
     }
     const parsed = parseStateFile(node_fs_1.default.readFileSync(filePath, "utf8"), filePath);
-    return parsed.baselineSha ?? null;
+    return parsed[BASELINE_SHA_KEY] ?? null;
 }
 function readReleaseTargets(cwd = process.cwd()) {
     const filePath = getBaselineStatePath(cwd);
@@ -74,10 +77,10 @@ function readReleaseTargets(cwd = process.cwd()) {
         return [];
     }
     const parsed = parseStateFile(node_fs_1.default.readFileSync(filePath, "utf8"), filePath);
-    return parsed.releaseTargets ?? [];
+    return parsed[RELEASE_TARGETS_KEY] ?? [];
 }
 function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets = []) {
-    const baselineSha = sha ??
+    const baselineShaValue = sha ??
         (0, node_child_process_1.execFileSync)("git", ["rev-parse", "HEAD"], {
             cwd,
             encoding: "utf8",
@@ -85,9 +88,9 @@ function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets = []) {
         }).trim();
     const filePath = getBaselineStatePath(cwd);
     const next = {
-        manifestVersion: 1,
-        baselineSha,
-        releaseTargets,
+        [MANIFEST_VERSION_KEY]: 1,
+        [BASELINE_SHA_KEY]: baselineShaValue,
+        [RELEASE_TARGETS_KEY]: releaseTargets,
     };
     node_fs_1.default.writeFileSync(filePath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
 }

package/dist/config/schema.d.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 export declare const configSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
     version: z.ZodLiteral<1>;
     "review-mode": z.ZodOptional<z.ZodEnum<{
         direct: "direct";
@@ -30,10 +31,11 @@ export declare const configSchema: z.ZodObject<{
                 regex: "regex";
             }>;
             path: z.ZodString;
+            "field-path": z.ZodOptional<z.ZodString>;
             jsonpath: z.ZodOptional<z.ZodString>;
             pattern: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
-    }, z.core.$strip>>>;
+    }, z.core.$strict>>>;
     plugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>;
+}, z.core.$strict>;
 export type ConfigSchema = z.infer<typeof configSchema>;

package/dist/config/schema.js

@@ -6,16 +6,18 @@ const artifactRuleSchema = zod_1.z
     .object({
     type: zod_1.z.enum(["json", "toml", "yaml", "regex"]),
     path: zod_1.z.string().min(1),
+    "field-path": zod_1.z.string().optional(),
     jsonpath: zod_1.z.string().optional(),
     pattern: zod_1.z.string().optional(),
 })
     .superRefine((value, ctx) => {
     const needsJsonPath = value.type === "json" || value.type === "toml" || value.type === "yaml";
-    if (needsJsonPath && !value.jsonpath) {
+    const hasFieldPath = Boolean(value["field-path"] ?? value.jsonpath);
+    if (needsJsonPath && !hasFieldPath) {
         ctx.addIssue({
             code: zod_1.z.ZodIssueCode.custom,
-            message: `${value.type} artifact rules require "jsonpath".`,
-            path: ["jsonpath"],
+            message: `${value.type} artifact rules require "field-path" (or deprecated "jsonpath").`,
+            path: ["field-path"],
         });
     }
     if (needsJsonPath && value.pattern) {
@@ -25,6 +27,13 @@ const artifactRuleSchema = zod_1.z
             path: ["pattern"],
         });
     }
+    if (value["field-path"] && value.jsonpath) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: 'Specify only one of "field-path" or deprecated "jsonpath".',
+            path: ["field-path"],
+        });
+    }
     if (value.type === "regex" && !value.pattern) {
         ctx.addIssue({
             code: zod_1.z.ZodIssueCode.custom,
@@ -32,21 +41,25 @@ const artifactRuleSchema = zod_1.z
             path: ["pattern"],
         });
     }
-    if (value.type === "regex" && value.jsonpath) {
+    if (value.type === "regex" && (value["field-path"] || value.jsonpath)) {
         ctx.addIssue({
             code: zod_1.z.ZodIssueCode.custom,
-            message: 'regex artifact rules do not support "jsonpath".',
-            path: ["jsonpath"],
+            message: 'regex artifact rules do not support "field-path" or deprecated "jsonpath".',
+            path: ["field-path"],
         });
     }
 });
-const packageSchema = zod_1.z.object({
+const packageSchema = zod_1.z
+    .object({
     "release-type": zod_1.z.string().optional(),
     "package-name": zod_1.z.string().optional(),
     "exclude-paths": zod_1.z.array(zod_1.z.string()).optional(),
     "extra-files": zod_1.z.array(artifactRuleSchema).optional(),
-});
-exports.configSchema = zod_1.z.object({
+})
+    .strict();
+exports.configSchema = zod_1.z
+    .object({
+    $schema: zod_1.z.string().optional(),
     version: zod_1.z.literal(1),
     "review-mode": zod_1.z.enum(["direct", "review"]).optional(),
     "version-file": zod_1.z.string().optional(),
@@ -61,4 +74,5 @@ exports.configSchema = zod_1.z.object({
     "release-type": zod_1.z.string().optional(),
     packages: zod_1.z.record(zod_1.z.string().min(1), packageSchema).optional(),
     plugins: zod_1.z.array(zod_1.z.string().min(1)).optional(),
-});
+})
+    .strict();

package/dist/domain/strategy/rust.js

@@ -287,6 +287,14 @@ function parseDependencyName(line) {
     const match = line.match(/^\s*(?:"([^"]+)"|'([^']+)'|([A-Za-z0-9_-]+))\s*=/u);
     return match?.[1] ?? match?.[2] ?? match?.[3] ?? null;
 }
+function rewriteCargoVersionRequirement(currentRequirement, nextVersion) {
+    const simpleRequirementMatch = currentRequirement.match(/^(\s*)(\^|~|>=|<=|>|<|=)?(\s*)([0-9A-Za-z.+-]+)(\s*)$/u);
+    if (!simpleRequirementMatch) {
+        return nextVersion;
+    }
+    const [, leadingWhitespace = "", operator = "", operatorWhitespace = "", , trailingWhitespace = "",] = simpleRequirementMatch;
+    return `${leadingWhitespace}${operator}${operatorWhitespace}${nextVersion}${trailingWhitespace}`;
+}
 function writeInternalDependencyVersionInLine(line, dependencyName, versionByDependency) {
     const nextVersion = versionByDependency.get(dependencyName);
     if (!nextVersion) {
@@ -294,19 +302,24 @@ function writeInternalDependencyVersionInLine(line, dependencyName, versionByDep
     }
     const stringVersionMatch = line.match(/^(\s*(?:"[^"]+"|'[^']+'|[A-Za-z0-9_-]+)\s*=\s*)(["'])([^"']*)(\2)(\s*(?:#.*)?)?$/u);
     if (stringVersionMatch) {
-        const [, prefix = "", quote = '"', , , suffix = ""] = stringVersionMatch;
-        return `${prefix}${quote}${nextVersion}${quote}${suffix}`;
+        const [, prefix = "", quote = '"', current = "", , suffix = ""] = stringVersionMatch;
+        const rewrittenRequirement = rewriteCargoVersionRequirement(current, nextVersion);
+        return `${prefix}${quote}${rewrittenRequirement}${quote}${suffix}`;
     }
     const inlineTableMatch = line.match(/^(\s*(?:"[^"]+"|'[^']+'|[A-Za-z0-9_-]+)\s*=\s*\{)(.*)(\}\s*(?:#.*)?)$/u);
-    if (!inlineTableMatch) {
-        return line;
+    if (inlineTableMatch) {
+        const [, prefix = "", tableBody = "", suffix = ""] = inlineTableMatch;
+        const updatedTableBody = tableBody.replace(/(\bversion\s*=\s*)(["'])([^"']*)(\2)/u, (_match, versionPrefix, quote, currentVersion) => `${versionPrefix}${quote}${rewriteCargoVersionRequirement(String(currentVersion), nextVersion)}${quote}`);
+        if (updatedTableBody === tableBody) {
+            return line;
+        }
+        return `${prefix}${updatedTableBody}${suffix}`;
     }
-    const [, prefix = "", tableBody = "", suffix = ""] = inlineTableMatch;
-    const updatedTableBody = tableBody.replace(/(\bversion\s*=\s*)(["'])([^"']*)(\2)/u, `$1$2${nextVersion}$4`);
-    if (updatedTableBody === tableBody) {
+    const updatedTableLine = line.replace(/(\bversion\s*=\s*)(["'])([^"']*)(\2)/u, (_match, versionPrefix, quote, currentVersion) => `${versionPrefix}${quote}${rewriteCargoVersionRequirement(String(currentVersion), nextVersion)}${quote}`);
+    if (updatedTableLine === line) {
         return line;
     }
-    return `${prefix}${updatedTableBody}${suffix}`;
+    return updatedTableLine;
 }
 function writeInternalDependencyVersions(cargoTomlRaw, internalCrates, version) {
     if (internalCrates.size === 0) {

package/dist/types/config.d.ts

@@ -2,6 +2,7 @@ export type ConfigFileFormat = "jsonc" | "json" | "toml" | "js";
 export interface VersionaryArtifactRule {
     type: "json" | "toml" | "yaml" | "regex";
     path: string;
+    "field-path"?: string;
     jsonpath?: string;
     pattern?: string;
 }

package/package.json

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