versionary 0.6.0 → 0.8.0

package/README.md

@@ -125,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]`,
@@ -137,6 +139,8 @@ 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:

package/dist/action/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/action/index.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+function getInput(name) {
+    const canonical = `INPUT_${name.replace(/ /g, "_").toUpperCase()}`;
+    const underscoreAlias = canonical.replace(/-/g, "_");
+    return (process.env[canonical] ??
+        process.env[underscoreAlias] ??
+        process.env[`INPUT_${name.toUpperCase()}`] ??
+        "").trim();
+}
+function runGit(cwd, args) {
+    return (0, node_child_process_1.execFileSync)("git", args, {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+}
+function hasGitConfig(cwd, key) {
+    try {
+        runGit(cwd, ["config", key]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function hasOriginRemote(cwd) {
+    try {
+        runGit(cwd, ["remote", "get-url", "origin"]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function setOutput(name, value) {
+    const outputPath = process.env.GITHUB_OUTPUT;
+    if (!outputPath) {
+        throw new Error("GITHUB_OUTPUT is not set.");
+    }
+    const delimiter = `versionary-${(0, node_crypto_1.randomUUID)()}`;
+    (0, node_fs_1.appendFileSync)(outputPath, `${name}<<${delimiter}\n${value}\n${delimiter}\n`, "utf8");
+}
+function main() {
+    const token = getInput("token") || getInput("github-token");
+    if (!token) {
+        throw new Error("Input required and not supplied: token (or deprecated github-token).");
+    }
+    const versionaryVersion = getInput("versionary-version") || "0.7.0";
+    const cwd = getInput("working-directory") || ".";
+    process.chdir(cwd);
+    if (!hasGitConfig(cwd, "user.name")) {
+        runGit(cwd, ["config", "user.name", "github-actions[bot]"]);
+    }
+    if (!hasGitConfig(cwd, "user.email")) {
+        runGit(cwd, [
+            "config",
+            "user.email",
+            "41898282+github-actions[bot]@users.noreply.github.com",
+        ]);
+    }
+    if (hasOriginRemote(cwd)) {
+        const serverUrl = process.env.GITHUB_SERVER_URL ?? "https://github.com";
+        const repository = process.env.GITHUB_REPOSITORY;
+        if (!repository) {
+            throw new Error("GITHUB_REPOSITORY is not set.");
+        }
+        const base = serverUrl.replace(/^https?:\/\//u, "");
+        const encodedToken = encodeURIComponent(token);
+        runGit(cwd, [
+            "remote",
+            "set-url",
+            "origin",
+            `https://x-access-token:${encodedToken}@${base}/${repository}.git`,
+        ]);
+    }
+    const raw = (0, node_child_process_1.execFileSync)("npx", ["--yes", `versionary@${versionaryVersion}`, "run", "--json"], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+        env: {
+            ...process.env,
+            GITHUB_TOKEN: token,
+        },
+    }).trim();
+    if (!raw) {
+        throw new Error("Versionary returned empty JSON output.");
+    }
+    process.stdout.write(`${raw}\n`);
+    let payload;
+    try {
+        payload = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`Failed parsing Versionary JSON output: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const tagNames = Array.isArray(payload.tagNames)
+        ? payload.tagNames.filter((value) => typeof value === "string")
+        : [];
+    const firstTag = tagNames[0] ?? "";
+    const releaseCreated = payload.releaseCreated === true || tagNames.length > 0 ? "true" : "false";
+    setOutput("action", payload.action ?? "");
+    setOutput("message", payload.message ?? "");
+    setOutput("release_created", releaseCreated);
+    setOutput("tag_name", firstTag);
+    setOutput("tag_names", JSON.stringify(tagNames));
+    setOutput("review_url", payload.reviewUrl ?? "");
+    setOutput("branch", payload.branch ?? "");
+    setOutput("title", payload.title ?? "");
+}
+try {
+    main();
+}
+catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`${message}\n`);
+    process.exit(1);
+}

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.d.ts

@@ -20,4 +20,4 @@ export declare function openOrUpdateSimpleReviewRequest(cwd: string, branch: str
     logger?: VersionaryPluginContext["logger"];
 }): Promise<string>;
 export declare function pushReleaseBranch(cwd: string, branch: string): void;
-export declare function isReleaseCommitMessage(subject: string): boolean;
+export declare function isReleaseCommitMessage(commitMessage: string): boolean;

package/dist/app/release/pr.js

@@ -30,6 +30,7 @@ const SAFE_DIRTY_FILES = new Set([
     "bun.lockb",
     "npm-shrinkwrap.json",
 ]);
+const VERSIONARY_RELEASE_TRAILER = "Versionary-Release: true";
 function listTrackedDirtyFiles(cwd) {
     const status = (0, node_child_process_1.execFileSync)("git", ["status", "--porcelain", "--untracked-files=no"], {
         cwd,
@@ -70,6 +71,25 @@ 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()
@@ -195,6 +215,7 @@ 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);
@@ -208,6 +229,7 @@ function prepareSimpleReleasePr(cwd = process.cwd(), options = {}) {
         ...new Set([
             ...updatedVersionFiles,
             ...updatedArtifactFiles,
+            ...updatedRustLockFiles,
             plan.changelogFile,
         ]),
     ];
@@ -215,7 +237,7 @@ function prepareSimpleReleasePr(cwd = process.cwd(), options = {}) {
         cwd,
         stdio: ["ignore", "pipe", "ignore"],
     });
-    (0, node_child_process_1.execFileSync)("git", ["commit", "-m", title], {
+    (0, node_child_process_1.execFileSync)("git", ["commit", "-m", title, "-m", VERSIONARY_RELEASE_TRAILER], {
         cwd,
         stdio: ["ignore", "pipe", "ignore"],
     });
@@ -306,6 +328,10 @@ function pushReleaseBranch(cwd, branch) {
         stdio: ["ignore", "pipe", "ignore"],
     });
 }
-function isReleaseCommitMessage(subject) {
-    return /^chore\(release\):\s+(?:v\d+\.\d+\.\d+|\S+-v\d+\.\d+\.\d+)(?:,\s+(?:v\d+\.\d+\.\d+|\S+-v\d+\.\d+\.\d+))*$/u.test(subject);
+function isReleaseCommitMessage(commitMessage) {
+    if (/^Versionary-Release:\s*true$/imu.test(commitMessage)) {
+        return true;
+    }
+    const subject = commitMessage.split("\n")[0]?.trim() ?? "";
+    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/release.js

@@ -15,8 +15,8 @@ const runtime_js_1 = require("../../plugins/runtime.js");
 const pr_js_1 = require("./pr.js");
 const recovery_js_1 = require("./recovery.js");
 const state_js_1 = require("./state.js");
-function getHeadCommitSubject(cwd) {
-    return (0, node_child_process_1.execFileSync)("git", ["log", "-1", "--pretty=%s"], {
+function getHeadCommitMessage(cwd) {
+    return (0, node_child_process_1.execFileSync)("git", ["log", "-1", "--pretty=%B"], {
         cwd,
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"],
@@ -54,8 +54,8 @@ async function runSimpleRelease(cwd = process.cwd()) {
     return result.message;
 }
 async function runSimpleReleaseDetailed(cwd = process.cwd(), options = {}) {
-    const subject = getHeadCommitSubject(cwd);
-    if (!(0, pr_js_1.isReleaseCommitMessage)(subject)) {
+    const commitMessage = getHeadCommitMessage(cwd);
+    if (!(0, pr_js_1.isReleaseCommitMessage)(commitMessage)) {
         return {
             action: "release-skipped",
             reason: "No release commit context detected; skipping release stage.",

package/dist/cli/index.js

@@ -33,11 +33,11 @@ async function main() {
     const flags = parseFlags(args);
     const logger = flags.json ? undefined : console;
     if (!command || command === "run") {
-        const subject = (0, node_child_process_1.execFileSync)("git", ["log", "-1", "--pretty=%s"], {
+        const commitMessage = (0, node_child_process_1.execFileSync)("git", ["log", "-1", "--pretty=%B"], {
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"],
         }).trim();
-        if ((0, pr_js_1.isReleaseCommitMessage)(subject)) {
+        if ((0, pr_js_1.isReleaseCommitMessage)(commitMessage)) {
             if (flags.json) {
                 const release = await (0, release_js_1.runSimpleReleaseDetailed)(process.cwd(), {
                     logger,

package/dist/config/schema.d.ts

@@ -31,6 +31,7 @@ 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>>>;

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,11 +41,11 @@ 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"],
         });
     }
 });

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