versionary 0.11.1 → 0.13.0

package/dist/{domain/release → release}/plan.js

@@ -3,24 +3,35 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChangelogDefaults = getChangelogDefaults;
+exports.createReleasePlan = createReleasePlan;
 exports.createSimplePlan = createSimplePlan;
 const node_fs_1 = __importDefault(require("node:fs"));
 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 load_config_js_1 = require("../config/load-config.js");
+const commits_js_1 = require("../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");
+const state_js_1 = require("./state.js");
 function getMode(configMode) {
     return configMode ?? "independent";
 }
-function createSimplePlan(cwd = process.cwd()) {
+function getChangelogDefaults(config) {
+    const changelogFormat = config["changelog-format"] ??
+        (config["release-type"] === "r" ? "r-news" : "markdown-changelog");
+    const changelogFile = config["changelog-file"] ??
+        (changelogFormat === "r-news" ? "NEWS.md" : "CHANGELOG.md");
+    return { changelogFile, changelogFormat };
+}
+function createReleasePlan(cwd = process.cwd()) {
     const loaded = (0, load_config_js_1.loadConfig)(cwd);
     const strategy = (0, resolve_js_1.resolveVersionStrategy)(loaded.config);
     const versionFile = strategy.getVersionFile(loaded.config);
-    const changelogFile = loaded.config["changelog-file"] ?? "CHANGELOG.md";
+    const { changelogFile, changelogFormat } = getChangelogDefaults(loaded.config);
+    const packageName = loaded.config["release-type"] === "r"
+        ? (strategy.readPackageName?.(cwd, loaded.config) ?? node_path_1.default.basename(cwd))
+        : node_path_1.default.basename(cwd);
     const releaseBranchPrefix = loaded.config["release-branch"] ?? "versionary/release";
     const baselineSha = (0, state_js_1.readBaselineSha)(cwd) ?? loaded.config["bootstrap-sha"] ?? null;
     const releaseTargetByPath = new Map((0, state_js_1.readReleaseTargets)(cwd).map((target) => [target.path, target]));
@@ -49,8 +60,10 @@ function createSimplePlan(cwd = process.cwd()) {
             releaseType,
             currentVersion,
             nextVersion,
+            packageName,
             versionFile,
             changelogFile,
+            changelogFormat,
             releaseBranchPrefix,
             baselineSha,
             commits,
@@ -72,32 +85,45 @@ function createSimplePlan(cwd = process.cwd()) {
             releaseType,
             currentVersion: packageCurrentVersion,
             nextVersion,
+            bumpReason: nextVersion ? "direct" : undefined,
             commits,
             parsedCommits,
         };
     })
         .sort((a, b) => a.path.localeCompare(b.path));
-    const rustManifestVersionTargets = {};
-    const rustPackageManifestByPath = {};
     const packageCurrentVersionByPath = {};
+    const strategyPackagesByName = new Map();
     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);
+        const existingGroup = strategyPackagesByName.get(packageContext.strategy.name);
+        if (existingGroup) {
+            existingGroup.packages.push({
+                packagePath: packagePlan.path,
+                versionFile: packageContext.versionFile,
+                currentVersion: packagePlan.currentVersion,
+                nextVersion: packagePlan.nextVersion,
+            });
         }
-        packageCurrentVersionByPath[packagePlan.path] = packagePlan.currentVersion;
-        if (packageContext.strategy.name === rust_js_1.rustVersionStrategy.name) {
-            const next = packagePlan.nextVersion;
-            if (next) {
-                rustManifestVersionTargets[packageContext.versionFile] = next;
-            }
+        else {
+            strategyPackagesByName.set(packageContext.strategy.name, {
+                strategy: packageContext.strategy,
+                packages: [
+                    {
+                        packagePath: packagePlan.path,
+                        versionFile: packageContext.versionFile,
+                        currentVersion: packagePlan.currentVersion,
+                        nextVersion: packagePlan.nextVersion,
+                    },
+                ],
+            });
         }
+        packageCurrentVersionByPath[packagePlan.path] = packagePlan.currentVersion;
     }
-    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)) {
+    for (const strategyGroup of strategyPackagesByName.values()) {
+        const impacted = strategyGroup.strategy.propagateDependentPatchImpacts?.(cwd, strategyGroup.packages);
+        for (const pkgPath of impacted ?? []) {
             impactedPaths.add(pkgPath);
         }
     }
@@ -110,6 +136,7 @@ function createSimplePlan(cwd = process.cwd()) {
             ...pkgPlan,
             releaseType: "patch",
             nextVersion: (0, semver_js_1.bumpVersion)(current, "patch", { allowStableMajor }),
+            bumpReason: "dependency-propagation",
         };
     });
     if (monorepoMode === "fixed") {
@@ -131,8 +158,10 @@ function createSimplePlan(cwd = process.cwd()) {
             releaseType: fixedType,
             currentVersion: fixedBaseVersion,
             nextVersion: fixedNextVersion,
+            packageName,
             versionFile,
             changelogFile,
+            changelogFormat,
             releaseBranchPrefix,
             baselineSha,
             commits: adjusted.flatMap((pkgPlan) => pkgPlan.commits),
@@ -151,11 +180,17 @@ function createSimplePlan(cwd = process.cwd()) {
         releaseType: overallType,
         currentVersion: overallBaseVersion,
         nextVersion: overallNextVersion,
+        packageName,
         versionFile,
         changelogFile,
+        changelogFormat,
         releaseBranchPrefix,
         baselineSha,
         commits: adjustedPackages.flatMap((pkgPlan) => pkgPlan.commits),
         packages: adjustedPackages,
     };
 }
+/** @deprecated Use createReleasePlan. */
+function createSimplePlan(cwd = process.cwd()) {
+    return createReleasePlan(cwd);
+}

package/dist/{app/release → release}/pr.d.ts

@@ -1,11 +1,11 @@
-import { type SimplePlan } from "../../domain/release/plan.js";
-import type { ParsedCommit } from "../../infra/git/commits.js";
-import type { VersionaryPluginContext } from "../../types/plugins.js";
+import type { ParsedCommit } from "../git/commits.js";
+import type { VersionaryPluginContext } from "../types/plugins.js";
+import { type ReleasePlan, type SimplePlan } from "./plan.js";
 export declare function splitSafeDirtyFiles(files: string[]): {
     ignored: string[];
     blocking: string[];
 };
-export declare function prepareSimpleReleasePr(cwd?: string, options?: {
+export declare function prepareReleasePr(cwd?: string, options?: {
     logger?: VersionaryPluginContext["logger"];
 }): {
     branch: string;
@@ -13,9 +13,17 @@ export declare function prepareSimpleReleasePr(cwd?: string, options?: {
     version: string;
     previousVersion: string;
     commits: ParsedCommit[];
-    plan: SimplePlan;
+    plan: ReleasePlan;
 };
 export declare function renderSimpleReviewRequestBody(version: string, previousVersion: string, commits: ParsedCommit[], plan?: SimplePlan | null, cwd?: string): string;
+export declare function openOrUpdateReviewRequest(cwd: string, branch: string, title: string, version: string, previousVersion: string, commits: ParsedCommit[], plan?: SimplePlan | null, options?: {
+    logger?: VersionaryPluginContext["logger"];
+}): Promise<string>;
+/** @deprecated Use prepareReleasePr. */
+export declare function prepareSimpleReleasePr(cwd?: string, options?: {
+    logger?: VersionaryPluginContext["logger"];
+}): ReturnType<typeof prepareReleasePr>;
+/** @deprecated Use openOrUpdateReviewRequest. */
 export declare function openOrUpdateSimpleReviewRequest(cwd: string, branch: string, title: string, version: string, previousVersion: string, commits: ParsedCommit[], plan?: SimplePlan | null, options?: {
     logger?: VersionaryPluginContext["logger"];
 }): Promise<string>;

package/dist/{app/release → release}/pr.js

@@ -4,24 +4,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.splitSafeDirtyFiles = splitSafeDirtyFiles;
-exports.prepareSimpleReleasePr = prepareSimpleReleasePr;
+exports.prepareReleasePr = prepareReleasePr;
 exports.renderSimpleReviewRequestBody = renderSimpleReviewRequestBody;
+exports.openOrUpdateReviewRequest = openOrUpdateReviewRequest;
+exports.prepareSimpleReleasePr = prepareSimpleReleasePr;
 exports.openOrUpdateSimpleReviewRequest = openOrUpdateSimpleReviewRequest;
 exports.pushReleaseBranch = pushReleaseBranch;
 exports.isReleaseCommitMessage = isReleaseCommitMessage;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const toml_1 = __importDefault(require("@iarna/toml"));
-const load_config_js_1 = require("../../config/load-config.js");
-const changelog_js_1 = require("../../domain/release/changelog.js");
-const plan_js_1 = require("../../domain/release/plan.js");
-const package_context_js_1 = require("../../domain/strategy/package-context.js");
-const resolve_js_1 = require("../../domain/strategy/resolve.js");
-const rust_js_1 = require("../../domain/strategy/rust.js");
-const capabilities_js_1 = require("../../plugins/capabilities.js");
-const runtime_js_1 = require("../../plugins/runtime.js");
+const load_config_js_1 = require("../config/load-config.js");
+const client_js_1 = require("../scm/client.js");
+const package_context_js_1 = require("../strategy/package-context.js");
+const resolve_js_1 = require("../strategy/resolve.js");
 const artifact_rules_js_1 = require("./artifact-rules.js");
+const changelog_js_1 = require("./changelog.js");
+const plan_js_1 = require("./plan.js");
 const state_js_1 = require("./state.js");
 const SAFE_DIRTY_FILES = new Set([
     "pnpm-lock.yaml",
@@ -133,47 +132,12 @@ function normalizeReleaseNameForTag(releaseName) {
         .replaceAll("/", "-")
         .replace(/\s+/gu, "-");
 }
-function readNodePackageName(versionPath) {
-    const raw = JSON.parse(node_fs_1.default.readFileSync(versionPath, "utf8"));
-    const name = raw.name;
-    if (typeof name !== "string" || name.trim().length === 0) {
-        return null;
-    }
-    return name.trim();
-}
-function readRustPackageName(versionPath) {
-    const parsed = toml_1.default.parse(node_fs_1.default.readFileSync(versionPath, "utf8"));
-    const name = parsed.package?.name;
-    if (typeof name !== "string" || name.trim().length === 0) {
-        return null;
-    }
-    return name.trim();
-}
-function readRPackageName(versionPath) {
-    const content = node_fs_1.default.readFileSync(versionPath, "utf8");
-    const match = content.match(/^Package:\s*(.+)\s*$/mu);
-    if (!match?.[1]) {
-        return null;
-    }
-    const name = match[1].trim();
-    return name.length > 0 ? name : null;
-}
-function resolveReleaseName(cwd, packagePath, packageConfig, strategyName, versionFile) {
+function resolveReleaseName(cwd, packagePath, packageConfig, strategy, strategyConfig) {
     const configuredName = packageConfig["package-name"]?.trim();
     if (configuredName) {
         return configuredName;
     }
-    const versionPath = node_path_1.default.join(cwd, versionFile);
-    if (strategyName === "node") {
-        return readNodePackageName(versionPath) ?? packagePath;
-    }
-    if (strategyName === "rust") {
-        return readRustPackageName(versionPath) ?? packagePath;
-    }
-    if (strategyName === "r") {
-        return readRPackageName(versionPath) ?? packagePath;
-    }
-    return packagePath;
+    return strategy.readPackageName?.(cwd, strategyConfig) ?? packagePath;
 }
 function buildReleaseTargets(cwd, plan, loadedConfig) {
     const releaseTargets = plan.packages
@@ -189,7 +153,7 @@ function buildReleaseTargets(cwd, plan, loadedConfig) {
             }
             const packageConfig = loadedConfig.packages?.[pkg.path] ?? {};
             const packageContext = (0, package_context_js_1.resolvePackageStrategyContext)(loadedConfig, pkg.path, packageConfig);
-            const releaseName = resolveReleaseName(cwd, pkg.path, packageConfig, packageContext.strategy.name, packageContext.versionFile);
+            const releaseName = resolveReleaseName(cwd, pkg.path, packageConfig, packageContext.strategy, packageContext.config);
             const tagPrefix = normalizeReleaseNameForTag(releaseName);
             return {
                 path: pkg.path,
@@ -222,7 +186,7 @@ function buildPackageReleaseMetadata(cwd, plan, loadedConfig) {
         }
         const packageConfig = loadedConfig.packages?.[pkg.path] ?? {};
         const packageContext = (0, package_context_js_1.resolvePackageStrategyContext)(loadedConfig, pkg.path, packageConfig);
-        const releaseName = resolveReleaseName(cwd, pkg.path, packageConfig, packageContext.strategy.name, packageContext.versionFile);
+        const releaseName = resolveReleaseName(cwd, pkg.path, packageConfig, packageContext.strategy, packageContext.config);
         metadataByPath[pkg.path] = {
             releaseName,
             tagPrefix: normalizeReleaseNameForTag(releaseName),
@@ -240,8 +204,8 @@ function formatReleaseCommitTitle(releaseTargets) {
     }
     return `chore(release): ${tags[0]} (+${tags.length - 1} more)`;
 }
-function prepareSimpleReleasePr(cwd = process.cwd(), options = {}) {
-    const plan = (0, plan_js_1.createSimplePlan)(cwd);
+function prepareReleasePr(cwd = process.cwd(), options = {}) {
+    const plan = (0, plan_js_1.createReleasePlan)(cwd);
     const loaded = (0, load_config_js_1.loadConfig)(cwd);
     const strategy = (0, resolve_js_1.resolveVersionStrategy)(loaded.config);
     if (!plan.nextVersion) {
@@ -249,7 +213,18 @@ function prepareSimpleReleasePr(cwd = process.cwd(), options = {}) {
     }
     ensureCleanWorktree(cwd, options.logger);
     const updatedVersionFiles = [];
-    const rustManifestVersionTargets = {};
+    const writesByStrategy = new Map();
+    const addStrategyWrite = (strategy, write) => {
+        const existing = writesByStrategy.get(strategy.name);
+        if (existing) {
+            existing.writes.push(write);
+            return;
+        }
+        writesByStrategy.set(strategy.name, {
+            strategy,
+            writes: [write],
+        });
+    };
     if (plan.packages && plan.packages.length > 0) {
         for (const packagePlan of plan.packages) {
             if (!packagePlan.nextVersion) {
@@ -259,31 +234,40 @@ function prepareSimpleReleasePr(cwd = process.cwd(), options = {}) {
             const packageContext = (0, package_context_js_1.resolvePackageStrategyContext)(loaded.config, packagePlan.path, packageConfig);
             const packageUpdated = packageContext.strategy.writeVersion(cwd, packageContext.config, packagePlan.nextVersion);
             updatedVersionFiles.push(...packageUpdated);
-            if (packageContext.strategy.name === rust_js_1.rustVersionStrategy.name) {
-                rustManifestVersionTargets[packageContext.versionFile] =
-                    packagePlan.nextVersion;
-            }
+            addStrategyWrite(packageContext.strategy, {
+                packagePath: packagePlan.path,
+                versionFile: packageContext.versionFile,
+                version: packagePlan.nextVersion,
+            });
         }
-        updatedVersionFiles.push(...(0, rust_js_1.applyRustWorkspaceDependencyUpdates)(cwd, rustManifestVersionTargets));
     }
     else {
         updatedVersionFiles.push(...strategy.writeVersion(cwd, loaded.config, plan.nextVersion));
+        addStrategyWrite(strategy, {
+            packagePath: ".",
+            versionFile: strategy.getVersionFile(loaded.config),
+            version: plan.nextVersion,
+        });
+    }
+    for (const strategyGroup of writesByStrategy.values()) {
+        updatedVersionFiles.push(...(strategyGroup.strategy.finalizeVersionWrites?.(cwd, strategyGroup.writes) ?? []));
     }
     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 section = (0, changelog_js_1.renderReleasePlanChangelog)(plan);
+    (0, changelog_js_1.prependChangelog)(cwd, plan.changelogFile, section, plan.changelogFormat);
     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 { changelogFile: packageChangelogFile } = (0, plan_js_1.getChangelogDefaults)({
+            "release-type": packageConfig["release-type"] ?? loaded.config["release-type"],
+            "changelog-file": packageConfig["changelog-file"] ?? loaded.config["changelog-file"],
+            "changelog-format": packageConfig["changelog-format"] ?? loaded.config["changelog-format"],
+        });
         const packageMetadata = packageReleaseMetadata[packagePlan.path];
         if (!packageMetadata) {
             continue;
@@ -295,7 +279,7 @@ function prepareSimpleReleasePr(cwd = process.cwd(), options = {}) {
             tagPrefix: packageMetadata.tagPrefix,
             cwd,
         });
-        (0, changelog_js_1.prependChangelog)(cwd, node_path_1.default.posix.join(packagePlan.path, packageChangelogFile), packageSection);
+        (0, changelog_js_1.prependChangelog)(cwd, node_path_1.default.posix.join(packagePlan.path, packageChangelogFile), packageSection, "markdown-changelog");
         updatedChangelogFiles.push(node_path_1.default.posix.join(packagePlan.path, packageChangelogFile));
     }
     const releaseTargets = buildReleaseTargets(cwd, plan, loaded.config);
@@ -342,31 +326,65 @@ function prepareSimpleReleasePr(cwd = process.cwd(), options = {}) {
 function renderSimpleReviewRequestBody(version, previousVersion, commits, plan = null, cwd = process.cwd()) {
     const rootPackageLabel = node_path_1.default.basename(cwd);
     const formatPackageLabel = (packagePath) => packagePath === "." ? rootPackageLabel : packagePath;
+    const isDirectBump = (pkg) => pkg.bumpReason === "direct" ||
+        (pkg.bumpReason === undefined &&
+            Boolean(pkg.nextVersion) &&
+            pkg.commits.length > 0);
+    const findPropagatedDependencies = (packagePath, packages) => {
+        const target = packages.find((pkg) => pkg.path === packagePath);
+        if (!target || target.bumpReason !== "dependency-propagation") {
+            return [];
+        }
+        const directSources = packages
+            .filter((pkg) => isDirectBump(pkg))
+            .map((pkg) => ({
+            name: formatPackageLabel(pkg.path),
+            version: pkg.nextVersion ?? "",
+        }))
+            .filter((dependency) => dependency.version.length > 0)
+            .sort((a, b) => a.name.localeCompare(b.name));
+        return directSources;
+    };
+    const relabelSectionHeader = (notes, packageLabel, nextVersion) => {
+        const linkedHeader = notes.match(/^##\s+\[([^\]]+)\]\(([^)]+)\)\s+\(([^)]+)\)/u);
+        if (linkedHeader) {
+            const [, , compareUrl, date] = linkedHeader;
+            return notes.replace(/^##\s+\[[^\]]+\]\([^)]+\)\s+\([^)]+\)/u, `## [${packageLabel}: ${nextVersion}](${compareUrl}) (${date})`);
+        }
+        const plainHeader = notes.match(/^##\s+([^\s]+)\s+\(([^)]+)\)/u);
+        if (plainHeader) {
+            const [, , date] = plainHeader;
+            return notes.replace(/^##\s+[^\s]+\s+\([^)]+\)/u, `## ${packageLabel}: ${nextVersion} (${date})`);
+        }
+        return notes;
+    };
     if (plan?.packages && plan.packages.length > 1) {
-        const sections = plan.packages
-            .filter((pkg) => pkg.nextVersion)
+        const sections = [];
+        const rootPackage = plan.packages.find((pkg) => pkg.path === "." && pkg.nextVersion);
+        if (rootPackage?.nextVersion) {
+            const rootNotes = (0, changelog_js_1.renderReleasePlanChangelog)(plan);
+            sections.push(relabelSectionHeader(rootNotes, formatPackageLabel("."), rootPackage.nextVersion));
+        }
+        const packageSections = plan.packages
+            .filter((pkg) => pkg.path !== "." && pkg.nextVersion)
             .map((pkg) => {
             const packageLabel = formatPackageLabel(pkg.path);
+            const propagatedDependencies = findPropagatedDependencies(pkg.path, plan.packages ?? []);
             const notes = (0, changelog_js_1.renderSimpleReleaseNotes)({
                 currentVersion: pkg.currentVersion,
                 nextVersion: pkg.nextVersion ?? "",
                 commits: pkg.commits,
                 cwd,
+                dependencies: propagatedDependencies,
             }, { includeFooter: false });
-            const linkedHeader = notes.match(/^##\s+\[([^\]]+)\]\(([^)]+)\)\s+\(([^)]+)\)/u);
-            if (linkedHeader) {
-                const [, , compareUrl, date] = linkedHeader;
-                return notes.replace(/^##\s+\[[^\]]+\]\([^)]+\)\s+\([^)]+\)/u, `## [${packageLabel}: ${pkg.nextVersion ?? ""}](${compareUrl}) (${date})`);
-            }
-            const plainHeader = notes.match(/^##\s+([^\s]+)\s+\(([^)]+)\)/u);
-            if (plainHeader) {
-                const [, , date] = plainHeader;
-                return notes.replace(/^##\s+[^\s]+\s+\([^)]+\)/u, `## ${packageLabel}: ${pkg.nextVersion ?? ""} (${date})`);
-            }
-            return notes;
-        })
-            .join("\n\n");
-        return `${sections}\n\nThis PR was generated by Versionary.`;
+            return relabelSectionHeader(notes, packageLabel, pkg.nextVersion ?? "");
+        });
+        sections.push(...packageSections);
+        const bodySections = sections.join("\n\n");
+        if (bodySections.length === 0) {
+            return "This PR was generated by Versionary.";
+        }
+        return `${bodySections}\n\nThis PR was generated by Versionary.`;
     }
     return (0, changelog_js_1.renderSimpleReleaseNotes)({
         currentVersion: previousVersion,
@@ -375,22 +393,14 @@ function renderSimpleReviewRequestBody(version, previousVersion, commits, plan =
         cwd,
     }, { includeFooter: true });
 }
-async function openOrUpdateSimpleReviewRequest(cwd, branch, title, version, previousVersion, commits, plan = null, options = {}) {
+async function openOrUpdateReviewRequest(cwd, branch, title, version, previousVersion, commits, plan = null, options = {}) {
     const loaded = (0, load_config_js_1.loadConfig)(cwd);
     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 pr but no scm.reviewRequest plugin is available.");
-    }
-    const plugin = scmPlugins[0];
-    if (!plugin?.createOrUpdateReviewRequest) {
-        throw new Error(`Plugin "${plugin?.name ?? "unknown"}" does not implement createOrUpdateReviewRequest.`);
-    }
-    const result = await plugin.createOrUpdateReviewRequest({
+    const scmClient = (0, client_js_1.getScmClient)();
+    const result = await scmClient.createOrUpdateReviewRequest({
         baseBranch: process.env.VERSIONARY_BASE_BRANCH ?? "main",
         headBranch: branch,
         title,
@@ -402,6 +412,14 @@ async function openOrUpdateSimpleReviewRequest(cwd, branch, title, version, prev
     });
     return result.url;
 }
+/** @deprecated Use prepareReleasePr. */
+function prepareSimpleReleasePr(cwd = process.cwd(), options = {}) {
+    return prepareReleasePr(cwd, options);
+}
+/** @deprecated Use openOrUpdateReviewRequest. */
+async function openOrUpdateSimpleReviewRequest(cwd, branch, title, version, previousVersion, commits, plan = null, options = {}) {
+    return openOrUpdateReviewRequest(cwd, branch, title, version, previousVersion, commits, plan, options);
+}
 function pushReleaseBranch(cwd, branch) {
     (0, node_child_process_1.execFileSync)("git", ["push", "--force-with-lease", "origin", branch], {
         cwd,

package/dist/{app/release → release}/recovery.d.ts

@@ -1,9 +1,10 @@
-import type { VersionaryScmReleaseMetadataResult } from "../../types/plugins.js";
+import type { VersionaryScmReleaseMetadataResult } from "../types/plugins.js";
 export type TagStepResult = "created" | "exists";
 export interface ReleaseTargetInput {
     tag: string;
     version: string;
     notes: string;
+    draft?: boolean;
 }
 export interface ReleaseExecutionContext {
     createReleaseMetadata: (input: ReleaseTargetInput) => Promise<VersionaryScmReleaseMetadataResult>;

package/dist/{app/release → release}/release.d.ts

@@ -1,8 +1,9 @@
-import type { VersionaryConfig } from "../../types/config.js";
-import type { VersionaryPluginContext } from "../../types/plugins.js";
+import type { VersionaryConfig } from "../types/config.js";
+import type { VersionaryPluginContext } from "../types/plugins.js";
+export declare function extractReleaseNotes(content: string, version: string, changelogFormat: "markdown-changelog" | "r-news"): string;
 export declare function resolveTargetChangelogFile(config: VersionaryConfig, rootChangelogFile: string, targetPath: string): string;
-export declare function runSimpleRelease(cwd?: string): Promise<string>;
-export type SimpleRunReleaseResult = {
+export declare function runRelease(cwd?: string): Promise<string>;
+export type RunReleaseResult = {
     action: "release-skipped";
     reason: string;
 } | {
@@ -22,8 +23,16 @@ export type SimpleRunReleaseResult = {
         metadataStatus: "created" | "exists";
     }[];
 };
-export interface RunSimpleReleaseOptions {
+export interface RunReleaseOptions {
     logger?: VersionaryPluginContext["logger"];
     "dry-run"?: boolean;
 }
+export declare function runReleaseDetailed(cwd?: string, options?: RunReleaseOptions): Promise<RunReleaseResult>;
+/** @deprecated Use RunReleaseResult. */
+export type SimpleRunReleaseResult = RunReleaseResult;
+/** @deprecated Use RunReleaseOptions. */
+export type RunSimpleReleaseOptions = RunReleaseOptions;
+/** @deprecated Use runRelease. */
+export declare function runSimpleRelease(cwd?: string): Promise<string>;
+/** @deprecated Use runReleaseDetailed. */
 export declare function runSimpleReleaseDetailed(cwd?: string, options?: RunSimpleReleaseOptions): Promise<SimpleRunReleaseResult>;