versionary 0.3.0 → 0.5.0

package/README.md

@@ -72,7 +72,7 @@ Configuration is loaded from `versionary.jsonc` by default (or
 
 Schema URL for editor support:
 
-- `https://raw.githubusercontent.com/jolars/versionary/main/schemas/versionary-schema.json`
+- `https://raw.githubusercontent.com/jolars/versionary/main/schemas/config.json`
 
 ## Config (manifest style)
 
@@ -82,6 +82,10 @@ For a quick trial, use:
 - `changelog-file` (default `CHANGELOG.md`) as release notes output
 - `release-type: "node"` uses `package.json` as version source and updates it
   during release PR prep
+- `release-type: "r"` uses `DESCRIPTION` as version source and updates the
+  `Version:` field
+- `release-type: "rust"` uses Cargo manifests (`Cargo.toml`) as version source;
+  `version-file` must point to a `Cargo.toml` (default: `Cargo.toml`)
 - simple/default strategy keeps `version.txt` as source of truth and does not
   update `package.json`
 - stable release branch (`release-branch`, default: `versionary/release`) so
@@ -97,6 +101,41 @@ For a quick trial, use:
   - `independent` computes package bumps per path
   - `fixed` computes one shared bump across configured package paths
 
+Rust strategy examples:
+
+```jsonc
+// Single crate
+{
+  "release-type": "rust",
+  "version-file": "Cargo.toml"
+}
+```
+
+```jsonc
+// Workspace root (virtual or root crate + members)
+{
+  "release-type": "rust",
+  "version-file": "Cargo.toml"
+}
+```
+
+Current rust auto-update behavior (phase scope):
+
+- updates crate versions in each targeted crate `[package].version`
+- updates internal workspace dependency versions when the dependency name
+  matches another targeted crate name
+- applies dependency version rewrites in:
+  - `[dependencies]`, `[dev-dependencies]`, `[build-dependencies]`
+  - `[target.*.dependencies]`, `[target.*.dev-dependencies]`,
+    `[target.*.build-dependencies]`
+
+Current rust non-goals/limits:
+
+- does not update external dependency versions
+- does not update `workspace.dependencies`
+- does not add missing `version = ...` fields to dependency inline tables
+- does not perform Cargo publish/release to crates.io
+
 ## Commit parsing and release analysis
 
 Release planning is based on Conventional Commit parsing semantics:
@@ -105,20 +144,21 @@ Release planning is based on Conventional Commit parsing semantics:
 - exposes structured parsed fields (`header`, `body`, `footer`, `type`, `scope`,
   `description`, `notes`, `references`, `mentions`, `revert`)
 - separates parser output from release policy mapping (`inferReleaseType*`)
-- recognizes breaking changes from `!` and `BREAKING CHANGE` /
-  `BREAKING-CHANGE` footers
+- recognizes breaking changes from `!` and `BREAKING CHANGE` / `BREAKING-CHANGE`
+  footers
 - maps release impact as `feat => minor`, `fix|perf => patch`, breaking => major
 - treats `revert:` as non-releasable commits
-- suppresses commits that are reverted within the analyzed release window so they
-  do not affect bump/changelog output
-- emits parser diagnostics for malformed headers/footers/references and ambiguous
-  revert messages
+- suppresses commits that are reverted within the analyzed release window so
+  they do not affect bump/changelog output
+- emits parser diagnostics for malformed headers/footers/references and
+  ambiguous revert messages
 
 Commands:
 
 - `pnpm verify`
 - `pnpm run` (default orchestration: no-op, create/update release PR, or publish
   release based on context)
+- `pnpm run -- --json` (machine-readable orchestration result)
 - `pnpm plan`
 - `pnpm changelog -- --write`
 - `pnpm pr`
@@ -133,8 +173,8 @@ Subsequent runs use the baseline state file.
 
 ## Release retry and recovery behavior
 
-Release publish (`pnpm release` or the publish path in `pnpm run`) is
-idempotent by target tag:
+Release publish (`pnpm release` or the publish path in `pnpm run`) is idempotent
+by target tag:
 
 - if a tag already exists, Versionary reuses it rather than recreating it
 - if release metadata already exists for the tag (e.g., GitHub Release), it is
@@ -188,18 +228,10 @@ steps:
     with:
       fetch-depth: 0
       fetch-tags: true
-  - uses: pnpm/action-setup@v6
-  - uses: actions/setup-node@v6
+  - id: versionary
+    uses: jolars/versionary@v1
     with:
-      node-version-file: .nvmrc
-      cache: pnpm
-  - run: pnpm install --frozen-lockfile --ignore-scripts
-  - run: |
-      git config user.name "github-actions[bot]"
-      git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
-      pnpm run run
-    env:
-      GITHUB_TOKEN: ${{ secrets.RELEASE_TOKEN }}
+      github-token: ${{ secrets.RELEASE_TOKEN }}
 ```
 
 ```yaml
@@ -212,17 +244,28 @@ steps:
     with:
       fetch-depth: 0
       fetch-tags: true
-  - uses: pnpm/action-setup@v6
-  - uses: actions/setup-node@v6
+  - id: versionary
+    uses: jolars/versionary@v1
     with:
-      node-version-file: .nvmrc
-      cache: pnpm
-  - run: pnpm install --frozen-lockfile --ignore-scripts
-  - run: pnpm run run
-    env:
-      GITHUB_TOKEN: ${{ secrets.RELEASE_TOKEN }}
+      github-token: ${{ secrets.RELEASE_TOKEN }}
+  - if: ${{ steps.versionary.outputs.release_created == 'true' }}
+    run: echo "Released ${{ steps.versionary.outputs.tag_name }}"
 ```
 
+Action outputs:
+
+- `action`: `noop`, `pr-prepared`, `release-published`, `release-skipped`
+- `message`: human-readable summary
+- `release_created`: `"true"` when at least one release was published
+- `tag_name`: first published tag (for single-target flows)
+- `tag_names`: JSON array of published tags
+- `review_url`: review request URL when PR flow runs
+
+For GitHub Action consumers, publish immutable tags (for example `v1.2.3`) and
+maintain a moving major tag (`v1`, `v2`, ...). A small release-triggered
+workflow should update `v<major>` to the latest release tag so `uses:
+jolars/versionary@v1` stays current without breaking major compatibility.
+
 Package publication is intentionally out of scope in the current release flow.
 Use separate CI workflows for publishing after Versionary has prepared/tagged
 the release.

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

@@ -0,0 +1,3 @@
+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/artifact-rules.js

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyConfiguredArtifactRules = applyConfiguredArtifactRules;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const toml_1 = __importDefault(require("@iarna/toml"));
+const yaml_1 = __importDefault(require("yaml"));
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function parseJsonPath(jsonpath) {
+    if (!jsonpath.startsWith("$")) {
+        throw new Error(`Invalid jsonpath "${jsonpath}". Must start with "$".`);
+    }
+    const tokens = [];
+    let index = 1;
+    while (index < jsonpath.length) {
+        const current = jsonpath[index];
+        if (current === ".") {
+            const keyMatch = jsonpath.slice(index + 1).match(/^[A-Za-z0-9_-]+/u);
+            if (!keyMatch) {
+                throw new Error(`Invalid jsonpath "${jsonpath}" near index ${index}.`);
+            }
+            tokens.push(keyMatch[0]);
+            index += 1 + keyMatch[0].length;
+            continue;
+        }
+        if (current === "[") {
+            const rest = jsonpath.slice(index + 1);
+            const numberMatch = rest.match(/^(\d+)\]/u);
+            if (numberMatch) {
+                tokens.push(Number(numberMatch[1]));
+                index += 2 + numberMatch[1].length;
+                continue;
+            }
+            const keyMatch = rest.match(/^"([^"]+)"\]/u);
+            if (keyMatch) {
+                tokens.push(keyMatch[1]);
+                index += 4 + keyMatch[1].length;
+                continue;
+            }
+            throw new Error(`Invalid jsonpath "${jsonpath}" near index ${index}.`);
+        }
+        throw new Error(`Invalid jsonpath "${jsonpath}" near index ${index}.`);
+    }
+    if (tokens.length === 0) {
+        throw new Error(`Invalid jsonpath "${jsonpath}". Path must target a field.`);
+    }
+    return tokens;
+}
+function setVersionAtJsonPath(document, jsonpath, version) {
+    const tokens = parseJsonPath(jsonpath);
+    let cursor = document;
+    for (let index = 0; index < tokens.length - 1; index += 1) {
+        const token = tokens[index];
+        if (typeof token === "number") {
+            if (!Array.isArray(cursor) || token >= cursor.length) {
+                throw new Error(`jsonpath "${jsonpath}" does not resolve to an existing field.`);
+            }
+            cursor = cursor[token];
+            continue;
+        }
+        if (!isRecord(cursor) || !(token in cursor)) {
+            throw new Error(`jsonpath "${jsonpath}" does not resolve to an existing field.`);
+        }
+        cursor = cursor[token];
+    }
+    const leaf = tokens.at(-1);
+    if (typeof leaf === "number") {
+        if (!Array.isArray(cursor) || leaf >= cursor.length) {
+            throw new Error(`jsonpath "${jsonpath}" does not resolve to an existing field.`);
+        }
+        const current = cursor[leaf];
+        if (typeof current !== "string" && typeof current !== "number") {
+            throw new Error(`jsonpath "${jsonpath}" must point to a string or number field for version updates.`);
+        }
+        cursor[leaf] = version;
+        return;
+    }
+    if (!isRecord(cursor) || !(leaf in cursor)) {
+        throw new Error(`jsonpath "${jsonpath}" does not resolve to an existing field.`);
+    }
+    const current = cursor[leaf];
+    if (typeof current !== "string" && typeof current !== "number") {
+        throw new Error(`jsonpath "${jsonpath}" must point to a string or number field for version updates.`);
+    }
+    cursor[leaf] = version;
+}
+function parseRegexPattern(pattern) {
+    const slashPattern = pattern.match(/^\/((?:\\\/|[^/])+)\/([a-z]*)$/u);
+    if (slashPattern) {
+        return new RegExp(slashPattern[1], slashPattern[2]);
+    }
+    return new RegExp(pattern, "m");
+}
+function applyRegexRule(content, pattern, version) {
+    const regex = parseRegexPattern(pattern);
+    const matchFlags = regex.flags.includes("g")
+        ? regex.flags
+        : `${regex.flags}g`;
+    const globalRegex = new RegExp(regex.source, matchFlags);
+    const matches = [...content.matchAll(globalRegex)];
+    if (matches.length !== 1) {
+        throw new Error(`Regex pattern must match exactly one occurrence; matched ${matches.length}.`);
+    }
+    const match = matches[0];
+    const start = match.index;
+    if (start === undefined) {
+        throw new Error("Regex match did not include an index.");
+    }
+    const full = match[0];
+    const groupOne = match[1];
+    const replacement = typeof groupOne === "string" ? full.replace(groupOne, version) : version;
+    return `${content.slice(0, start)}${replacement}${content.slice(start + full.length)}`;
+}
+function applyArtifactRuleToContent(content, rule, version) {
+    if (rule.type === "regex") {
+        return applyRegexRule(content, rule.pattern, version);
+    }
+    if (rule.type === "json") {
+        const parsed = JSON.parse(content);
+        setVersionAtJsonPath(parsed, rule.jsonpath, version);
+        return `${JSON.stringify(parsed, null, 2)}\n`;
+    }
+    if (rule.type === "toml") {
+        const parsed = toml_1.default.parse(content);
+        setVersionAtJsonPath(parsed, rule.jsonpath, version);
+        return `${toml_1.default.stringify(parsed)}\n`;
+    }
+    const parsed = yaml_1.default.parse(content);
+    setVersionAtJsonPath(parsed, rule.jsonpath, version);
+    return `${yaml_1.default.stringify(parsed)}`;
+}
+function normalizeRelative(base, target) {
+    return node_path_1.default.relative(base, target).replaceAll("\\", "/");
+}
+function applyArtifactRulesForPackage(cwd, packagePath, packageConfig, version) {
+    const rules = packageConfig["extra-files"] ?? [];
+    if (rules.length === 0) {
+        return [];
+    }
+    const packageBase = node_path_1.default.join(cwd, packagePath);
+    const updated = [];
+    for (const rule of rules) {
+        const targetPath = node_path_1.default.join(packageBase, rule.path);
+        if (!node_fs_1.default.existsSync(targetPath)) {
+            throw new Error(`Artifact rule target missing for package "${packagePath}": ${rule.path}`);
+        }
+        const existing = node_fs_1.default.readFileSync(targetPath, "utf8");
+        let next;
+        try {
+            next = applyArtifactRuleToContent(existing, rule, version);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed applying artifact rule (${rule.type}) for package "${packagePath}" file "${rule.path}": ${message}`);
+        }
+        node_fs_1.default.writeFileSync(targetPath, next, "utf8");
+        updated.push(normalizeRelative(cwd, targetPath));
+    }
+    return updated;
+}
+function applyConfiguredArtifactRules(cwd, config, plan) {
+    const packageConfigs = config.packages ?? {};
+    if (!plan.packages || plan.packages.length === 0) {
+        return [];
+    }
+    const updated = new Set();
+    for (const packagePlan of plan.packages) {
+        if (!packagePlan.nextVersion) {
+            continue;
+        }
+        const packageConfig = packageConfigs[packagePlan.path];
+        if (!packageConfig?.["extra-files"]?.length) {
+            continue;
+        }
+        const files = applyArtifactRulesForPackage(cwd, packagePlan.path, packageConfig, packagePlan.nextVersion);
+        for (const file of files) {
+            updated.add(file);
+        }
+    }
+    return [...updated].sort((a, b) => a.localeCompare(b));
+}

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

@@ -1,10 +1,13 @@
 import { type SimplePlan } from "../../domain/release/plan.js";
 import type { ParsedCommit } from "../../infra/git/commits.js";
+import type { VersionaryPluginContext } from "../../types/plugins.js";
 export declare function splitSafeDirtyFiles(files: string[]): {
     ignored: string[];
     blocking: string[];
 };
-export declare function prepareSimpleReleasePr(cwd?: string): {
+export declare function prepareSimpleReleasePr(cwd?: string, options?: {
+    logger?: VersionaryPluginContext["logger"];
+}): {
     branch: string;
     title: string;
     version: string;
@@ -13,6 +16,8 @@ export declare function prepareSimpleReleasePr(cwd?: string): {
     plan: SimplePlan;
 };
 export declare function renderSimpleReviewRequestBody(version: string, previousVersion: string, commits: ParsedCommit[], plan?: SimplePlan | null, cwd?: string): string;
-export declare function openOrUpdateSimpleReviewRequest(cwd: string, branch: string, title: string, version: string, previousVersion: string, commits: ParsedCommit[], plan?: SimplePlan | null): Promise<string>;
+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>;
 export declare function pushReleaseBranch(cwd: string, branch: string): void;
 export declare function isReleaseCommitMessage(subject: string): boolean;

package/dist/app/release/pr.js

@@ -14,9 +14,12 @@ const node_path_1 = __importDefault(require("node:path"));
 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 artifact_rules_js_1 = require("./artifact-rules.js");
 const state_js_1 = require("./state.js");
 const SAFE_DIRTY_FILES = new Set([
     "pnpm-lock.yaml",
@@ -55,25 +58,46 @@ function splitSafeDirtyFiles(files) {
     }
     return { ignored, blocking };
 }
-function ensureCleanWorktree(cwd) {
+function ensureCleanWorktree(cwd, logger) {
     const dirtyFiles = listTrackedDirtyFiles(cwd);
     const { ignored, blocking } = splitSafeDirtyFiles(dirtyFiles);
     if (blocking.length > 0) {
         throw new Error(`Working tree has tracked modifications before versionary pr:\n${blocking.join("\n")}\nCommit/stash tracked changes first.`);
     }
     if (ignored.length > 0) {
-        console.warn(`Ignoring safe tracked changes before versionary pr:\n${ignored.join("\n")}`);
+        logger?.warn(`Ignoring safe tracked changes before versionary pr:\n${ignored.join("\n")}`);
     }
 }
-function prepareSimpleReleasePr(cwd = process.cwd()) {
+function prepareSimpleReleasePr(cwd = process.cwd(), options = {}) {
     const plan = (0, plan_js_1.createSimplePlan)(cwd);
     const loaded = (0, load_config_js_1.loadConfig)(cwd);
     const strategy = (0, resolve_js_1.resolveVersionStrategy)(loaded.config);
     if (!plan.nextVersion) {
         throw new Error("No releasable commits found. Nothing to open a release PR for.");
     }
-    ensureCleanWorktree(cwd);
-    const updatedVersionFiles = strategy.writeVersion(cwd, loaded.config, plan.nextVersion);
+    ensureCleanWorktree(cwd, options.logger);
+    const updatedVersionFiles = [];
+    const rustManifestVersionTargets = {};
+    if (plan.packages && plan.packages.length > 0) {
+        for (const packagePlan of plan.packages) {
+            if (!packagePlan.nextVersion) {
+                continue;
+            }
+            const packageConfig = loaded.config.packages?.[packagePlan.path] ?? {};
+            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;
+            }
+        }
+        updatedVersionFiles.push(...(0, rust_js_1.applyRustWorkspaceDependencyUpdates)(cwd, rustManifestVersionTargets));
+    }
+    else {
+        updatedVersionFiles.push(...strategy.writeVersion(cwd, loaded.config, plan.nextVersion));
+    }
+    const updatedArtifactFiles = (0, artifact_rules_js_1.applyConfiguredArtifactRules)(cwd, loaded.config, plan);
     const section = (0, changelog_js_1.renderSimpleChangelog)(plan);
     (0, changelog_js_1.prependChangelog)(cwd, plan.changelogFile, section);
     const branch = plan.releaseBranchPrefix;
@@ -82,7 +106,13 @@ function prepareSimpleReleasePr(cwd = process.cwd()) {
         cwd,
         stdio: ["ignore", "pipe", "ignore"],
     });
-    const filesToAdd = [...new Set([...updatedVersionFiles, plan.changelogFile])];
+    const filesToAdd = [
+        ...new Set([
+            ...updatedVersionFiles,
+            ...updatedArtifactFiles,
+            plan.changelogFile,
+        ]),
+    ];
     (0, node_child_process_1.execFileSync)("git", ["add", ...filesToAdd], {
         cwd,
         stdio: ["ignore", "pipe", "ignore"],
@@ -100,24 +130,12 @@ function prepareSimpleReleasePr(cwd = process.cwd()) {
             tag: pkg.path === "."
                 ? `v${pkg.nextVersion ?? ""}`
                 : `${pkg.path.replaceAll("/", "-")}-v${pkg.nextVersion ?? ""}`,
-            notes: (0, changelog_js_1.renderSimpleReleaseNotes)({
-                currentVersion: pkg.currentVersion,
-                nextVersion: pkg.nextVersion ?? "",
-                commits: pkg.commits,
-                cwd,
-            }, { includeFooter: false }),
         }))
         : [
             {
                 path: ".",
                 version: plan.nextVersion,
                 tag: `v${plan.nextVersion}`,
-                notes: (0, changelog_js_1.renderSimpleReleaseNotes)({
-                    currentVersion: plan.currentVersion,
-                    nextVersion: plan.nextVersion,
-                    commits: plan.commits,
-                    cwd,
-                }, { includeFooter: false }),
             },
         ];
     (0, state_js_1.writeBaselineSha)(cwd, undefined, releaseTargets);
@@ -171,7 +189,7 @@ function renderSimpleReviewRequestBody(version, previousVersion, commits, plan =
         cwd,
     }, { includeFooter: true });
 }
-async function openOrUpdateSimpleReviewRequest(cwd, branch, title, version, previousVersion, commits, plan = null) {
+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") {
@@ -194,7 +212,7 @@ async function openOrUpdateSimpleReviewRequest(cwd, branch, title, version, prev
         labels: ["release"],
     }, {
         cwd,
-        logger: console,
+        logger: options.logger,
     });
     return result.url;
 }

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

@@ -7,6 +7,9 @@ export interface ReleaseTargetInput {
 }
 export interface ReleaseExecutionContext {
     createReleaseMetadata: (input: ReleaseTargetInput) => Promise<VersionaryScmReleaseMetadataResult>;
+    logger?: {
+        info: (message: string) => void;
+    };
 }
 export interface ReleaseTargetOutcome {
     tag: string;

package/dist/app/release/recovery.js

@@ -87,7 +87,7 @@ async function executeIdempotentReleaseTarget(cwd, target, context) {
     const metadata = await context.createReleaseMetadata(target);
     const metadataStatus = metadata.status ?? "created";
     if (tagStatus === "exists" && metadataStatus === "created") {
-        console.info(`Recovered drift for ${target.tag}: tag already existed and release metadata has now been created.`);
+        context.logger?.info(`Recovered drift for ${target.tag}: tag already existed and release metadata has now been created.`);
     }
     if (!metadata.url) {
         throw new Error(`Release metadata for "${target.tag}" did not return a URL. Verify SCM API permissions and retry.`);

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

@@ -1 +1,19 @@
+import type { VersionaryPluginContext } from "../../types/plugins.js";
 export declare function runSimpleRelease(cwd?: string): Promise<string>;
+export type SimpleRunReleaseResult = {
+    action: "release-skipped";
+    reason: string;
+} | {
+    action: "release-published";
+    message: string;
+    releases: {
+        tag: string;
+        url: string;
+        tagStatus: "created" | "exists";
+        metadataStatus: "created" | "exists";
+    }[];
+};
+export interface RunSimpleReleaseOptions {
+    logger?: VersionaryPluginContext["logger"];
+}
+export declare function runSimpleReleaseDetailed(cwd?: string, options?: RunSimpleReleaseOptions): Promise<SimpleRunReleaseResult>;

package/dist/app/release/release.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runSimpleRelease = runSimpleRelease;
+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"));
@@ -46,9 +47,19 @@ function readReleaseNotes(cwd, version, changelogFile) {
     return notes.length > 0 ? notes : `Automated release for v${version}`;
 }
 async function runSimpleRelease(cwd = process.cwd()) {
+    const result = await runSimpleReleaseDetailed(cwd, { logger: console });
+    if (result.action === "release-skipped") {
+        return result.reason;
+    }
+    return result.message;
+}
+async function runSimpleReleaseDetailed(cwd = process.cwd(), options = {}) {
     const subject = getHeadCommitSubject(cwd);
     if (!(0, pr_js_1.isReleaseCommitMessage)(subject)) {
-        return "No release commit context detected; skipping release stage.";
+        return {
+            action: "release-skipped",
+            reason: "No release commit context detected; skipping release stage.",
+        };
     }
     const loaded = (0, load_config_js_1.loadConfig)(cwd);
     const strategy = (0, resolve_js_1.resolveVersionStrategy)(loaded.config);
@@ -72,19 +83,29 @@ async function runSimpleRelease(cwd = process.cwd()) {
                 path: ".",
                 version,
                 tag: defaultTag,
-                notes: readReleaseNotes(cwd, version, changelogFile),
             },
         ];
-    const published = [];
+    const releases = [];
     for (const target of targets) {
         const outcome = await (0, recovery_js_1.executeIdempotentReleaseTarget)(cwd, {
             tag: target.tag,
             version: target.version,
-            notes: target.notes ?? readReleaseNotes(cwd, target.version, changelogFile),
+            notes: readReleaseNotes(cwd, target.version, changelogFile),
         }, {
-            createReleaseMetadata: (input) => plugin.createReleaseMetadata(input, { cwd, logger: console }),
+            createReleaseMetadata: (input) => plugin.createReleaseMetadata(input, { cwd, logger: options.logger }),
+            logger: options.logger,
+        });
+        releases.push({
+            tag: outcome.tag,
+            url: outcome.url,
+            tagStatus: outcome.tagStatus,
+            metadataStatus: outcome.metadataStatus,
         });
-        published.push(`${outcome.tag}: ${outcome.url} (tag=${outcome.tagStatus}, metadata=${outcome.metadataStatus})`);
     }
-    return `Published releases ${published.join(", ")}`;
+    const published = releases.map((outcome) => `${outcome.tag}: ${outcome.url} (tag=${outcome.tagStatus}, metadata=${outcome.metadataStatus})`);
+    return {
+        action: "release-published",
+        releases,
+        message: `Published releases ${published.join(", ")}`,
+    };
 }

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

@@ -2,7 +2,6 @@ export interface ReleaseTargetState {
     path: string;
     version: string;
     tag: string;
-    notes?: string;
 }
 export declare function getBaselineStatePath(cwd: string): string;
 export declare function readBaselineSha(cwd?: string): string | null;