versionary 0.31.0 → 1.0.0

package/dist/config/schema.js

@@ -4,34 +4,33 @@ 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 (value["field-path"] && value.jsonpath) {
+    if (needsFieldPath && value.replacement) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
-            message: 'Specify only one of "field-path" or deprecated "jsonpath".',
-            path: ["field-path"],
+            message: `${value.type} artifact rules do not support "replacement".`,
+            path: ["replacement"],
         });
     }
     if (value.type === "regex" && !value.pattern) {
@@ -41,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"],
         });
     }
@@ -67,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(),
@@ -77,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

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
 import YAML from "yaml";
+import { parseVersion } from "./semver.js";
 const WILDCARD = Symbol("wildcard");
 function isRecord(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -142,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;
 }
@@ -160,12 +161,34 @@ function parseRegexPattern(pattern) {
     }
     return new RegExp(pattern, "m");
 }
-function applyRegexRule(content, pattern, version) {
+const REPLACEMENT_TOKEN_PATTERN = /\{\{\s*([A-Za-z]+)\s*\}\}/gu;
+function renderReplacementTemplate(template, version) {
+    const parsed = parseVersion(version);
+    const tokens = {
+        version,
+        major: String(parsed.major),
+        minor: String(parsed.minor),
+        patch: String(parsed.patch),
+        prerelease: parsed.prerelease.join("."),
+        build: parsed.build.join("."),
+    };
+    return template.replace(REPLACEMENT_TOKEN_PATTERN, (_whole, name) => {
+        const key = name.toLowerCase();
+        const value = tokens[key];
+        if (value === undefined) {
+            throw new Error(`Unknown replacement token "{{${name}}}". Supported tokens: ${Object.keys(tokens)
+                .map((token) => `{{${token}}}`)
+                .join(", ")}.`);
+        }
+        return value;
+    });
+}
+function applyRegexRule(content, pattern, version, replacementTemplate) {
     const regex = parseRegexPattern(pattern);
     const matchFlags = regex.flags.includes("g")
         ? regex.flags
         : `${regex.flags}g`;
-    const globalRegex = new RegExp(regex.source, matchFlags);
+    const globalRegex = new RegExp(regex.source, matchFlags.includes("d") ? matchFlags : `${matchFlags}d`);
     const matches = [...content.matchAll(globalRegex)];
     if (matches.length !== 1) {
         throw new Error(`Regex pattern must match exactly one occurrence; matched ${matches.length}.`);
@@ -179,9 +202,21 @@ function applyRegexRule(content, pattern, version) {
         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)}`;
+    // With a replacement template, render it and replace the entire match.
+    if (replacementTemplate !== undefined) {
+        const rendered = renderReplacementTemplate(replacementTemplate, version);
+        return `${content.slice(0, start)}${rendered}${content.slice(start + full.length)}`;
+    }
+    // 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];
+    if (!groupIndices) {
+        return `${content.slice(0, start)}${version}${content.slice(start + full.length)}`;
+    }
+    const [groupStart, groupEnd] = groupIndices;
+    return `${content.slice(0, groupStart)}${version}${content.slice(groupEnd)}`;
 }
 function applyTomlRulePreservingFormatting(content, fieldPath, version) {
     const simplePath = fieldPath.match(/^\$\.([A-Za-z0-9_-]+)$/u);
@@ -368,7 +403,7 @@ function applyArtifactRuleToContent(content, rule, version) {
         if (!rule.pattern) {
             throw new Error('regex artifact rules require "pattern".');
         }
-        return applyRegexRule(content, rule.pattern, version);
+        return applyRegexRule(content, rule.pattern, version, rule.replacement);
     }
     if (rule.type === "json") {
         const parsed = JSON.parse(content);

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 } 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()}`;
@@ -198,10 +219,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 +309,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,8 @@ export declare function getChangelogDefaults(config: {
     changelogFormat: VersionaryChangelogFormat;
 };
 export declare function createReleasePlan(cwd?: string): ReleasePlan;
-/** @deprecated Use createReleasePlan. */
-export declare function createSimplePlan(cwd?: string): ReleasePlan;
 export declare function resolvePackageDependencies(plan: ReleasePlan, packagePath: string): Array<{
     name: string;
     version: string;
 }>;
+export {};