versionary 0.32.0 → 1.0.1

package/dist/action/index.js

@@ -57,9 +57,9 @@ function setOutput(name, value) {
     appendFileSync(outputPath, `${name}<<${delimiter}\n${value}\n${delimiter}\n`, "utf8");
 }
 function main() {
-    const token = getInput("token") || getInput("github-token");
+    const token = getInput("token");
     if (!token) {
-        throw new Error("Input required and not supplied: token (or deprecated github-token).");
+        throw new Error("Input required and not supplied: token.");
     }
     const versionaryVersion = getInput("versionary-version") || "0.7.0";
     const cwd = getInput("working-directory") || ".";

package/dist/cli/index.js

@@ -1,11 +1,24 @@
 #!/usr/bin/env node
 import { execFileSync } from "node:child_process";
-import { loadConfig } from "../config/load-config.js";
 import { prependChangelog, renderReleasePlanChangelog, } from "../release/changelog.js";
 import { createReleasePlan } from "../release/plan.js";
-import { closeStaleReviewRequestIfExists, consumeNextReleaseFile, isReleaseCommitMessage, openOrUpdateReviewRequest, prepareReleasePr, pushReleaseBranch, resolveReleaseHighlights, } from "../release/pr.js";
+import { closeStaleReviewRequestIfExists, isReleaseCommitMessage, openOrUpdateReviewRequest, prepareReleasePr, pushReleaseBranch, resolveReleaseHighlights, } from "../release/pr.js";
 import { runRelease, runReleaseDetailed } from "../release/release.js";
 import { verifyProject } from "../release/verify-project.js";
+/**
+ * What a dry run would actually release. `plan.nextVersion` is the repository
+ * aggregate, which in a monorepo names no real release, so prefer the
+ * per-package versions whenever the plan has them.
+ */
+function formatDryRunReleaseSubject(plan) {
+    const releasing = (plan.packages ?? []).filter((pkg) => pkg.nextVersion);
+    if (releasing.length === 0) {
+        return plan.nextVersion ?? "";
+    }
+    return releasing
+        .map((pkg) => `${pkg.path === "." ? plan.packageName : pkg.path} ${pkg.nextVersion}`)
+        .join(", ");
+}
 function printVerifyResult() {
     const result = verifyProject();
     const categories = [
@@ -115,7 +128,7 @@ async function main() {
             return 0;
         }
         if (flags["dry-run"]) {
-            const dryRunMessage = `Dry run: would prepare release PR branch ${plan.releaseBranchPrefix} for ${plan.nextVersion}`;
+            const dryRunMessage = `Dry run: would prepare release PR branch ${plan.releaseBranchPrefix} for ${formatDryRunReleaseSubject(plan)}`;
             if (flags.json) {
                 emitJson({
                     action: "pr-dry-run",
@@ -195,8 +208,7 @@ async function main() {
             console.log("No releasable commits found.");
             return 0;
         }
-        const loaded = loadConfig();
-        const highlightsResult = resolveReleaseHighlights(process.cwd(), loaded.config, plan.changelogFile, plan.changelogFormat, logger);
+        const highlightsResult = resolveReleaseHighlights(process.cwd(), plan.changelogFile, plan.changelogFormat);
         const section = renderReleasePlanChangelog(plan, {
             highlights: highlightsResult.highlights,
         });
@@ -205,9 +217,6 @@ async function main() {
             return 0;
         }
         prependChangelog(process.cwd(), plan.changelogFile, section, plan.changelogFormat);
-        if (highlightsResult.source === "file" && highlightsResult.filePath) {
-            consumeNextReleaseFile(process.cwd(), highlightsResult.filePath);
-        }
         console.log(`Updated ${plan.changelogFile}`);
         return 0;
     }
@@ -223,7 +232,7 @@ async function main() {
             return 0;
         }
         if (flags["dry-run"]) {
-            console.log(`Dry run: would prepare release PR branch ${plan.releaseBranchPrefix} for ${plan.nextVersion}`);
+            console.log(`Dry run: would prepare release PR branch ${plan.releaseBranchPrefix} for ${formatDryRunReleaseSubject(plan)}`);
             return 0;
         }
         const pr = prepareReleasePr(process.cwd(), { logger: console });

package/dist/config/schema.d.ts

@@ -5,7 +5,6 @@ export declare const configSchema: z.ZodObject<{
     "review-mode": z.ZodOptional<z.ZodEnum<{
         direct: "direct";
         pr: "pr";
-        review: "review";
     }>>;
     "version-file": z.ZodOptional<z.ZodString>;
     "changelog-file": z.ZodOptional<z.ZodString>;
@@ -15,17 +14,16 @@ export declare const configSchema: z.ZodObject<{
     }>>;
     "release-draft": z.ZodOptional<z.ZodBoolean>;
     "release-reference-comments": z.ZodOptional<z.ZodEnum<{
-        off: "off";
         "best-effort": "best-effort";
+        off: "off";
         strict: "strict";
     }>>;
     "release-branch": z.ZodOptional<z.ZodString>;
     "baseline-file": z.ZodOptional<z.ZodString>;
-    "next-release-file": z.ZodOptional<z.ZodString>;
     "bootstrap-sha": z.ZodOptional<z.ZodString>;
     "monorepo-mode": z.ZodOptional<z.ZodEnum<{
-        independent: "independent";
         fixed: "fixed";
+        independent: "independent";
     }>>;
     "bump-minor-pre-major": z.ZodOptional<z.ZodBoolean>;
     "allow-stable-major": z.ZodOptional<z.ZodBoolean>;
@@ -45,14 +43,13 @@ export declare const configSchema: z.ZodObject<{
         "extra-files": z.ZodOptional<z.ZodArray<z.ZodObject<{
             type: z.ZodEnum<{
                 json: "json";
-                toml: "toml";
-                yaml: "yaml";
                 nix: "nix";
                 regex: "regex";
+                toml: "toml";
+                yaml: "yaml";
             }>;
             path: z.ZodString;
             "field-path": z.ZodOptional<z.ZodString>;
-            jsonpath: z.ZodOptional<z.ZodString>;
             pattern: z.ZodOptional<z.ZodString>;
             replacement: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;

package/dist/config/schema.js

@@ -4,44 +4,35 @@ const artifactRuleSchema = z
     type: z.enum(["json", "toml", "yaml", "nix", "regex"]),
     path: z.string().min(1),
     "field-path": z.string().optional(),
-    jsonpath: z.string().optional(),
     pattern: z.string().optional(),
     replacement: z.string().optional(),
 })
     .superRefine((value, ctx) => {
-    const needsJsonPath = value.type === "json" ||
+    const needsFieldPath = value.type === "json" ||
         value.type === "toml" ||
         value.type === "yaml" ||
         value.type === "nix";
-    const hasFieldPath = Boolean(value["field-path"] ?? value.jsonpath);
-    if (needsJsonPath && !hasFieldPath) {
+    if (needsFieldPath && !value["field-path"]) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
-            message: `${value.type} artifact rules require "field-path" (or deprecated "jsonpath").`,
+            message: `${value.type} artifact rules require "field-path".`,
             path: ["field-path"],
         });
     }
-    if (needsJsonPath && value.pattern) {
+    if (needsFieldPath && value.pattern) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
             message: `${value.type} artifact rules do not support "pattern".`,
             path: ["pattern"],
         });
     }
-    if (needsJsonPath && value.replacement) {
+    if (needsFieldPath && value.replacement) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
             message: `${value.type} artifact rules do not support "replacement".`,
             path: ["replacement"],
         });
     }
-    if (value["field-path"] && value.jsonpath) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: 'Specify only one of "field-path" or deprecated "jsonpath".',
-            path: ["field-path"],
-        });
-    }
     if (value.type === "regex" && !value.pattern) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
@@ -49,10 +40,10 @@ const artifactRuleSchema = z
             path: ["pattern"],
         });
     }
-    if (value.type === "regex" && (value["field-path"] || value.jsonpath)) {
+    if (value.type === "regex" && value["field-path"]) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
-            message: 'regex artifact rules do not support "field-path" or deprecated "jsonpath".',
+            message: 'regex artifact rules do not support "field-path".',
             path: ["field-path"],
         });
     }
@@ -75,7 +66,7 @@ export const configSchema = z
     .object({
     $schema: z.string().optional(),
     version: z.literal(1),
-    "review-mode": z.enum(["direct", "pr", "review"]).optional(),
+    "review-mode": z.enum(["direct", "pr"]).optional(),
     "version-file": z.string().optional(),
     "changelog-file": z.string().optional(),
     "changelog-format": z.enum(["markdown-changelog", "r-news"]).optional(),
@@ -85,7 +76,6 @@ export const configSchema = z
         .optional(),
     "release-branch": z.string().optional(),
     "baseline-file": z.string().optional(),
-    "next-release-file": z.string().optional(),
     "bootstrap-sha": z.string().optional(),
     "monorepo-mode": z.enum(["independent", "fixed"]).optional(),
     "bump-minor-pre-major": z.boolean().optional(),

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

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

package/dist/release/artifact-rules.js

@@ -143,9 +143,9 @@ function setVersionAtJsonPath(document, fieldPath, version) {
     }
 }
 function resolveFieldPath(rule) {
-    const fieldPath = rule["field-path"] ?? rule.jsonpath;
+    const fieldPath = rule["field-path"];
     if (!fieldPath) {
-        throw new Error(`${rule.type} artifact rules require "field-path" (or deprecated "jsonpath").`);
+        throw new Error(`${rule.type} artifact rules require "field-path".`);
     }
     return fieldPath;
 }
@@ -207,8 +207,8 @@ function applyRegexRule(content, pattern, version, replacementTemplate) {
         const rendered = renderReplacementTemplate(replacementTemplate, version);
         return `${content.slice(0, start)}${rendered}${content.slice(start + full.length)}`;
     }
-    // Legacy behavior: substitute the full version into the first capture group,
-    // leaving the rest of the match intact. Splice by group indices rather than
+    // Without a template: substitute the full version into the first capture
+    // group, leaving the rest of the match intact. Splice by group indices rather than
     // `String.replace` so literal `$` sequences and repeated group content are
     // handled correctly.
     const groupIndices = match.indices?.[1];

package/dist/release/changelog.d.ts

@@ -1,6 +1,6 @@
 import { type ParsedCommit } from "../git/commits.js";
 import type { VersionaryChangelogFormat } from "../types/config.js";
-import { type ReleasePlan, type SimplePlan } from "./plan.js";
+import { type ReleasePlan } from "./plan.js";
 export declare function renderReleaseNotesSection(input: {
     currentVersion: string;
     nextVersion: string;
@@ -23,8 +23,6 @@ export declare function renderReleasePlanChangelog(plan: ReleasePlan, options?:
     cwd?: string;
     highlights?: string;
 }): string;
-/** @deprecated Use renderReleasePlanChangelog. */
-export declare function renderSimpleChangelog(plan: SimplePlan): string;
 /**
  * Locate a manual-notes block at the top of an existing changelog and split it
  * out. The notes block is the first release-level heading whose text is not a

package/dist/release/changelog.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { applyRevertSuppression, inferReleaseTypeFromParsedCommit, parseConventionalCommitMessage, } from "../git/commits.js";
 import { resolveRepositoryWebBaseUrl } from "../git/repo-url.js";
-import { resolvePackageDependencies, } from "./plan.js";
+import { resolvePackageDependencies, resolveRootReleaseView, } from "./plan.js";
 import { isVersionHeading } from "./semver.js";
 const REVIEW_REQUEST_FOOTER = "---\n\nThis PR was generated by [Versionary](https://github.com/jolars/versionary).";
 function formatDate() {
@@ -68,6 +68,7 @@ function groupCommitLines(commits, repoUrl) {
     const fixes = [];
     const performance = [];
     const reverts = [];
+    const other = [];
     const effectiveCommits = applyRevertSuppression(commits);
     const getRevertedSubject = (commit) => {
         const normalizedDescription = (commit.description ?? "")
@@ -93,9 +94,6 @@ function groupCommitLines(commits, repoUrl) {
     };
     for (const commit of effectiveCommits) {
         const type = inferReleaseTypeFromParsedCommit(commit);
-        if (!type) {
-            continue;
-        }
         const { label, message } = formatCommitMessage(commit.subject);
         const short = commit.hash.slice(0, 7);
         const hashLabel = repoUrl
@@ -106,6 +104,10 @@ function groupCommitLines(commits, repoUrl) {
         const line = `- ${label}${message} (${hashLabel})${referencesSuffix}`;
         const commitType = (commit.type ?? "").toLowerCase();
         const isBreaking = type === "major";
+        if (!type) {
+            other.push(line);
+            continue;
+        }
         if (commit.isRevert) {
             if (!shouldIncludeRevert(commit)) {
                 continue;
@@ -128,7 +130,23 @@ function groupCommitLines(commits, repoUrl) {
             fixes.push(line);
         }
     }
-    return { breaking, features, fixes, performance, reverts };
+    return { breaking, features, fixes, performance, reverts, other };
+}
+/**
+ * A forced bump — a stale dependency, or a propagated requirement rewrite —
+ * can carry no release-worthy commits at all. Rather than publish a bare
+ * version heading, such a release falls back to listing whatever else is
+ * shipping under it.
+ */
+function needsOtherChangesFallback(grouped, hasHighlights, dependencyCount) {
+    if (hasHighlights || dependencyCount > 0 || grouped.other.length === 0) {
+        return false;
+    }
+    return (grouped.breaking.length === 0 &&
+        grouped.features.length === 0 &&
+        grouped.fixes.length === 0 &&
+        grouped.performance.length === 0 &&
+        grouped.reverts.length === 0);
 }
 export function renderReleaseNotesSection(input, options = {}) {
     const repoUrl = resolveRepositoryWebBaseUrl(input.cwd ?? process.cwd());
@@ -161,6 +179,9 @@ export function renderReleaseNotesSection(input, options = {}) {
     if (input.dependencies && input.dependencies.length > 0) {
         sections.push("### Dependencies", ...input.dependencies.map((dependency) => `- updated ${dependency.name} to v${dependency.version}`), "");
     }
+    if (needsOtherChangesFallback(grouped, trimmedHighlights.length > 0, input.dependencies?.length ?? 0)) {
+        sections.push("### Other changes", ...grouped.other, "");
+    }
     const body = [header, "", ...sections].join("\n").trimEnd();
     if (options.includeFooter) {
         return `${body}\n\n${renderReviewRequestFooter()}`;
@@ -171,24 +192,27 @@ export function renderReviewRequestFooter() {
     return REVIEW_REQUEST_FOOTER;
 }
 export function renderReleasePlanChangelog(plan, options = {}) {
-    if (!plan.nextVersion) {
+    // Root's changelog describes root's own release, so it must be driven by the
+    // root package's version and commit set rather than the plan-level aggregate.
+    const root = resolveRootReleaseView(plan);
+    if (!root.nextVersion) {
         return "";
     }
     const dedupedCommits = [
-        ...new Map(plan.commits.map((commit) => [commit.hash, commit])).values(),
+        ...new Map(root.commits.map((commit) => [commit.hash, commit])).values(),
     ];
     if (plan.changelogFormat === "r-news") {
         return renderRNewsReleaseNotes({
             packageName: plan.packageName,
-            nextVersion: plan.nextVersion,
+            nextVersion: root.nextVersion,
             commits: dedupedCommits,
             cwd: process.cwd(),
             highlights: options.highlights,
         });
     }
     return renderReleaseNotesSection({
-        currentVersion: plan.currentVersion,
-        nextVersion: plan.nextVersion,
+        currentVersion: root.currentVersion,
+        nextVersion: root.nextVersion,
         commits: dedupedCommits,
         cwd: options.cwd ?? process.cwd(),
         dependencies: resolvePackageDependencies(plan, "."),
@@ -198,10 +222,6 @@ export function renderReleasePlanChangelog(plan, options = {}) {
         includeFooter: options.includeFooter,
     });
 }
-/** @deprecated Use renderReleasePlanChangelog. */
-export function renderSimpleChangelog(plan) {
-    return renderReleasePlanChangelog(plan);
-}
 /**
  * Locate a manual-notes block at the top of an existing changelog and split it
  * out. The notes block is the first release-level heading whose text is not a
@@ -292,6 +312,9 @@ export function renderRNewsReleaseNotes(input) {
     if (grouped.reverts.length > 0) {
         sections.push("## Reverts", "", ...grouped.reverts, "");
     }
+    if (needsOtherChangesFallback(grouped, trimmedHighlights.length > 0, 0)) {
+        sections.push("## Other changes", "", ...grouped.other, "");
+    }
     return [`# ${input.packageName} ${normalizedVersion}`, "", ...sections]
         .join("\n")
         .trimEnd();

package/dist/release/plan.d.ts

@@ -1,6 +1,7 @@
 import { type ParsedCommit } from "../git/commits.js";
 import type { VersionaryChangelogFormat, VersionaryConfig } from "../types/config.js";
 import { type ReleaseType } from "./semver.js";
+type BumpReason = "direct" | "dependency-propagation" | "stale-dependency" | "follows" | "release-as";
 export interface ReleasePlan {
     mode: "simple";
     releaseType: ReleaseType;
@@ -18,13 +19,11 @@ export interface ReleasePlan {
         releaseType: ReleaseType;
         currentVersion: string;
         nextVersion: string | null;
-        bumpReason?: "direct" | "dependency-propagation" | "follows";
+        bumpReason?: BumpReason;
         dependencySourcePaths?: string[];
         commits: ParsedCommit[];
     }>;
 }
-/** @deprecated Use ReleasePlan. */
-export type SimplePlan = ReleasePlan;
 export declare function getChangelogDefaults(config: {
     "release-type"?: VersionaryConfig["release-type"];
     "changelog-file"?: VersionaryConfig["changelog-file"];
@@ -35,9 +34,30 @@ export declare function getChangelogDefaults(config: {
     changelogFormat: VersionaryChangelogFormat;
 };
 export declare function createReleasePlan(cwd?: string): ReleasePlan;
-/** @deprecated Use createReleasePlan. */
-export declare function createSimplePlan(cwd?: string): ReleasePlan;
+/**
+ * The root package's own release, as distinct from the plan-level aggregate.
+ *
+ * `plan.releaseType`/`plan.nextVersion`/`plan.commits` describe the repository
+ * as a whole: the aggregate release type folds in every package's commits and
+ * is then applied to root's version number. That answers "is anything
+ * releasing, and how large is the biggest change anywhere" — not "what is root
+ * releasing". A sibling's `feat` therefore lifts the aggregate to a minor even
+ * when root's own `exclude-paths` drop that commit, so anything that names or
+ * describes root's release must go through here instead. Using the aggregate
+ * would report a version no version file carries and list commits root
+ * deliberately excluded.
+ *
+ * Falls back to the aggregate when the plan has no explicit root package: the
+ * top-level changelog is then a repository-wide summary with no package of its
+ * own to describe.
+ */
+export declare function resolveRootReleaseView(plan: ReleasePlan): {
+    currentVersion: string;
+    nextVersion: string | null;
+    commits: ParsedCommit[];
+};
 export declare function resolvePackageDependencies(plan: ReleasePlan, packagePath: string): Array<{
     name: string;
     version: string;
 }>;
+export {};