versionary 0.8.2 → 0.10.0

package/README.md

@@ -22,7 +22,7 @@ Versionary is being built to:
 
 - support both direct releases and release-PR-gated releases
 - work across repository types (Node, Rust, docs/LaTeX, etc.)
-- stay SCM-agnostic at the core, with integrations via plugin capabilities
+- stay SCM-agnostic at the core with built-in integration adapters
   (GitHub first; GitLab/Codeberg later)
 - keep a small, stable core with explicit extension points
 - handle trunk-based development and monorepo workflows cleanly
@@ -40,6 +40,7 @@ Out of scope (intentional):
 
 - publishing artifacts to language registries
 - replacing package-specific publish tooling
+- external/user-provided plugin loading
 
 Use your CI/CD platform for registry publishing, triggered from a created
 release/tag.
@@ -95,12 +96,14 @@ For a quick trial, use:
 - pre-1.0 policy defaults to conservative major handling: for `0.y.z`, breaking
   changes bump to `0.(y+1).0`; set `allow-stable-major: true` to allow explicit
   auto-transition to `1.0.0` on a breaking release
-- review mode (`review-mode`): `review` (PR/MR style) or `direct` (no review
+- review mode (`review-mode`): `pr` (PR/MR style) or `direct` (no review
   request)
 - 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)
+  - per-package `changelog-file` writes package release notes to
+    `<package-path>/<changelog-file>`
 
 Rust strategy examples:
 
@@ -123,6 +126,8 @@ Rust strategy examples:
 Current rust auto-update behavior (phase scope):
 
 - updates crate versions in each targeted crate `[package].version`
+- supports targeted crates using `version.workspace = true` by updating
+  `[workspace.package].version` in the owning workspace manifest
 - 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
@@ -235,7 +240,8 @@ Minimum GitHub token/repo permissions for Versionary-managed metadata:
 
 `review-mode` behavior:
 
-- `review`: `pnpm run run` prepares/updates the release branch and creates or
+- `pr` (preferred; `review` is a backward-compatible alias): `pnpm run run`
+  prepares/updates the release branch and creates or
   updates a release PR
 - `direct`: `pnpm run run` prepares/updates the release branch and skips review
   request creation

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

@@ -33,13 +33,17 @@ function parseFieldPath(fieldPath) {
             const numberMatch = rest.match(/^(\d+)\]/u);
             if (numberMatch) {
                 tokens.push(Number(numberMatch[1]));
-                index += 2 + numberMatch[1].length;
+                index += 2 + numberMatch[1]?.length;
                 continue;
             }
             const keyMatch = rest.match(/^"([^"]+)"\]/u);
             if (keyMatch) {
-                tokens.push(keyMatch[1]);
-                index += 4 + keyMatch[1].length;
+                const key = keyMatch[1];
+                if (!key) {
+                    throw new Error(`Invalid field-path "${fieldPath}" near index ${index}.`);
+                }
+                tokens.push(key);
+                index += 4 + keyMatch[1]?.length;
                 continue;
             }
             throw new Error(`Invalid field-path "${fieldPath}" near index ${index}.`);
@@ -56,6 +60,9 @@ function setVersionAtJsonPath(document, fieldPath, version) {
     let cursor = document;
     for (let index = 0; index < tokens.length - 1; index += 1) {
         const token = tokens[index];
+        if (token === undefined) {
+            throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
+        }
         if (typeof token === "number") {
             if (!Array.isArray(cursor) || token >= cursor.length) {
                 throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
@@ -69,6 +76,9 @@ function setVersionAtJsonPath(document, fieldPath, version) {
         cursor = cursor[token];
     }
     const leaf = tokens.at(-1);
+    if (leaf === undefined) {
+        throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
+    }
     if (typeof leaf === "number") {
         if (!Array.isArray(cursor) || leaf >= cursor.length) {
             throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
@@ -99,7 +109,12 @@ function resolveFieldPath(rule) {
 function parseRegexPattern(pattern) {
     const slashPattern = pattern.match(/^\/((?:\\\/|[^/])+)\/([a-z]*)$/u);
     if (slashPattern) {
-        return new RegExp(slashPattern[1], slashPattern[2]);
+        const source = slashPattern[1];
+        const flags = slashPattern[2];
+        if (!source || flags === undefined) {
+            throw new Error(`Invalid regex pattern "${pattern}".`);
+        }
+        return new RegExp(source, flags);
     }
     return new RegExp(pattern, "m");
 }
@@ -114,6 +129,9 @@ function applyRegexRule(content, pattern, version) {
         throw new Error(`Regex pattern must match exactly one occurrence; matched ${matches.length}.`);
     }
     const match = matches[0];
+    if (!match) {
+        throw new Error("Regex match result missing.");
+    }
     const start = match.index;
     if (start === undefined) {
         throw new Error("Regex match did not include an index.");
@@ -131,6 +149,9 @@ function applyTomlRulePreservingFormatting(content, fieldPath, version) {
         return `${toml_1.default.stringify(parsed)}\n`;
     }
     const key = simplePath[1];
+    if (!key) {
+        throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
+    }
     const linePattern = new RegExp(`^(\\s*${key}\\s*=\\s*)(["'])([^"']*)(\\2)(\\s*(?:#.*)?)$`, "mu");
     const match = content.match(linePattern);
     if (!match) {
@@ -141,6 +162,9 @@ function applyTomlRulePreservingFormatting(content, fieldPath, version) {
 }
 function applyArtifactRuleToContent(content, rule, version) {
     if (rule.type === "regex") {
+        if (!rule.pattern) {
+            throw new Error('regex artifact rules require "pattern".');
+        }
         return applyRegexRule(content, rule.pattern, version);
     }
     if (rule.type === "json") {

package/dist/app/release/pr.js

@@ -71,24 +71,60 @@ function ensureCleanWorktree(cwd, logger) {
         logger?.warn(`Ignoring safe tracked changes before versionary pr:\n${ignored.join("\n")}`);
     }
 }
+function normalizeSlashPath(input) {
+    return input.replaceAll("\\", "/");
+}
+function listCargoLockFiles(cwd) {
+    const lockfiles = [];
+    const queue = [cwd];
+    while (queue.length > 0) {
+        const currentDir = queue.shift();
+        if (!currentDir) {
+            continue;
+        }
+        const entries = node_fs_1.default.readdirSync(currentDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name === ".git") {
+                continue;
+            }
+            const fullPath = node_path_1.default.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                queue.push(fullPath);
+                continue;
+            }
+            if (!entry.isFile() || entry.name !== "Cargo.lock") {
+                continue;
+            }
+            lockfiles.push(normalizeSlashPath(node_path_1.default.relative(cwd, fullPath)));
+        }
+    }
+    return lockfiles.sort((a, b) => a.localeCompare(b));
+}
 function ensureCargoLockUpToDate(cwd) {
-    const lockfilePath = node_path_1.default.join(cwd, "Cargo.lock");
-    if (!node_fs_1.default.existsSync(lockfilePath)) {
+    const lockfiles = listCargoLockFiles(cwd);
+    if (lockfiles.length === 0) {
         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 updatedLockfiles = [];
+    for (const lockfile of lockfiles) {
+        const lockfilePath = node_path_1.default.join(cwd, lockfile);
+        const before = node_fs_1.default.readFileSync(lockfilePath, "utf8");
+        try {
+            (0, node_child_process_1.execFileSync)("cargo", ["generate-lockfile"], {
+                cwd: node_path_1.default.dirname(lockfilePath),
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to refresh ${lockfile} via "cargo generate-lockfile". Ensure cargo is installed and available in PATH. Details: ${message}`);
+        }
+        const after = node_fs_1.default.readFileSync(lockfilePath, "utf8");
+        if (after !== before) {
+            updatedLockfiles.push(lockfile);
+        }
     }
-    const after = node_fs_1.default.readFileSync(lockfilePath, "utf8");
-    return after !== before ? ["Cargo.lock"] : [];
+    return updatedLockfiles;
 }
 function normalizeReleaseNameForTag(releaseName) {
     return releaseName
@@ -178,12 +214,31 @@ function buildReleaseTargets(cwd, plan, loadedConfig) {
     }
     return releaseTargets;
 }
+function buildPackageReleaseMetadata(cwd, plan, loadedConfig) {
+    const metadataByPath = {};
+    for (const pkg of plan.packages ?? []) {
+        if (!pkg.nextVersion || pkg.path === ".") {
+            continue;
+        }
+        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);
+        metadataByPath[pkg.path] = {
+            releaseName,
+            tagPrefix: normalizeReleaseNameForTag(releaseName),
+        };
+    }
+    return metadataByPath;
+}
 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(", ")}`;
+    if (tags.length === 1) {
+        return `chore(release): ${tags[0]}`;
+    }
+    return `chore(release): ${tags[0]} (+${tags.length - 1} more)`;
 }
 function prepareSimpleReleasePr(cwd = process.cwd(), options = {}) {
     const plan = (0, plan_js_1.createSimplePlan)(cwd);
@@ -216,8 +271,33 @@ function prepareSimpleReleasePr(cwd = process.cwd(), options = {}) {
     }
     const updatedArtifactFiles = (0, artifact_rules_js_1.applyConfiguredArtifactRules)(cwd, loaded.config, plan);
     const updatedRustLockFiles = ensureCargoLockUpToDate(cwd);
+    const packageReleaseMetadata = buildPackageReleaseMetadata(cwd, plan, loaded.config);
     const section = (0, changelog_js_1.renderSimpleChangelog)(plan);
     (0, changelog_js_1.prependChangelog)(cwd, plan.changelogFile, section);
+    const updatedChangelogFiles = [plan.changelogFile];
+    for (const packagePlan of plan.packages ?? []) {
+        if (!packagePlan.nextVersion || packagePlan.path === ".") {
+            continue;
+        }
+        const packageConfig = loaded.config.packages?.[packagePlan.path] ?? {};
+        const packageChangelogFile = packageConfig["changelog-file"];
+        if (!packageChangelogFile) {
+            continue;
+        }
+        const packageMetadata = packageReleaseMetadata[packagePlan.path];
+        if (!packageMetadata) {
+            continue;
+        }
+        const packageSection = (0, changelog_js_1.renderPackageChangelogSection)({
+            currentVersion: packagePlan.currentVersion,
+            nextVersion: packagePlan.nextVersion,
+            commits: packagePlan.commits,
+            tagPrefix: packageMetadata.tagPrefix,
+            cwd,
+        });
+        (0, changelog_js_1.prependChangelog)(cwd, node_path_1.default.posix.join(packagePlan.path, packageChangelogFile), packageSection);
+        updatedChangelogFiles.push(node_path_1.default.posix.join(packagePlan.path, packageChangelogFile));
+    }
     const releaseTargets = buildReleaseTargets(cwd, plan, loaded.config);
     const branch = plan.releaseBranchPrefix;
     const title = formatReleaseCommitTitle(releaseTargets);
@@ -230,7 +310,7 @@ function prepareSimpleReleasePr(cwd = process.cwd(), options = {}) {
             ...updatedVersionFiles,
             ...updatedArtifactFiles,
             ...updatedRustLockFiles,
-            plan.changelogFile,
+            ...updatedChangelogFiles,
         ]),
     ];
     (0, node_child_process_1.execFileSync)("git", ["add", ...filesToAdd], {
@@ -297,14 +377,14 @@ function renderSimpleReviewRequestBody(version, previousVersion, commits, plan =
 }
 async function openOrUpdateSimpleReviewRequest(cwd, branch, title, version, previousVersion, commits, plan = null, options = {}) {
     const loaded = (0, load_config_js_1.loadConfig)(cwd);
-    const releaseFlow = loaded.config["review-mode"] ?? "direct";
-    if (releaseFlow !== "review") {
+    const releaseFlow = loaded.config["review-mode"] ?? "pr";
+    if (releaseFlow === "direct") {
         return "Release flow mode is direct; skipping review request creation.";
     }
     const plugins = (0, runtime_js_1.loadRuntimePlugins)();
     const scmPlugins = (0, capabilities_js_1.findPluginsByCapability)(plugins, "scm.reviewRequest");
     if (scmPlugins.length === 0) {
-        throw new Error("review-mode is review but no scm.reviewRequest plugin is available.");
+        throw new Error("review-mode is pr but no scm.reviewRequest plugin is available.");
     }
     const plugin = scmPlugins[0];
     if (!plugin?.createOrUpdateReviewRequest) {
@@ -333,5 +413,5 @@ function isReleaseCommitMessage(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);
+    return /^chore\(release\):\s+(?:(?:v\d+\.\d+\.\d+|\S+-v\d+\.\d+\.\d+)(?:,\s+(?:v\d+\.\d+\.\d+|\S+-v\d+\.\d+\.\d+))*|(?:v\d+\.\d+\.\d+|\S+-v\d+\.\d+\.\d+)\s+\(\+\d+\s+more\))(?:\s+\(#\d+\))?$/u.test(subject);
 }

package/dist/app/release/release.d.ts

@@ -3,6 +3,13 @@ export declare function runSimpleRelease(cwd?: string): Promise<string>;
 export type SimpleRunReleaseResult = {
     action: "release-skipped";
     reason: string;
+} | {
+    action: "release-dry-run";
+    message: string;
+    targets: {
+        tag: string;
+        version: string;
+    }[];
 } | {
     action: "release-published";
     message: string;
@@ -15,5 +22,6 @@ export type SimpleRunReleaseResult = {
 };
 export interface RunSimpleReleaseOptions {
     logger?: VersionaryPluginContext["logger"];
+    "dry-run"?: boolean;
 }
 export declare function runSimpleReleaseDetailed(cwd?: string, options?: RunSimpleReleaseOptions): Promise<SimpleRunReleaseResult>;

package/dist/app/release/release.js

@@ -66,15 +66,6 @@ async function runSimpleReleaseDetailed(cwd = process.cwd(), options = {}) {
     const changelogFile = loaded.config["changelog-file"] ?? "CHANGELOG.md";
     const version = strategy.readVersion(cwd, loaded.config);
     const defaultTag = `v${version}`;
-    const plugins = (0, runtime_js_1.loadRuntimePlugins)();
-    const scmPlugins = (0, capabilities_js_1.findPluginsByCapability)(plugins, "scm.releaseMetadata");
-    if (scmPlugins.length === 0) {
-        throw new Error("No scm.releaseMetadata plugin is available.");
-    }
-    const plugin = scmPlugins[0];
-    if (!plugin?.createReleaseMetadata) {
-        throw new Error(`Plugin "${plugin?.name ?? "unknown"}" does not implement createReleaseMetadata.`);
-    }
     const releaseTargets = (0, state_js_1.readReleaseTargets)(cwd);
     const targets = releaseTargets.length > 0
         ? releaseTargets
@@ -85,6 +76,27 @@ async function runSimpleReleaseDetailed(cwd = process.cwd(), options = {}) {
                 tag: defaultTag,
             },
         ];
+    if (options["dry-run"]) {
+        const targetList = targets.map((target) => `${target.tag} (${target.version})`);
+        return {
+            action: "release-dry-run",
+            targets: targets.map((target) => ({
+                tag: target.tag,
+                version: target.version,
+            })),
+            message: `Dry run: would publish releases ${targetList.join(", ")}`,
+        };
+    }
+    const plugins = (0, runtime_js_1.loadRuntimePlugins)();
+    const scmPlugins = (0, capabilities_js_1.findPluginsByCapability)(plugins, "scm.releaseMetadata");
+    if (scmPlugins.length === 0) {
+        throw new Error("No scm.releaseMetadata plugin is available.");
+    }
+    const plugin = scmPlugins[0];
+    if (!plugin?.createReleaseMetadata) {
+        throw new Error(`Plugin "${plugin?.name ?? "unknown"}" does not implement createReleaseMetadata.`);
+    }
+    const createReleaseMetadata = plugin.createReleaseMetadata;
     const releases = [];
     for (const target of targets) {
         const outcome = await (0, recovery_js_1.executeIdempotentReleaseTarget)(cwd, {
@@ -92,7 +104,10 @@ async function runSimpleReleaseDetailed(cwd = process.cwd(), options = {}) {
             version: target.version,
             notes: readReleaseNotes(cwd, target.version, changelogFile),
         }, {
-            createReleaseMetadata: (input) => plugin.createReleaseMetadata(input, { cwd, logger: options.logger }),
+            createReleaseMetadata: (input) => createReleaseMetadata(input, {
+                cwd,
+                logger: options.logger,
+            }),
             logger: options.logger,
         });
         releases.push({

package/dist/app/release/state.js

@@ -79,7 +79,7 @@ function readReleaseTargets(cwd = process.cwd()) {
     const parsed = parseStateFile(node_fs_1.default.readFileSync(filePath, "utf8"), filePath);
     return parsed[RELEASE_TARGETS_KEY] ?? [];
 }
-function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets = []) {
+function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets) {
     const baselineShaValue = sha ??
         (0, node_child_process_1.execFileSync)("git", ["rev-parse", "HEAD"], {
             cwd,
@@ -87,10 +87,22 @@ function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets = []) {
             stdio: ["ignore", "pipe", "ignore"],
         }).trim();
     const filePath = getBaselineStatePath(cwd);
+    const existing = node_fs_1.default.existsSync(filePath)
+        ? parseStateFile(node_fs_1.default.readFileSync(filePath, "utf8"), filePath)
+        : {};
+    const existingTargets = existing[RELEASE_TARGETS_KEY] ?? [];
+    const nextTargets = releaseTargets === undefined
+        ? existingTargets
+        : [
+            ...new Map([...existingTargets, ...releaseTargets].map((target) => [
+                target.path,
+                target,
+            ])).values(),
+        ].sort((a, b) => a.path.localeCompare(b.path));
     const next = {
         [MANIFEST_VERSION_KEY]: 1,
         [BASELINE_SHA_KEY]: baselineShaValue,
-        [RELEASE_TARGETS_KEY]: releaseTargets,
+        [RELEASE_TARGETS_KEY]: nextTargets,
     };
     node_fs_1.default.writeFileSync(filePath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
 }

package/dist/cli/index.js

@@ -14,15 +14,33 @@ const changelog_js_1 = require("../domain/release/changelog.js");
 const plan_js_1 = require("../domain/release/plan.js");
 function printVerifyResult() {
     const result = (0, verify_js_1.verifyProject)();
-    for (const check of result.checks) {
-        const status = check.ok ? "OK" : "FAIL";
-        console.log(`[${status}] ${check.name} - ${check.details}`);
+    const categories = [
+        { key: "config", title: "Config" },
+        { key: "paths", title: "Paths" },
+        { key: "version-files", title: "Version files" },
+    ];
+    for (const category of categories) {
+        const checks = result.checks.filter((check) => check.category === category.key);
+        if (checks.length === 0) {
+            continue;
+        }
+        console.log(`${category.title}:`);
+        for (const check of checks) {
+            const status = check.ok ? "OK" : "FAIL";
+            console.log(`  [${status}] ${check.name} - ${check.details}`);
+            if (!check.ok && check.remediation) {
+                console.log(`         Fix: ${check.remediation}`);
+            }
+        }
+        console.log("");
     }
+    console.log(result.ok ? "Summary: all checks passed." : "Summary: checks failed.");
     return result.ok ? 0 : 1;
 }
 function parseFlags(args) {
     return {
         json: args.includes("--json"),
+        "dry-run": args.includes("--dry-run"),
     };
 }
 function emitJson(payload) {
@@ -38,9 +56,20 @@ async function main() {
             stdio: ["ignore", "pipe", "ignore"],
         }).trim();
         if ((0, pr_js_1.isReleaseCommitMessage)(commitMessage)) {
+            if (flags["dry-run"] && !flags.json) {
+                const release = await (0, release_js_1.runSimpleReleaseDetailed)(process.cwd(), {
+                    logger,
+                    "dry-run": true,
+                });
+                if (release.action === "release-dry-run") {
+                    console.log(release.message);
+                    return 0;
+                }
+            }
             if (flags.json) {
                 const release = await (0, release_js_1.runSimpleReleaseDetailed)(process.cwd(), {
                     logger,
+                    "dry-run": flags["dry-run"],
                 });
                 if (release.action === "release-skipped") {
                     emitJson({
@@ -51,6 +80,16 @@ async function main() {
                     });
                     return 0;
                 }
+                if (release.action === "release-dry-run") {
+                    emitJson({
+                        action: "release-dry-run",
+                        message: release.message,
+                        releaseCreated: false,
+                        tagNames: release.targets.map((target) => target.tag),
+                        targets: release.targets,
+                    });
+                    return 0;
+                }
                 emitJson({
                     action: "release-published",
                     message: release.message,
@@ -78,6 +117,34 @@ async function main() {
             console.log(message);
             return 0;
         }
+        if (flags["dry-run"]) {
+            const dryRunMessage = `Dry run: would prepare release PR branch ${plan.releaseBranchPrefix} for ${plan.nextVersion}`;
+            if (flags.json) {
+                emitJson({
+                    action: "pr-dry-run",
+                    message: dryRunMessage,
+                    releaseCreated: false,
+                    tagNames: [],
+                    branch: plan.releaseBranchPrefix,
+                    targets: plan.packages
+                        ?.filter((pkg) => pkg.nextVersion)
+                        .map((pkg) => ({
+                        tag: pkg.path === "."
+                            ? `v${pkg.nextVersion ?? ""}`
+                            : `${pkg.path}-v${pkg.nextVersion ?? ""}`,
+                        version: pkg.nextVersion ?? "",
+                    })) ?? [
+                        {
+                            tag: `v${plan.nextVersion}`,
+                            version: plan.nextVersion,
+                        },
+                    ],
+                });
+                return 0;
+            }
+            console.log(dryRunMessage);
+            return 0;
+        }
         const pr = (0, pr_js_1.prepareSimpleReleasePr)(process.cwd(), { logger });
         (0, pr_js_1.pushReleaseBranch)(process.cwd(), pr.branch);
         const reviewResult = await (0, pr_js_1.openOrUpdateSimpleReviewRequest)(process.cwd(), pr.branch, pr.title, pr.version, pr.previousVersion, pr.commits, pr.plan, { logger });
@@ -125,11 +192,20 @@ async function main() {
             : "";
         const heading = "# Changelog\n\n";
         const body = existing.replace(/^# Changelog\s*/u, "");
-        node_fs_1.default.writeFileSync(changelogPath, `${heading}${section}\n${body}`.trimEnd() + "\n", "utf8");
+        node_fs_1.default.writeFileSync(changelogPath, `${`${heading}${section}\n${body}`.trimEnd()}\n`, "utf8");
         console.log(`Updated ${plan.changelogFile}`);
         return 0;
     }
     if (command === "pr") {
+        if (flags["dry-run"]) {
+            const plan = (0, plan_js_1.createSimplePlan)();
+            if (!plan.nextVersion) {
+                console.log("No releasable commits found. Nothing to do.");
+                return 0;
+            }
+            console.log(`Dry run: would prepare release PR branch ${plan.releaseBranchPrefix} for ${plan.nextVersion}`);
+            return 0;
+        }
         const pr = (0, pr_js_1.prepareSimpleReleasePr)(process.cwd(), { logger: console });
         (0, pr_js_1.pushReleaseBranch)(process.cwd(), pr.branch);
         const reviewResult = await (0, pr_js_1.openOrUpdateSimpleReviewRequest)(process.cwd(), pr.branch, pr.title, pr.version, pr.previousVersion, pr.commits, pr.plan);
@@ -139,18 +215,34 @@ async function main() {
         return 0;
     }
     if (command === "release") {
+        if (flags["dry-run"]) {
+            const result = await (0, release_js_1.runSimpleReleaseDetailed)(process.cwd(), {
+                logger,
+                "dry-run": true,
+            });
+            if (result.action === "release-dry-run") {
+                console.log(result.message);
+            }
+            else if (result.action === "release-skipped") {
+                console.log(result.reason);
+            }
+            else {
+                console.log(result.message);
+            }
+            return 0;
+        }
         const message = await (0, release_js_1.runSimpleRelease)(process.cwd());
         console.log(message);
         return 0;
     }
     console.log("Usage: versionary <command>");
     console.log("Commands:");
-    console.log("  run [--json]  Auto-dispatch release PR/update or release publish by context");
+    console.log("  run [--json] [--dry-run]  Auto-dispatch release PR/update or release publish by context");
     console.log("  verify  Validate config and basic repository shape");
     console.log("  plan    Print release plan (simple mode)");
     console.log("  changelog [--write]  Print or write changelog section");
-    console.log("  pr      Prepare release PR commit and branch");
-    console.log("  release Publish release metadata for release commit context");
+    console.log("  pr [--dry-run]      Prepare release PR commit and branch");
+    console.log("  release [--dry-run] Publish release metadata for release commit context");
     return 1;
 }
 main()

package/dist/config/load-config.js

@@ -41,6 +41,9 @@ function loadConfig(cwd = process.cwd()) {
     if (!isRecord(parsed)) {
         throw new Error("Invalid config: expected an object at the root.");
     }
+    if (Object.hasOwn(parsed, "plugins")) {
+        throw new Error('The "plugins" config key is no longer supported. Versionary uses built-in integrations only.');
+    }
     const validated = schema_js_1.configSchema.parse(parsed);
     return {
         path: found.path,

package/dist/config/schema.d.ts

@@ -4,6 +4,7 @@ export declare const configSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     "review-mode": z.ZodOptional<z.ZodEnum<{
         direct: "direct";
+        pr: "pr";
         review: "review";
     }>>;
     "version-file": z.ZodOptional<z.ZodString>;
@@ -22,6 +23,7 @@ export declare const configSchema: z.ZodObject<{
     packages: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         "release-type": z.ZodOptional<z.ZodString>;
         "package-name": z.ZodOptional<z.ZodString>;
+        "changelog-file": z.ZodOptional<z.ZodString>;
         "exclude-paths": z.ZodOptional<z.ZodArray<z.ZodString>>;
         "extra-files": z.ZodOptional<z.ZodArray<z.ZodObject<{
             type: z.ZodEnum<{
@@ -36,6 +38,5 @@ export declare const configSchema: z.ZodObject<{
             pattern: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
     }, z.core.$strict>>>;
-    plugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 export type ConfigSchema = z.infer<typeof configSchema>;

package/dist/config/schema.js

@@ -53,6 +53,7 @@ const packageSchema = zod_1.z
     .object({
     "release-type": zod_1.z.string().optional(),
     "package-name": zod_1.z.string().optional(),
+    "changelog-file": zod_1.z.string().optional(),
     "exclude-paths": zod_1.z.array(zod_1.z.string()).optional(),
     "extra-files": zod_1.z.array(artifactRuleSchema).optional(),
 })
@@ -61,7 +62,7 @@ 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(),
+    "review-mode": zod_1.z.enum(["direct", "pr", "review"]).optional(),
     "version-file": zod_1.z.string().optional(),
     "changelog-file": zod_1.z.string().optional(),
     "release-branch": zod_1.z.string().optional(),
@@ -73,6 +74,5 @@ exports.configSchema = zod_1.z
     "include-commit-authors": zod_1.z.boolean().optional(),
     "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/release/changelog.d.ts

@@ -9,4 +9,11 @@ export declare function renderSimpleReleaseNotes(input: {
     includeFooter?: boolean;
 }): string;
 export declare function renderSimpleChangelog(plan: SimplePlan): string;
+export declare function renderPackageChangelogSection(input: {
+    currentVersion: string;
+    nextVersion: string;
+    commits: ParsedCommit[];
+    tagPrefix: string;
+    cwd?: string;
+}): string;
 export declare function prependChangelog(cwd: string, changelogFile: string, section: string): void;

package/dist/domain/release/changelog.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderSimpleReleaseNotes = renderSimpleReleaseNotes;
 exports.renderSimpleChangelog = renderSimpleChangelog;
+exports.renderPackageChangelogSection = renderPackageChangelogSection;
 exports.prependChangelog = prependChangelog;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
@@ -110,6 +111,24 @@ function renderSimpleChangelog(plan) {
         cwd: process.cwd(),
     });
 }
+function renderPackageChangelogSection(input) {
+    const repoUrl = (0, repo_url_js_1.resolveRepositoryWebBaseUrl)(input.cwd ?? process.cwd());
+    const header = repoUrl
+        ? `## [${input.nextVersion}](${repoUrl}/compare/${input.tagPrefix}-v${input.currentVersion}...${input.tagPrefix}-v${input.nextVersion}) (${formatDate()})`
+        : `## ${input.nextVersion} (${formatDate()})`;
+    const grouped = groupCommitLines(input.commits, repoUrl);
+    const sections = [];
+    if (grouped.breaking.length > 0) {
+        sections.push("### Breaking changes", ...grouped.breaking, "");
+    }
+    if (grouped.features.length > 0) {
+        sections.push("### Features", ...grouped.features, "");
+    }
+    if (grouped.fixes.length > 0) {
+        sections.push("### Bug Fixes", ...grouped.fixes, "");
+    }
+    return [header, "", ...sections].join("\n");
+}
 function prependChangelog(cwd, changelogFile, section) {
     const changelogPath = node_path_1.default.join(cwd, changelogFile);
     const existing = node_fs_1.default.existsSync(changelogPath)

package/dist/domain/strategy/r.js

@@ -8,7 +8,7 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 function readDescriptionVersion(content, versionFile) {
     const match = content.match(/^Version:\s*(.+)\s*$/mu);
-    if (!match || !match[1]) {
+    if (!match?.[1]) {
         throw new Error(`${versionFile} is missing a valid "Version:" field required by release-type "r".`);
     }
     return match[1].trim();

package/dist/domain/strategy/rust.js

@@ -202,19 +202,73 @@ function collectRustTargetManifests(cwd, versionFile, includeWorkspaceMembers) {
     }
     throw new Error(`Configured rust target "${versionFile}" is not a Rust crate manifest. Expected [package].version or [workspace].members with crate Cargo.toml files.`);
 }
-function readCargoVersion(cargoTomlRaw, versionFile) {
-    const { packageTable } = parseCargoManifest(versionFile, cargoTomlRaw);
+function isWorkspaceInheritedVersion(rawVersion) {
+    if (!rawVersion || typeof rawVersion !== "object") {
+        return false;
+    }
+    const versionRecord = rawVersion;
+    return versionRecord.workspace === true;
+}
+function readWorkspacePackageVersion(cargoTomlRaw, versionFile) {
+    const { workspaceTable } = parseCargoManifest(versionFile, cargoTomlRaw);
+    if (!workspaceTable || typeof workspaceTable !== "object") {
+        throw new Error(`${versionFile} is missing [workspace.package].version required by members using version.workspace = true.`);
+    }
+    const workspacePackage = workspaceTable.package && typeof workspaceTable.package === "object"
+        ? workspaceTable.package
+        : null;
+    const rawVersion = workspacePackage?.version;
+    if (typeof rawVersion !== "string" || rawVersion.trim().length === 0) {
+        throw new Error(`${versionFile} is missing [workspace.package].version required by members using version.workspace = true.`);
+    }
+    return rawVersion.trim();
+}
+function findWorkspaceManifestForMember(cwd, memberManifest) {
+    const cwdAbs = node_path_1.default.resolve(cwd);
+    let currentDir = node_path_1.default.resolve(cwd, node_path_1.default.dirname(memberManifest));
+    while (true) {
+        const relativeDir = node_path_1.default.relative(cwdAbs, currentDir);
+        if (relativeDir.startsWith("..")) {
+            break;
+        }
+        const candidatePath = node_path_1.default.join(currentDir, "Cargo.toml");
+        if (node_fs_1.default.existsSync(candidatePath)) {
+            const relativeManifest = normalizeSlashPath(node_path_1.default.relative(cwdAbs, candidatePath));
+            const cargoTomlRaw = node_fs_1.default.readFileSync(candidatePath, "utf8");
+            const parsed = parseCargoManifest(relativeManifest, cargoTomlRaw);
+            if (parsed.workspaceTable) {
+                return relativeManifest;
+            }
+        }
+        if (currentDir === cwdAbs) {
+            break;
+        }
+        const parentDir = node_path_1.default.dirname(currentDir);
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+    }
+    throw new Error(`${memberManifest} uses version.workspace = true, but no workspace Cargo.toml with [workspace.package].version was found between that crate and repository root.`);
+}
+function readResolvedCargoVersion(cwd, manifest, cargoTomlRaw) {
+    const { packageTable } = parseCargoManifest(manifest, cargoTomlRaw);
     if (!packageTable || typeof packageTable !== "object") {
-        throw new Error(`${versionFile} is missing [package].version. Add [package] with a SemVer version.`);
+        throw new Error(`${manifest} is missing [package].version. Add [package] with a SemVer version.`);
     }
     const rawVersion = packageTable.version;
     if (rawVersion === undefined) {
-        throw new Error(`${versionFile} is missing [package].version. Add [package] with a SemVer version.`);
+        throw new Error(`${manifest} is missing [package].version. Add [package] with a SemVer version.`);
     }
-    if (typeof rawVersion !== "string" || rawVersion.trim().length === 0) {
-        throw new Error(`${versionFile} has invalid [package].version. Expected a non-empty SemVer string.`);
+    if (typeof rawVersion === "string" && rawVersion.trim().length > 0) {
+        return rawVersion.trim();
     }
-    return rawVersion.trim();
+    if (!isWorkspaceInheritedVersion(rawVersion)) {
+        throw new Error(`${manifest} has invalid [package].version. Expected a non-empty SemVer string or version.workspace = true.`);
+    }
+    const workspaceManifest = findWorkspaceManifestForMember(cwd, manifest);
+    const workspaceRaw = node_fs_1.default.readFileSync(node_path_1.default.join(cwd, workspaceManifest), "utf8");
+    return readWorkspacePackageVersion(workspaceRaw, workspaceManifest);
 }
 function readCargoPackageName(cargoTomlRaw, versionFile) {
     const { packageTable } = parseCargoManifest(versionFile, cargoTomlRaw);
@@ -272,6 +326,56 @@ function writeCargoVersion(cargoTomlRaw, versionFile, version) {
     }
     return updated;
 }
+function writeWorkspacePackageVersion(cargoTomlRaw, versionFile, version) {
+    const lineEnding = cargoTomlRaw.includes("\r\n") ? "\r\n" : "\n";
+    const hasFinalLineEnding = cargoTomlRaw.endsWith("\n") || cargoTomlRaw.endsWith("\r\n");
+    const lines = cargoTomlRaw.split(/\r?\n/u);
+    let inWorkspacePackageSection = false;
+    let foundWorkspacePackageSection = false;
+    let replacedVersion = false;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        const sectionMatch = line.match(/^\s*\[([^\]]+)\]\s*(?:#.*)?$/u);
+        if (sectionMatch) {
+            const section = sectionMatch[1]?.trim();
+            inWorkspacePackageSection = section === "workspace.package";
+            if (inWorkspacePackageSection) {
+                foundWorkspacePackageSection = true;
+            }
+            continue;
+        }
+        if (!inWorkspacePackageSection) {
+            continue;
+        }
+        const versionMatch = line.match(/^(\s*version\s*=\s*)(["'])([^"']*)(\2)(\s*(?:#.*)?)?$/u);
+        if (!versionMatch) {
+            continue;
+        }
+        const [, prefix = "", quote = '"', , , suffix = ""] = versionMatch;
+        lines[index] = `${prefix}${quote}${version}${quote}${suffix}`;
+        replacedVersion = true;
+        break;
+    }
+    if (!foundWorkspacePackageSection || !replacedVersion) {
+        throw new Error(`${versionFile} is missing [workspace.package].version required by members using version.workspace = true.`);
+    }
+    let updated = lines.join(lineEnding);
+    if (hasFinalLineEnding && !updated.endsWith(lineEnding)) {
+        updated += lineEnding;
+    }
+    if (!hasFinalLineEnding && updated.endsWith(lineEnding)) {
+        updated = updated.slice(0, -lineEnding.length);
+    }
+    return updated;
+}
+function usesWorkspaceInheritedVersion(cargoTomlRaw, versionFile) {
+    const { packageTable } = parseCargoManifest(versionFile, cargoTomlRaw);
+    if (!packageTable || typeof packageTable !== "object") {
+        return false;
+    }
+    const rawVersion = packageTable.version;
+    return isWorkspaceInheritedVersion(rawVersion);
+}
 function isDependencySection(section) {
     if (ROOT_DEPENDENCY_SECTIONS.has(section)) {
         return true;
@@ -450,13 +554,14 @@ exports.rustVersionStrategy = {
             throw new Error(`Configured rust target "${versionFile}" did not resolve to a Rust crate manifest.`);
         }
         const cargoTomlRaw = node_fs_1.default.readFileSync(node_path_1.default.join(cwd, selectedManifest), "utf8");
-        return readCargoVersion(cargoTomlRaw, selectedManifest);
+        return readResolvedCargoVersion(cwd, selectedManifest, cargoTomlRaw);
     },
     writeVersion(cwd, config, version) {
         const versionFile = this.getVersionFile(config);
         const manifests = collectRustTargetManifests(cwd, versionFile, !config.packages);
         const updatedFiles = [];
         const internalCrates = new Set();
+        const workspaceManifestsToUpdate = new Set();
         for (const manifest of manifests) {
             const versionPath = node_path_1.default.join(cwd, manifest);
             if (!node_fs_1.default.existsSync(versionPath)) {
@@ -467,6 +572,7 @@ exports.rustVersionStrategy = {
                 continue;
             }
             internalCrates.add(readCargoPackageName(cargoTomlRaw, manifest));
+            readResolvedCargoVersion(cwd, manifest, cargoTomlRaw);
         }
         for (const manifest of manifests) {
             const versionPath = node_path_1.default.join(cwd, manifest);
@@ -477,10 +583,30 @@ exports.rustVersionStrategy = {
             if (!isCrateManifest(manifest, cargoTomlRaw)) {
                 continue;
             }
-            readCargoVersion(cargoTomlRaw, manifest);
-            const updatedCargoToml = writeInternalDependencyVersions(writeCargoVersion(cargoTomlRaw, manifest, version), internalCrates, version);
-            node_fs_1.default.writeFileSync(versionPath, updatedCargoToml, "utf8");
-            updatedFiles.push(manifest);
+            let updatedCargoToml = cargoTomlRaw;
+            if (usesWorkspaceInheritedVersion(cargoTomlRaw, manifest)) {
+                workspaceManifestsToUpdate.add(findWorkspaceManifestForMember(cwd, manifest));
+            }
+            else {
+                updatedCargoToml = writeCargoVersion(updatedCargoToml, manifest, version);
+            }
+            updatedCargoToml = writeInternalDependencyVersions(updatedCargoToml, internalCrates, version);
+            if (updatedCargoToml !== cargoTomlRaw) {
+                node_fs_1.default.writeFileSync(versionPath, updatedCargoToml, "utf8");
+                updatedFiles.push(manifest);
+            }
+        }
+        for (const workspaceManifest of workspaceManifestsToUpdate) {
+            const workspacePath = node_path_1.default.join(cwd, workspaceManifest);
+            if (!node_fs_1.default.existsSync(workspacePath)) {
+                continue;
+            }
+            const workspaceRaw = node_fs_1.default.readFileSync(workspacePath, "utf8");
+            const updatedWorkspaceToml = writeInternalDependencyVersions(writeWorkspacePackageVersion(workspaceRaw, workspaceManifest, version), internalCrates, version);
+            if (updatedWorkspaceToml !== workspaceRaw) {
+                node_fs_1.default.writeFileSync(workspacePath, updatedWorkspaceToml, "utf8");
+                updatedFiles.push(workspaceManifest);
+            }
         }
         if (updatedFiles.length === 0) {
             throw new Error(`Configured rust target "${versionFile}" did not resolve to a Rust crate manifest to update.`);

package/dist/infra/scm/runtime.d.ts

@@ -1,2 +1,2 @@
 import type { VersionaryPluginRuntime } from "../../types/plugins.js";
-export declare function loadRuntimePlugins(cwd?: string): VersionaryPluginRuntime[];
+export declare function loadRuntimePlugins(): VersionaryPluginRuntime[];

package/dist/infra/scm/runtime.js

@@ -1,24 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadRuntimePlugins = loadRuntimePlugins;
-const load_config_js_1 = require("../../config/load-config.js");
 const plugin_js_1 = require("./github/plugin.js");
-const BUILTIN_PLUGIN_FACTORIES = {
-    github: plugin_js_1.createGitHubPlugin,
-};
-function loadRuntimePlugins(cwd = process.cwd()) {
-    const loaded = (0, load_config_js_1.loadConfig)(cwd);
-    const configured = loaded.config.plugins ?? [];
-    const plugins = [(0, plugin_js_1.createGitHubPlugin)()];
-    const seen = new Set(plugins.map((plugin) => plugin.name));
-    for (const name of configured) {
-        const factory = BUILTIN_PLUGIN_FACTORIES[name];
-        if (!factory || seen.has(name)) {
-            continue;
-        }
-        const plugin = factory();
-        plugins.push(plugin);
-        seen.add(plugin.name);
-    }
-    return plugins;
+function loadRuntimePlugins() {
+    return [(0, plugin_js_1.createGitHubPlugin)()];
 }

package/dist/types/config.d.ts

@@ -9,12 +9,13 @@ export interface VersionaryArtifactRule {
 export interface VersionaryPackage {
     "release-type"?: string;
     "package-name"?: string;
+    "changelog-file"?: string;
     "exclude-paths"?: string[];
     "extra-files"?: VersionaryArtifactRule[];
 }
 export interface VersionaryConfig {
     version: 1;
-    "review-mode"?: "direct" | "review";
+    "review-mode"?: "direct" | "pr" | "review";
     "version-file"?: string;
     "changelog-file"?: string;
     "release-branch"?: string;
@@ -26,7 +27,6 @@ export interface VersionaryConfig {
     "include-commit-authors"?: boolean;
     "release-type"?: string;
     packages?: Record<string, VersionaryPackage>;
-    plugins?: string[];
 }
 export interface LoadedConfig {
     path: string;

package/dist/verify/verify-project.d.ts

@@ -4,6 +4,8 @@ export interface VerifyResult {
         name: string;
         ok: boolean;
         details: string;
+        category: "config" | "paths" | "version-files";
+        remediation?: string;
     }>;
 }
 export declare function verifyProject(cwd?: string): VerifyResult;

package/dist/verify/verify-project.js

@@ -16,6 +16,7 @@ function verifyProject(cwd = process.cwd()) {
         name: "config-load",
         ok: true,
         details: `Loaded ${node_path_1.default.basename(config.path)} (${config.format})`,
+        category: "config",
     });
     const strategy = (0, resolve_js_1.resolveVersionStrategy)(config.config);
     const versionFile = strategy.getVersionFile(config.config);
@@ -24,6 +25,10 @@ function verifyProject(cwd = process.cwd()) {
         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 (config.config.packages) {
         for (const [pkgPathRaw, packageConfig] of Object.entries(config.config.packages)) {
@@ -33,6 +38,10 @@ function verifyProject(cwd = process.cwd()) {
                 name: `package-path:${pkgPathRaw}`,
                 ok: exists,
                 details: exists ? "Path exists" : `Missing path: ${pkgPathRaw}`,
+                category: "paths",
+                remediation: exists
+                    ? undefined
+                    : `Create ${pkgPathRaw} or remove/rename this entry under "packages" in versionary config.`,
             });
             if (exists) {
                 const packageContext = (0, package_context_js_1.resolvePackageStrategyContext)(config.config, pkgPathRaw, packageConfig);
@@ -44,6 +53,10 @@ function verifyProject(cwd = process.cwd()) {
                     details: packageVersionExists
                         ? "Version file exists"
                         : `Missing ${packageVersionFile}`,
+                    category: "version-files",
+                    remediation: packageVersionExists
+                        ? undefined
+                        : `Create ${packageVersionFile} or adjust package release settings ("release-type"/"version-file") for ${pkgPathRaw}.`,
                 });
             }
         }

package/package.json

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