versionary 0.11.0 → 0.12.0

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

@@ -12,16 +12,13 @@ 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 +130,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 +151,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 +184,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),
@@ -249,7 +211,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,21 +232,29 @@ 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);
+    (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 === ".") {
@@ -295,7 +276,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,16 +323,37 @@ 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;
+    };
     if (plan?.packages && plan.packages.length > 1) {
         const sections = plan.packages
             .filter((pkg) => 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) {
@@ -381,16 +383,8 @@ async function openOrUpdateSimpleReviewRequest(cwd, branch, title, version, prev
     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,

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,5 +1,5 @@
-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 resolveTargetChangelogFile(config: VersionaryConfig, rootChangelogFile: string, targetPath: string): string;
 export declare function runSimpleRelease(cwd?: string): Promise<string>;
 export type SimpleRunReleaseResult = {

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

@@ -9,10 +9,10 @@ exports.runSimpleReleaseDetailed = runSimpleReleaseDetailed;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const load_config_js_1 = require("../../config/load-config.js");
-const resolve_js_1 = require("../../domain/strategy/resolve.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 resolve_js_1 = require("../strategy/resolve.js");
+const plan_js_1 = require("./plan.js");
 const pr_js_1 = require("./pr.js");
 const recovery_js_1 = require("./recovery.js");
 const state_js_1 = require("./state.js");
@@ -30,7 +30,12 @@ function readReleaseNotes(cwd, version, changelogFile) {
     }
     const content = node_fs_1.default.readFileSync(changelogPath, "utf8");
     const lines = content.split("\n");
-    const start = lines.findIndex((line) => line.startsWith(`## ${version} -`) || line.startsWith(`## [${version}](`));
+    const shortVersion = version.replace(/\.\d+$/u, "");
+    const start = lines.findIndex((line) => line.startsWith(`## ${version} -`) ||
+        line.startsWith(`## [${version}](`) ||
+        line.startsWith(`# ${shortVersion} -`) ||
+        line.startsWith(`# [${shortVersion}](`) ||
+        new RegExp(`^#\\s+.+\\s+${shortVersion}\\s*$`, "u").test(line));
     if (start < 0) {
         return `Automated release for v${version}`;
     }
@@ -74,7 +79,7 @@ async function runSimpleReleaseDetailed(cwd = process.cwd(), options = {}) {
     }
     const loaded = (0, load_config_js_1.loadConfig)(cwd);
     const strategy = (0, resolve_js_1.resolveVersionStrategy)(loaded.config);
-    const changelogFile = loaded.config["changelog-file"] ?? "CHANGELOG.md";
+    const { changelogFile } = (0, plan_js_1.getChangelogDefaults)(loaded.config);
     const version = strategy.readVersion(cwd, loaded.config);
     const defaultTag = `v${version}`;
     const releaseTargets = (0, state_js_1.readReleaseTargets)(cwd);
@@ -98,16 +103,7 @@ async function runSimpleReleaseDetailed(cwd = process.cwd(), options = {}) {
             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 scmClient = (0, client_js_1.getScmClient)();
     const releases = [];
     for (const target of targets) {
         const targetChangelogFile = resolveTargetChangelogFile(loaded.config, changelogFile, target.path);
@@ -115,8 +111,9 @@ async function runSimpleReleaseDetailed(cwd = process.cwd(), options = {}) {
             tag: target.tag,
             version: target.version,
             notes: readReleaseNotes(cwd, target.version, targetChangelogFile),
+            draft: loaded.config["release-draft"] ?? false,
         }, {
-            createReleaseMetadata: (input) => createReleaseMetadata(input, {
+            createReleaseMetadata: (input) => scmClient.createReleaseMetadata(input, {
                 cwd,
                 logger: options.logger,
             }),

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

@@ -10,7 +10,7 @@ exports.writeBaselineSha = writeBaselineSha;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const load_config_js_1 = require("../../config/load-config.js");
+const load_config_js_1 = require("../config/load-config.js");
 const MANIFEST_VERSION_KEY = "manifest-version";
 const BASELINE_SHA_KEY = "baseline-sha";
 const RELEASE_TARGETS_KEY = "release-targets";

package/dist/{verify → release}/verify-project.js

@@ -7,8 +7,8 @@ exports.verifyProject = verifyProject;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const load_config_js_1 = require("../config/load-config.js");
-const package_context_js_1 = require("../domain/strategy/package-context.js");
-const resolve_js_1 = require("../domain/strategy/resolve.js");
+const package_context_js_1 = require("../strategy/package-context.js");
+const resolve_js_1 = require("../strategy/resolve.js");
 function verifyProject(cwd = process.cwd()) {
     const checks = [];
     const config = (0, load_config_js_1.loadConfig)(cwd);

package/dist/scm/client.d.ts

@@ -0,0 +1,2 @@
+import type { ScmClient } from "./types.js";
+export declare function getScmClient(): ScmClient;

package/dist/scm/client.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScmClient = getScmClient;
+const github_plugin_js_1 = require("./github-plugin.js");
+function getScmClient() {
+    return (0, github_plugin_js_1.createGitHubPlugin)();
+}

package/dist/scm/github-plugin.d.ts

@@ -1,2 +1,3 @@
 import type { VersionaryPluginRuntime } from "../types/plugins.js";
-export declare function createGitHubPlugin(): VersionaryPluginRuntime;
+import type { ScmClient } from "./types.js";
+export declare function createGitHubPlugin(): VersionaryPluginRuntime & ScmClient;

package/dist/scm/github-plugin.js

@@ -90,6 +90,7 @@ function createGitHubPlugin() {
     return {
         name: "github",
         capabilities: ["scm.reviewRequest", "scm.releaseMetadata"],
+        provider: "github",
         async createOrUpdateReviewRequest(input, _context) {
             const repo = getRepoFromEnv();
             const octokit = new rest_1.Octokit({ auth: getGitHubToken() });
@@ -194,6 +195,7 @@ function createGitHubPlugin() {
                     tag_name: input.tag,
                     name: input.tag,
                     body: input.notes,
+                    draft: input.draft ?? false,
                 });
                 data = response.data;
             }

package/dist/scm/types.d.ts

@@ -0,0 +1,37 @@
+export type ScmProvider = "github";
+export interface ScmClientContext {
+    cwd: string;
+    logger?: {
+        info: (message: string) => void;
+        warn: (message: string) => void;
+        error: (message: string) => void;
+    };
+}
+export interface ScmReviewRequestInput {
+    baseBranch: string;
+    headBranch: string;
+    title: string;
+    body: string;
+    labels?: string[];
+}
+export interface ScmReviewRequestResult {
+    id: string;
+    number?: number;
+    url: string;
+    state: "open" | "closed" | "merged";
+}
+export interface ScmReleaseMetadataInput {
+    tag: string;
+    version: string;
+    notes: string;
+    draft?: boolean;
+}
+export interface ScmReleaseMetadataResult {
+    url: string;
+    status?: "created" | "exists";
+}
+export interface ScmClient {
+    provider: ScmProvider;
+    createOrUpdateReviewRequest: (input: ScmReviewRequestInput, context: ScmClientContext) => Promise<ScmReviewRequestResult>;
+    createReleaseMetadata: (input: ScmReleaseMetadataInput, context: ScmClientContext) => Promise<ScmReleaseMetadataResult>;
+}

package/dist/{domain/strategy → strategy}/node.js

@@ -64,4 +64,17 @@ exports.nodeVersionStrategy = {
         ];
         return updatedFiles;
     },
+    readPackageName(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.`);
+        }
+        const packageJson = readJsonFile(versionPath);
+        const name = packageJson.name;
+        if (typeof name !== "string" || name.trim().length === 0) {
+            return null;
+        }
+        return name.trim();
+    },
 };

package/dist/{domain/strategy → strategy}/package-context.d.ts

@@ -1,4 +1,4 @@
-import type { VersionaryConfig, VersionaryPackage } from "../../types/config.js";
+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;

package/dist/{domain/strategy → strategy}/package-context.js

@@ -34,7 +34,7 @@ function resolvePackageStrategyContext(rootConfig, packagePath, packageConfig) {
                 }));
         const config = withVersionFile({
             ...baseConfig,
-            packages: undefined,
+            packages: packagePath === "." ? baseConfig.packages : undefined,
         }, versionFile);
         return {
             strategy: baseStrategy,
@@ -50,7 +50,7 @@ function resolvePackageStrategyContext(rootConfig, packagePath, packageConfig) {
         }));
     const config = withVersionFile({
         ...baseConfig,
-        packages: undefined,
+        packages: packagePath === "." ? baseConfig.packages : undefined,
     }, packageVersionFile);
     const strategy = (0, resolve_js_1.resolveVersionStrategy)(config);
     return {

package/dist/{domain/strategy → strategy}/r.js

@@ -43,4 +43,18 @@ exports.rVersionStrategy = {
         node_fs_1.default.writeFileSync(versionPath, updated, "utf8");
         return [versionFile];
     },
+    readPackageName(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.`);
+        }
+        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;
+    },
 };

package/dist/{domain/strategy → strategy}/resolve.d.ts

@@ -1,3 +1,4 @@
-import type { VersionaryConfig } from "../../types/config.js";
+import type { VersionaryConfig } from "../types/config.js";
 import type { VersionStrategy } from "./types.js";
+export declare function listKnownReleaseTypes(): string[];
 export declare function resolveVersionStrategy(config: VersionaryConfig): VersionStrategy;

package/dist/strategy/resolve.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listKnownReleaseTypes = listKnownReleaseTypes;
+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");
+const strategyRegistry = {
+    simple: simple_js_1.simpleVersionStrategy,
+    node: node_js_1.nodeVersionStrategy,
+    rust: rust_js_1.rustVersionStrategy,
+    r: r_js_1.rVersionStrategy,
+};
+function listKnownReleaseTypes() {
+    return Object.keys(strategyRegistry).sort((a, b) => a.localeCompare(b));
+}
+function resolveVersionStrategy(config) {
+    const releaseType = config["release-type"] ?? "simple";
+    return strategyRegistry[releaseType] ?? simple_js_1.simpleVersionStrategy;
+}

package/dist/{domain/strategy → strategy}/rust.js

@@ -613,4 +613,46 @@ exports.rustVersionStrategy = {
         }
         return updatedFiles.sort((a, b) => a.localeCompare(b));
     },
+    readPackageName(cwd, config) {
+        const versionFile = this.getVersionFile(config);
+        const manifests = collectRustTargetManifests(cwd, versionFile, !config.packages);
+        const selectedManifest = manifests[0];
+        if (!selectedManifest) {
+            throw new Error(`Configured rust target "${versionFile}" did not resolve to a Rust crate manifest.`);
+        }
+        const versionPath = node_path_1.default.join(cwd, selectedManifest);
+        if (!node_fs_1.default.existsSync(versionPath)) {
+            throw new Error(`Versionary requires ${selectedManifest} to exist.`);
+        }
+        const cargoTomlRaw = node_fs_1.default.readFileSync(versionPath, "utf8");
+        if (!isCrateManifest(selectedManifest, cargoTomlRaw)) {
+            return null;
+        }
+        return readCargoPackageName(cargoTomlRaw, selectedManifest);
+    },
+    propagateDependentPatchImpacts(cwd, packages) {
+        const manifestToVersion = {};
+        const candidateManifests = [];
+        const manifestToPath = new Map();
+        for (const pkg of packages) {
+            const manifest = pkg.versionFile;
+            candidateManifests.push(manifest);
+            manifestToPath.set(manifest, pkg.packagePath);
+            if (pkg.nextVersion) {
+                manifestToVersion[manifest] = pkg.nextVersion;
+            }
+        }
+        const impactedManifests = detectRustDependencyImpact(cwd, manifestToVersion, candidateManifests);
+        return impactedManifests
+            .map((manifest) => manifestToPath.get(manifest))
+            .filter((pkgPath) => Boolean(pkgPath))
+            .sort((a, b) => a.localeCompare(b));
+    },
+    finalizeVersionWrites(cwd, writes) {
+        const manifestToVersion = {};
+        for (const write of writes) {
+            manifestToVersion[write.versionFile] = write.version;
+        }
+        return applyRustWorkspaceDependencyUpdates(cwd, manifestToVersion);
+    },
 };

package/dist/strategy/types.d.ts

@@ -0,0 +1,21 @@
+import type { VersionaryConfig } from "../types/config.js";
+export interface StrategyPackagePlanContext {
+    packagePath: string;
+    versionFile: string;
+    currentVersion: string;
+    nextVersion: string | null;
+}
+export interface StrategyVersionWriteContext {
+    packagePath: string;
+    versionFile: string;
+    version: string;
+}
+export interface VersionStrategy {
+    name: string;
+    getVersionFile(config: VersionaryConfig): string;
+    readVersion(cwd: string, config: VersionaryConfig): string;
+    writeVersion(cwd: string, config: VersionaryConfig, version: string): string[];
+    readPackageName?(cwd: string, config: VersionaryConfig): string | null;
+    propagateDependentPatchImpacts?(cwd: string, packages: StrategyPackagePlanContext[]): string[];
+    finalizeVersionWrites?(cwd: string, writes: StrategyVersionWriteContext[]): string[];
+}

package/dist/types/config.d.ts

@@ -1,4 +1,5 @@
 export type ConfigFileFormat = "jsonc" | "json" | "toml" | "js";
+export type VersionaryChangelogFormat = "markdown-changelog" | "r-news";
 export interface VersionaryArtifactRule {
     type: "json" | "toml" | "yaml" | "regex";
     path: string;
@@ -10,6 +11,7 @@ export interface VersionaryPackage {
     "release-type"?: string;
     "package-name"?: string;
     "changelog-file"?: string;
+    "changelog-format"?: VersionaryChangelogFormat;
     "exclude-paths"?: string[];
     "extra-files"?: VersionaryArtifactRule[];
 }
@@ -18,6 +20,8 @@ export interface VersionaryConfig {
     "review-mode"?: "direct" | "pr" | "review";
     "version-file"?: string;
     "changelog-file"?: string;
+    "changelog-format"?: VersionaryChangelogFormat;
+    "release-draft"?: boolean;
     "release-branch"?: string;
     "baseline-file"?: string;
     "bootstrap-sha"?: string;

package/dist/types/plugins.d.ts

@@ -1,37 +1,14 @@
+import type { ScmClientContext, ScmProvider, ScmReleaseMetadataInput, ScmReleaseMetadataResult, ScmReviewRequestInput, ScmReviewRequestResult } from "../scm/types.js";
 export type VersionaryPluginCapability = "scm.reviewRequest" | "scm.releaseMetadata";
-export interface VersionaryScmReviewRequestInput {
-    baseBranch: string;
-    headBranch: string;
-    title: string;
-    body: string;
-    labels?: string[];
-}
-export interface VersionaryScmReviewRequestResult {
-    id: string;
-    number?: number;
-    url: string;
-    state: "open" | "closed" | "merged";
-}
-export interface VersionaryScmReleaseMetadataInput {
-    tag: string;
-    version: string;
-    notes: string;
-}
-export interface VersionaryScmReleaseMetadataResult {
-    url: string;
-    status?: "created" | "exists";
-}
-export interface VersionaryPluginContext {
-    cwd: string;
-    logger?: {
-        info: (message: string) => void;
-        warn: (message: string) => void;
-        error: (message: string) => void;
-    };
-}
+export type VersionaryScmReviewRequestInput = ScmReviewRequestInput;
+export type VersionaryScmReviewRequestResult = ScmReviewRequestResult;
+export type VersionaryScmReleaseMetadataInput = ScmReleaseMetadataInput;
+export type VersionaryScmReleaseMetadataResult = ScmReleaseMetadataResult;
+export type VersionaryPluginContext = ScmClientContext;
 export interface VersionaryPluginRuntime {
     name: string;
     capabilities: VersionaryPluginCapability[];
+    provider?: ScmProvider;
     createOrUpdateReviewRequest?: (input: VersionaryScmReviewRequestInput, context: VersionaryPluginContext) => Promise<VersionaryScmReviewRequestResult>;
     createReleaseMetadata?: (input: VersionaryScmReleaseMetadataInput, context: VersionaryPluginContext) => Promise<VersionaryScmReleaseMetadataResult>;
 }

package/package.json

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

package/dist/app/release/artifact-rules.d.ts

@@ -1,3 +0,0 @@
-import type { SimplePlan } from "../../domain/release/plan.js";
-import type { VersionaryConfig } from "../../types/config.js";
-export declare function applyConfiguredArtifactRules(cwd: string, config: VersionaryConfig, plan: SimplePlan): string[];

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

@@ -1,2 +0,0 @@
-export type { VerifyResult } from "../../verify/verify-project.js";
-export { verifyProject } from "../../verify/verify-project.js";