versionary 0.3.0 → 0.5.0

package/dist/app/release/state.js

@@ -11,6 +11,39 @@ 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");
+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.baselineSha !== undefined &&
+        typeof manifest.baselineSha !== "string") {
+        throw new Error(`Invalid release manifest at ${filePath}: baselineSha 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 (Array.isArray(manifest.releaseTargets)) {
+        for (const target of manifest.releaseTargets) {
+            if (!target || typeof target !== "object" || Array.isArray(target)) {
+                throw new Error(`Invalid release manifest at ${filePath}: each release target must be an object.`);
+            }
+            const record = target;
+            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.`);
+            }
+        }
+    }
+    return manifest;
+}
 function getBaselineStatePath(cwd) {
     const loaded = (0, load_config_js_1.loadConfig)(cwd);
     const configured = loaded.config["baseline-file"];
@@ -32,7 +65,7 @@ function readBaselineSha(cwd = process.cwd()) {
     if (!node_fs_1.default.existsSync(filePath)) {
         return null;
     }
-    const parsed = JSON.parse(node_fs_1.default.readFileSync(filePath, "utf8"));
+    const parsed = parseStateFile(node_fs_1.default.readFileSync(filePath, "utf8"), filePath);
     return parsed.baselineSha ?? null;
 }
 function readReleaseTargets(cwd = process.cwd()) {
@@ -40,7 +73,7 @@ function readReleaseTargets(cwd = process.cwd()) {
     if (!node_fs_1.default.existsSync(filePath)) {
         return [];
     }
-    const parsed = JSON.parse(node_fs_1.default.readFileSync(filePath, "utf8"));
+    const parsed = parseStateFile(node_fs_1.default.readFileSync(filePath, "utf8"), filePath);
     return parsed.releaseTargets ?? [];
 }
 function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets = []) {
@@ -52,6 +85,7 @@ function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets = []) {
         }).trim();
     const filePath = getBaselineStatePath(cwd);
     const next = {
+        manifestVersion: 1,
         baselineSha,
         releaseTargets,
     };

package/dist/cli/index.js

@@ -20,27 +20,81 @@ function printVerifyResult() {
     }
     return result.ok ? 0 : 1;
 }
+function parseFlags(args) {
+    return {
+        json: args.includes("--json"),
+    };
+}
+function emitJson(payload) {
+    process.stdout.write(`${JSON.stringify(payload)}\n`);
+}
 async function main() {
     const [, , command, ...args] = process.argv;
+    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"], {
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"],
         }).trim();
         if ((0, pr_js_1.isReleaseCommitMessage)(subject)) {
+            if (flags.json) {
+                const release = await (0, release_js_1.runSimpleReleaseDetailed)(process.cwd(), {
+                    logger,
+                });
+                if (release.action === "release-skipped") {
+                    emitJson({
+                        action: "release-skipped",
+                        message: release.reason,
+                        releaseCreated: false,
+                        tagNames: [],
+                    });
+                    return 0;
+                }
+                emitJson({
+                    action: "release-published",
+                    message: release.message,
+                    releaseCreated: release.releases.length > 0,
+                    tagNames: release.releases.map((target) => target.tag),
+                });
+                return 0;
+            }
             const message = await (0, release_js_1.runSimpleRelease)(process.cwd());
             console.log(message);
             return 0;
         }
         const plan = (0, plan_js_1.createSimplePlan)();
         if (!plan.nextVersion) {
-            console.log("No releasable commits found. Nothing to do.");
+            const message = "No releasable commits found. Nothing to do.";
+            if (flags.json) {
+                emitJson({
+                    action: "noop",
+                    message,
+                    releaseCreated: false,
+                    tagNames: [],
+                });
+                return 0;
+            }
+            console.log(message);
             return 0;
         }
-        const pr = (0, pr_js_1.prepareSimpleReleasePr)();
+        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);
-        console.log(`Prepared release PR branch ${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 });
+        const message = `Prepared release PR branch ${pr.branch}`;
+        if (flags.json) {
+            emitJson({
+                action: "pr-prepared",
+                message,
+                releaseCreated: false,
+                tagNames: [],
+                reviewUrl: reviewResult,
+                branch: pr.branch,
+                title: pr.title,
+            });
+            return 0;
+        }
+        console.log(message);
         console.log(`Title: ${pr.title}`);
         console.log(reviewResult);
         return 0;
@@ -76,7 +130,7 @@ async function main() {
         return 0;
     }
     if (command === "pr") {
-        const pr = (0, pr_js_1.prepareSimpleReleasePr)();
+        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);
         console.log(`Prepared release PR branch ${pr.branch}`);
@@ -91,7 +145,7 @@ async function main() {
     }
     console.log("Usage: versionary <command>");
     console.log("Commands:");
-    console.log("  run     Auto-dispatch release PR/update or release publish by context");
+    console.log("  run [--json]  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");

package/dist/config/schema.js

@@ -2,11 +2,43 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configSchema = void 0;
 const zod_1 = require("zod");
-const artifactRuleSchema = zod_1.z.object({
+const artifactRuleSchema = zod_1.z
+    .object({
     type: zod_1.z.enum(["json", "toml", "yaml", "regex"]),
     path: zod_1.z.string().min(1),
     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) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `${value.type} artifact rules require "jsonpath".`,
+            path: ["jsonpath"],
+        });
+    }
+    if (needsJsonPath && value.pattern) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `${value.type} artifact rules do not support "pattern".`,
+            path: ["pattern"],
+        });
+    }
+    if (value.type === "regex" && !value.pattern) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: 'regex artifact rules require "pattern".',
+            path: ["pattern"],
+        });
+    }
+    if (value.type === "regex" && value.jsonpath) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: 'regex artifact rules do not support "jsonpath".',
+            path: ["jsonpath"],
+        });
+    }
 });
 const packageSchema = zod_1.z.object({
     "release-type": zod_1.z.string().optional(),

package/dist/domain/release/changelog.js

@@ -95,7 +95,7 @@ function renderSimpleReleaseNotes(input, options = {}) {
     }
     const lines = [header, "", ...sections];
     if (options.includeFooter) {
-        lines.push("This PR was generated by Versionary.");
+        lines.push("\n---\n\nThis PR was generated by [Versionary](https://github.com/jolars/versionary).");
     }
     return lines.join("\n");
 }

package/dist/domain/release/plan.js

@@ -9,7 +9,9 @@ const node_path_1 = __importDefault(require("node:path"));
 const state_js_1 = require("../../app/release/state.js");
 const load_config_js_1 = require("../../config/load-config.js");
 const commits_js_1 = require("../../infra/git/commits.js");
+const package_context_js_1 = require("../strategy/package-context.js");
 const resolve_js_1 = require("../strategy/resolve.js");
+const rust_js_1 = require("../strategy/rust.js");
 const semver_js_1 = require("./semver.js");
 function getMode(configMode) {
     return configMode ?? "independent";
@@ -21,11 +23,6 @@ function createSimplePlan(cwd = process.cwd()) {
     const changelogFile = loaded.config["changelog-file"] ?? "CHANGELOG.md";
     const releaseBranchPrefix = loaded.config["release-branch"] ?? "versionary/release";
     const baselineSha = (0, state_js_1.readBaselineSha)(cwd) ?? loaded.config["bootstrap-sha"] ?? null;
-    const versionPath = node_path_1.default.join(cwd, versionFile);
-    if (!node_fs_1.default.existsSync(versionPath)) {
-        throw new Error(`Versionary requires ${versionFile} to exist.`);
-    }
-    const currentVersion = strategy.readVersion(cwd, loaded.config);
     const allowStableMajor = loaded.config["allow-stable-major"] ?? false;
     const configuredPackages = Object.entries(loaded.config.packages ?? {}).map(([pkgPath, cfg]) => ({
         path: pkgPath,
@@ -34,6 +31,11 @@ function createSimplePlan(cwd = process.cwd()) {
     const monorepoMode = getMode(loaded.config["monorepo-mode"]);
     const hasPackages = configuredPackages.length > 0;
     if (!hasPackages) {
+        const versionPath = node_path_1.default.join(cwd, versionFile);
+        if (!node_fs_1.default.existsSync(versionPath)) {
+            throw new Error(`Versionary requires ${versionFile} to exist.`);
+        }
+        const currentVersion = strategy.readVersion(cwd, loaded.config);
         const parsedCommits = (0, commits_js_1.getParsedCommitsSinceLastTag)(cwd, baselineSha);
         const effectiveCommits = (0, commits_js_1.applyRevertSuppression)(parsedCommits);
         const commits = effectiveCommits;
@@ -55,29 +57,70 @@ function createSimplePlan(cwd = process.cwd()) {
     }
     const packagePlans = configuredPackages
         .map((pkg) => {
+        const packageContext = (0, package_context_js_1.resolvePackageStrategyContext)(loaded.config, pkg.path, pkg);
+        const packageCurrentVersion = packageContext.strategy.readVersion(cwd, packageContext.config);
         const parsedCommits = (0, commits_js_1.getParsedCommitsForPath)(cwd, baselineSha, pkg.path, pkg["exclude-paths"] ?? []);
         const effectiveCommits = (0, commits_js_1.applyRevertSuppression)(parsedCommits);
         const commits = effectiveCommits;
         const releaseType = (0, commits_js_1.analyzeParsedCommits)(parsedCommits);
         const nextVersion = releaseType
-            ? (0, semver_js_1.bumpVersion)(currentVersion, releaseType, { allowStableMajor })
+            ? (0, semver_js_1.bumpVersion)(packageCurrentVersion, releaseType, { allowStableMajor })
             : null;
         return {
             path: pkg.path,
             releaseType,
-            currentVersion,
+            currentVersion: packageCurrentVersion,
             nextVersion,
             commits,
             parsedCommits,
         };
     })
         .sort((a, b) => a.path.localeCompare(b.path));
+    const rustManifestVersionTargets = {};
+    const rustPackageManifestByPath = {};
+    const packageCurrentVersionByPath = {};
+    for (const packagePlan of packagePlans) {
+        const packageConfig = loaded.config.packages?.[packagePlan.path] ?? {};
+        const packageContext = (0, package_context_js_1.resolvePackageStrategyContext)(loaded.config, packagePlan.path, packageConfig);
+        if (packageContext.strategy.name === rust_js_1.rustVersionStrategy.name) {
+            rustPackageManifestByPath[packagePlan.path] = (0, rust_js_1.toCargoManifestPath)(packagePlan.path);
+        }
+        packageCurrentVersionByPath[packagePlan.path] = packagePlan.currentVersion;
+        if (packageContext.strategy.name === rust_js_1.rustVersionStrategy.name) {
+            const next = packagePlan.nextVersion;
+            if (next) {
+                rustManifestVersionTargets[packageContext.versionFile] = next;
+            }
+        }
+    }
+    const impactedRustManifests = (0, rust_js_1.detectRustDependencyImpact)(cwd, rustManifestVersionTargets, Object.values(rustPackageManifestByPath));
+    const impactedPaths = new Set();
+    for (const [pkgPath, manifest] of Object.entries(rustPackageManifestByPath)) {
+        if (impactedRustManifests.includes(manifest)) {
+            impactedPaths.add(pkgPath);
+        }
+    }
+    const adjustedPackages = packagePlans.map((pkgPlan) => {
+        if (pkgPlan.nextVersion || !impactedPaths.has(pkgPlan.path)) {
+            return pkgPlan;
+        }
+        const current = packageCurrentVersionByPath[pkgPlan.path] ?? pkgPlan.currentVersion;
+        return {
+            ...pkgPlan,
+            releaseType: "patch",
+            nextVersion: (0, semver_js_1.bumpVersion)(current, "patch", { allowStableMajor }),
+        };
+    });
     if (monorepoMode === "fixed") {
-        const fixedType = (0, commits_js_1.analyzeParsedCommits)(packagePlans.flatMap((pkgPlan) => pkgPlan.parsedCommits));
+        const fixedType = (0, commits_js_1.analyzeParsedCommits)(adjustedPackages.flatMap((pkgPlan) => pkgPlan.parsedCommits));
+        const fixedBaseVersion = adjustedPackages.find((pkgPlan) => pkgPlan.path === ".")
+            ?.currentVersion ??
+            adjustedPackages[0]?.currentVersion ??
+            "0.0.0";
         const fixedNextVersion = fixedType
-            ? (0, semver_js_1.bumpVersion)(currentVersion, fixedType, { allowStableMajor })
+            ? (0, semver_js_1.bumpVersion)(fixedBaseVersion, fixedType, { allowStableMajor })
             : null;
-        const adjusted = packagePlans.map((pkgPlan) => ({
+        const adjusted = adjustedPackages.map((pkgPlan) => ({
             ...pkgPlan,
             releaseType: fixedType,
             nextVersion: fixedNextVersion,
@@ -85,7 +128,7 @@ function createSimplePlan(cwd = process.cwd()) {
         return {
             mode: "simple",
             releaseType: fixedType,
-            currentVersion,
+            currentVersion: fixedBaseVersion,
             nextVersion: fixedNextVersion,
             versionFile,
             changelogFile,
@@ -95,20 +138,23 @@ function createSimplePlan(cwd = process.cwd()) {
             packages: adjusted,
         };
     }
-    const overallType = (0, commits_js_1.analyzeParsedCommits)(packagePlans.flatMap((pkgPlan) => pkgPlan.parsedCommits));
+    const overallType = (0, commits_js_1.analyzeParsedCommits)(adjustedPackages.flatMap((pkgPlan) => pkgPlan.parsedCommits));
+    const overallBaseVersion = adjustedPackages.find((pkgPlan) => pkgPlan.path === ".")?.currentVersion ??
+        adjustedPackages[0]?.currentVersion ??
+        "0.0.0";
     const overallNextVersion = overallType
-        ? (0, semver_js_1.bumpVersion)(currentVersion, overallType, { allowStableMajor })
+        ? (0, semver_js_1.bumpVersion)(overallBaseVersion, overallType, { allowStableMajor })
         : null;
     return {
         mode: "simple",
         releaseType: overallType,
-        currentVersion,
+        currentVersion: overallBaseVersion,
         nextVersion: overallNextVersion,
         versionFile,
         changelogFile,
         releaseBranchPrefix,
         baselineSha,
-        commits: packagePlans.flatMap((pkgPlan) => pkgPlan.commits),
-        packages: packagePlans,
+        commits: adjustedPackages.flatMap((pkgPlan) => pkgPlan.commits),
+        packages: adjustedPackages,
     };
 }

package/dist/domain/strategy/node.js

@@ -6,10 +6,33 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.nodeVersionStrategy = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
+function readJsonFile(targetPath) {
+    return JSON.parse(node_fs_1.default.readFileSync(targetPath, "utf8"));
+}
+function writeJsonFile(targetPath, value) {
+    node_fs_1.default.writeFileSync(targetPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+function updateNodeLockfileVersion(cwd, version) {
+    const updated = [];
+    for (const lockfile of ["package-lock.json", "npm-shrinkwrap.json"]) {
+        const lockfilePath = node_path_1.default.join(cwd, lockfile);
+        if (!node_fs_1.default.existsSync(lockfilePath)) {
+            continue;
+        }
+        const parsed = readJsonFile(lockfilePath);
+        parsed.version = version;
+        if (parsed.packages?.[""]) {
+            parsed.packages[""].version = version;
+        }
+        writeJsonFile(lockfilePath, parsed);
+        updated.push(lockfile);
+    }
+    return updated;
+}
 exports.nodeVersionStrategy = {
     name: "node",
     getVersionFile(config) {
-        return config["version-file"] ?? "version.txt";
+        return config["version-file"] ?? "package.json";
     },
     readVersion(cwd, config) {
         const versionFile = this.getVersionFile(config);
@@ -17,21 +40,28 @@ exports.nodeVersionStrategy = {
         if (!node_fs_1.default.existsSync(versionPath)) {
             throw new Error(`Versionary requires ${versionFile} to exist.`);
         }
-        return node_fs_1.default.readFileSync(versionPath, "utf8").trim();
+        const packageJson = readJsonFile(versionPath);
+        if (!packageJson.version || typeof packageJson.version !== "string") {
+            throw new Error(`${versionFile} is missing a valid "version" field required by release-type "node".`);
+        }
+        return packageJson.version.trim();
     },
     writeVersion(cwd, config, version) {
         const versionFile = this.getVersionFile(config);
         const versionPath = node_path_1.default.join(cwd, versionFile);
-        node_fs_1.default.writeFileSync(versionPath, `${version}\n`, "utf8");
-        const updatedFiles = [versionFile];
-        const packageJsonPath = node_path_1.default.join(cwd, "package.json");
-        if (node_fs_1.default.existsSync(packageJsonPath)) {
-            const packageJsonRaw = node_fs_1.default.readFileSync(packageJsonPath, "utf8");
-            const packageJson = JSON.parse(packageJsonRaw);
-            packageJson.version = version;
-            node_fs_1.default.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, "utf8");
-            updatedFiles.push("package.json");
+        if (!node_fs_1.default.existsSync(versionPath)) {
+            throw new Error(`Versionary requires ${versionFile} to exist.`);
+        }
+        const packageJson = readJsonFile(versionPath);
+        if (!packageJson.version || typeof packageJson.version !== "string") {
+            throw new Error(`${versionFile} is missing a valid "version" field required by release-type "node".`);
         }
+        packageJson.version = version;
+        writeJsonFile(versionPath, packageJson);
+        const updatedFiles = [
+            versionFile,
+            ...updateNodeLockfileVersion(cwd, version),
+        ];
         return updatedFiles;
     },
 };

package/dist/domain/strategy/package-context.d.ts

@@ -0,0 +1,7 @@
+import type { VersionaryConfig, VersionaryPackage } from "../../types/config.js";
+import type { VersionStrategy } from "./types.js";
+export declare function resolvePackageStrategyContext(rootConfig: VersionaryConfig, packagePath: string, packageConfig: VersionaryPackage): {
+    strategy: VersionStrategy;
+    config: VersionaryConfig;
+    versionFile: string;
+};

package/dist/domain/strategy/package-context.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePackageStrategyContext = resolvePackageStrategyContext;
+const node_path_1 = __importDefault(require("node:path"));
+const resolve_js_1 = require("./resolve.js");
+function withVersionFile(config, versionFile) {
+    return {
+        ...config,
+        "version-file": versionFile,
+    };
+}
+function resolvePackageStrategyContext(rootConfig, packagePath, packageConfig) {
+    const packageReleaseType = packageConfig["release-type"];
+    const baseConfig = packageReleaseType
+        ? {
+            ...rootConfig,
+            "release-type": packageReleaseType,
+        }
+        : { ...rootConfig };
+    const baseStrategy = (0, resolve_js_1.resolveVersionStrategy)(baseConfig);
+    if (!packageReleaseType) {
+        const versionFile = baseConfig["version-file"] ?? baseStrategy.getVersionFile(baseConfig);
+        const config = withVersionFile(baseConfig, versionFile);
+        return {
+            strategy: baseStrategy,
+            config,
+            versionFile,
+        };
+    }
+    const packageVersionFile = packagePath === "."
+        ? (baseConfig["version-file"] ?? baseStrategy.getVersionFile(baseConfig))
+        : node_path_1.default.posix.join(packagePath, baseStrategy.getVersionFile({
+            ...baseConfig,
+            "version-file": undefined,
+        }));
+    const config = withVersionFile({
+        ...baseConfig,
+        packages: undefined,
+    }, packageVersionFile);
+    const strategy = (0, resolve_js_1.resolveVersionStrategy)(config);
+    return {
+        strategy,
+        config,
+        versionFile: packageVersionFile,
+    };
+}

package/dist/domain/strategy/r.d.ts

@@ -0,0 +1,2 @@
+import type { VersionStrategy } from "./types.js";
+export declare const rVersionStrategy: VersionStrategy;

package/dist/domain/strategy/r.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rVersionStrategy = void 0;
+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]) {
+        throw new Error(`${versionFile} is missing a valid "Version:" field required by release-type "r".`);
+    }
+    return match[1].trim();
+}
+function writeDescriptionVersion(content, versionFile, version) {
+    if (!/^Version:\s*/mu.test(content)) {
+        throw new Error(`${versionFile} is missing a valid "Version:" field required by release-type "r".`);
+    }
+    return content.replace(/^Version:\s*.*$/mu, `Version: ${version}`);
+}
+exports.rVersionStrategy = {
+    name: "r",
+    getVersionFile(config) {
+        return config["version-file"] ?? "DESCRIPTION";
+    },
+    readVersion(cwd, config) {
+        const versionFile = this.getVersionFile(config);
+        const versionPath = node_path_1.default.join(cwd, versionFile);
+        if (!node_fs_1.default.existsSync(versionPath)) {
+            throw new Error(`Versionary requires ${versionFile} to exist.`);
+        }
+        return readDescriptionVersion(node_fs_1.default.readFileSync(versionPath, "utf8"), versionFile);
+    },
+    writeVersion(cwd, config, version) {
+        const versionFile = this.getVersionFile(config);
+        const versionPath = node_path_1.default.join(cwd, versionFile);
+        if (!node_fs_1.default.existsSync(versionPath)) {
+            throw new Error(`Versionary requires ${versionFile} to exist.`);
+        }
+        const existing = node_fs_1.default.readFileSync(versionPath, "utf8");
+        const updated = writeDescriptionVersion(existing, versionFile, version);
+        node_fs_1.default.writeFileSync(versionPath, updated, "utf8");
+        return [versionFile];
+    },
+};

package/dist/domain/strategy/resolve.js

@@ -2,10 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveVersionStrategy = resolveVersionStrategy;
 const node_js_1 = require("./node.js");
+const r_js_1 = require("./r.js");
+const rust_js_1 = require("./rust.js");
 const simple_js_1 = require("./simple.js");
 function resolveVersionStrategy(config) {
     if (config["release-type"] === "node") {
         return node_js_1.nodeVersionStrategy;
     }
+    if (config["release-type"] === "rust") {
+        return rust_js_1.rustVersionStrategy;
+    }
+    if (config["release-type"] === "r") {
+        return r_js_1.rVersionStrategy;
+    }
     return simple_js_1.simpleVersionStrategy;
 }

package/dist/domain/strategy/rust.d.ts

@@ -0,0 +1,5 @@
+import type { VersionStrategy } from "./types.js";
+export declare function applyRustWorkspaceDependencyUpdates(cwd: string, manifestToVersion: Record<string, string>): string[];
+export declare function detectRustDependencyImpact(cwd: string, manifestToVersion: Record<string, string>, candidateManifests: string[]): string[];
+export declare function toCargoManifestPath(packagePath: string): string;
+export declare const rustVersionStrategy: VersionStrategy;