versionary 0.20.2 → 0.22.0

package/dist/cli/index.js

@@ -2,6 +2,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_child_process_1 = require("node:child_process");
+const load_config_js_1 = require("../config/load-config.js");
 const changelog_js_1 = require("../release/changelog.js");
 const plan_js_1 = require("../release/plan.js");
 const pr_js_1 = require("../release/pr.js");
@@ -162,7 +163,7 @@ async function main() {
             return 0;
         }
         (0, pr_js_1.pushReleaseBranch)(process.cwd(), pr.branch);
-        const reviewResult = await (0, pr_js_1.openOrUpdateReviewRequest)(process.cwd(), pr.branch, pr.title, pr.version, pr.previousVersion, pr.commits, pr.plan, { logger });
+        const reviewResult = await (0, pr_js_1.openOrUpdateReviewRequest)(process.cwd(), pr.branch, pr.title, pr.version, pr.previousVersion, pr.commits, pr.plan, { logger, highlights: pr.highlights });
         const message = `Prepared release PR branch ${pr.branch}`;
         if (flags.json) {
             emitJson({
@@ -196,12 +197,18 @@ async function main() {
             console.log("No releasable commits found.");
             return 0;
         }
-        const section = (0, changelog_js_1.renderReleasePlanChangelog)(plan);
+        const loaded = (0, load_config_js_1.loadConfig)();
+        const highlightsRead = (0, pr_js_1.readNextReleaseHighlights)(process.cwd(), loaded.config);
+        const highlights = highlightsRead?.content ?? "";
+        const section = (0, changelog_js_1.renderReleasePlanChangelog)(plan, { highlights });
         if (!write) {
             console.log(section);
             return 0;
         }
         (0, changelog_js_1.prependChangelog)(process.cwd(), plan.changelogFile, section, plan.changelogFormat);
+        if (highlightsRead) {
+            (0, pr_js_1.consumeNextReleaseFile)(process.cwd(), highlightsRead.filePath);
+        }
         console.log(`Updated ${plan.changelogFile}`);
         return 0;
     }
@@ -227,7 +234,7 @@ async function main() {
             return 0;
         }
         (0, pr_js_1.pushReleaseBranch)(process.cwd(), pr.branch);
-        const reviewResult = await (0, pr_js_1.openOrUpdateReviewRequest)(process.cwd(), pr.branch, pr.title, pr.version, pr.previousVersion, pr.commits, pr.plan);
+        const reviewResult = await (0, pr_js_1.openOrUpdateReviewRequest)(process.cwd(), pr.branch, pr.title, pr.version, pr.previousVersion, pr.commits, pr.plan, { highlights: pr.highlights });
         console.log(`Prepared release PR branch ${pr.branch}`);
         console.log(`Title: ${pr.title}`);
         console.log(reviewResult);

package/dist/config/schema.d.ts

@@ -21,6 +21,7 @@ export declare const configSchema: z.ZodObject<{
     }>>;
     "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";

package/dist/config/schema.js

@@ -76,6 +76,7 @@ exports.configSchema = zod_1.z
         .optional(),
     "release-branch": zod_1.z.string().optional(),
     "baseline-file": zod_1.z.string().optional(),
+    "next-release-file": zod_1.z.string().optional(),
     "bootstrap-sha": zod_1.z.string().optional(),
     "monorepo-mode": zod_1.z.enum(["independent", "fixed"]).optional(),
     "bump-minor-pre-major": zod_1.z.boolean().optional(),

package/dist/release/artifact-rules.js

@@ -8,6 +8,7 @@ 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"));
+const WILDCARD = Symbol("wildcard");
 function isRecord(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -20,7 +21,12 @@ function parseFieldPath(fieldPath) {
     while (index < fieldPath.length) {
         const current = fieldPath[index];
         if (current === ".") {
-            const keyMatch = fieldPath.slice(index + 1).match(/^[A-Za-z0-9_-]+/u);
+            if (fieldPath[index + 1] === "*") {
+                tokens.push(WILDCARD);
+                index += 2;
+                continue;
+            }
+            const keyMatch = fieldPath.slice(index + 1).match(/^[A-Za-z0-9_@/-]+/u);
             if (!keyMatch) {
                 throw new Error(`Invalid field-path "${fieldPath}" near index ${index}.`);
             }
@@ -30,6 +36,11 @@ function parseFieldPath(fieldPath) {
         }
         if (current === "[") {
             const rest = fieldPath.slice(index + 1);
+            if (rest.startsWith("*]")) {
+                tokens.push(WILDCARD);
+                index += 3;
+                continue;
+            }
             const numberMatch = rest.match(/^(\d+)\]/u);
             if (numberMatch) {
                 tokens.push(Number(numberMatch[1]));
@@ -55,49 +66,86 @@ function parseFieldPath(fieldPath) {
     }
     return tokens;
 }
-function setVersionAtJsonPath(document, fieldPath, version) {
-    const tokens = parseFieldPath(fieldPath);
-    let cursor = document;
-    for (let index = 0; index < tokens.length - 1; index += 1) {
-        const token = tokens[index];
-        if (token === undefined) {
+function assignLeaf(container, key, fieldPath, version) {
+    if (typeof key === "number") {
+        if (!Array.isArray(container) || key >= container.length) {
             throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
         }
-        if (typeof token === "number") {
-            if (!Array.isArray(cursor) || token >= cursor.length) {
-                throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
-            }
-            cursor = cursor[token];
-            continue;
-        }
-        if (!isRecord(cursor) || !(token in cursor)) {
-            throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
-        }
-        cursor = cursor[token];
-    }
-    const leaf = tokens.at(-1);
-    if (leaf === undefined) {
-        throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
-    }
-    if (typeof leaf === "number") {
-        if (!Array.isArray(cursor) || leaf >= cursor.length) {
-            throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
-        }
-        const current = cursor[leaf];
+        const current = container[key];
         if (typeof current !== "string" && typeof current !== "number") {
             throw new Error(`field-path "${fieldPath}" must point to a string or number field for version updates.`);
         }
-        cursor[leaf] = version;
+        container[key] = version;
         return;
     }
-    if (!isRecord(cursor) || !(leaf in cursor)) {
+    if (!isRecord(container) || !(key in container)) {
         throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
     }
-    const current = cursor[leaf];
+    const current = container[key];
     if (typeof current !== "string" && typeof current !== "number") {
         throw new Error(`field-path "${fieldPath}" must point to a string or number field for version updates.`);
     }
-    cursor[leaf] = version;
+    container[key] = version;
+}
+function applyTokens(cursor, tokens, position, fieldPath, version) {
+    const token = tokens[position];
+    const isLeaf = position === tokens.length - 1;
+    if (token === WILDCARD) {
+        let matched = false;
+        if (isRecord(cursor)) {
+            for (const key of Object.keys(cursor)) {
+                if (isLeaf) {
+                    assignLeaf(cursor, key, fieldPath, version);
+                    matched = true;
+                }
+                else if (applyTokens(cursor[key], tokens, position + 1, fieldPath, version)) {
+                    matched = true;
+                }
+            }
+            return matched;
+        }
+        if (Array.isArray(cursor)) {
+            for (let i = 0; i < cursor.length; i += 1) {
+                if (isLeaf) {
+                    assignLeaf(cursor, i, fieldPath, version);
+                    matched = true;
+                }
+                else if (applyTokens(cursor[i], tokens, position + 1, fieldPath, version)) {
+                    matched = true;
+                }
+            }
+            return matched;
+        }
+        throw new Error(`field-path "${fieldPath}" wildcard segment does not target an object or array.`);
+    }
+    if (typeof token === "number") {
+        if (!Array.isArray(cursor) || token >= cursor.length) {
+            throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
+        }
+        if (isLeaf) {
+            assignLeaf(cursor, token, fieldPath, version);
+            return true;
+        }
+        return applyTokens(cursor[token], tokens, position + 1, fieldPath, version);
+    }
+    if (typeof token === "string") {
+        if (!isRecord(cursor) || !(token in cursor)) {
+            throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
+        }
+        if (isLeaf) {
+            assignLeaf(cursor, token, fieldPath, version);
+            return true;
+        }
+        return applyTokens(cursor[token], tokens, position + 1, fieldPath, version);
+    }
+    throw new Error(`field-path "${fieldPath}" does not resolve to an existing field.`);
+}
+function setVersionAtJsonPath(document, fieldPath, version) {
+    const tokens = parseFieldPath(fieldPath);
+    const matched = applyTokens(document, tokens, 0, fieldPath, version);
+    if (!matched) {
+        throw new Error(`field-path "${fieldPath}" did not match any fields.`);
+    }
 }
 function resolveFieldPath(rule) {
     const fieldPath = rule["field-path"] ?? rule.jsonpath;
@@ -232,6 +280,9 @@ function findMatchingBrace(content, openBraceIndex, endExclusive) {
 }
 function resolveNixPathTokens(fieldPath) {
     const tokens = parseFieldPath(fieldPath);
+    if (tokens.some((token) => token === WILDCARD)) {
+        throw new Error(`Nix artifact rules do not support wildcard segments in field-path "${fieldPath}".`);
+    }
     if (tokens.some((token) => typeof token === "number")) {
         throw new Error(`Nix artifact rules do not support array index segments in field-path "${fieldPath}".`);
     }

package/dist/release/changelog.d.ts

@@ -10,6 +10,7 @@ export declare function renderSimpleReleaseNotes(input: {
         name: string;
         version: string;
     }>;
+    highlights?: string;
 }, options?: {
     includeFooter?: boolean;
     headerLabel?: string;
@@ -19,6 +20,7 @@ export declare function renderReleasePlanChangelog(plan: ReleasePlan, options?:
     headerLabel?: string;
     includeFooter?: boolean;
     cwd?: string;
+    highlights?: string;
 }): string;
 /** @deprecated Use renderReleasePlanChangelog. */
 export declare function renderSimpleChangelog(plan: SimplePlan): string;
@@ -35,4 +37,5 @@ export declare function renderRNewsReleaseNotes(input: {
     nextVersion: string;
     commits: ParsedCommit[];
     cwd?: string;
+    highlights?: string;
 }): string;

package/dist/release/changelog.js

@@ -148,6 +148,10 @@ function renderSimpleReleaseNotes(input, options = {}) {
         : `## ${headerLabel} (${formatDate()})`;
     const grouped = groupCommitLines(input.commits, repoUrl);
     const sections = [];
+    const trimmedHighlights = input.highlights?.trim() ?? "";
+    if (trimmedHighlights.length > 0) {
+        sections.push(trimmedHighlights, "");
+    }
     if (grouped.breaking.length > 0) {
         sections.push("### Breaking changes", ...grouped.breaking, "");
     }
@@ -212,6 +216,7 @@ function renderReleasePlanChangelog(plan, options = {}) {
             nextVersion: plan.nextVersion,
             commits: dedupedCommits,
             cwd: process.cwd(),
+            highlights: options.highlights,
         });
     }
     return renderSimpleReleaseNotes({
@@ -220,6 +225,7 @@ function renderReleasePlanChangelog(plan, options = {}) {
         commits: dedupedCommits,
         cwd: options.cwd ?? process.cwd(),
         dependencies,
+        highlights: options.highlights,
     }, {
         includeFooter: options.includeFooter,
         headerLabel: options.headerLabel,
@@ -276,6 +282,10 @@ function renderRNewsReleaseNotes(input) {
     const grouped = groupCommitLines(input.commits, repoUrl);
     const normalizedVersion = input.nextVersion.replace(/\.\d+$/u, "");
     const sections = [];
+    const trimmedHighlights = input.highlights?.trim() ?? "";
+    if (trimmedHighlights.length > 0) {
+        sections.push(trimmedHighlights, "");
+    }
     if (grouped.breaking.length > 0) {
         sections.push("## Breaking changes", "", ...grouped.breaking, "");
     }

package/dist/release/pr.d.ts

@@ -1,6 +1,15 @@
 import type { ParsedCommit } from "../git/commits.js";
+import type { VersionaryConfig } from "../types/config.js";
 import type { VersionaryPluginContext } from "../types/plugins.js";
 import { type ReleasePlan, type SimplePlan } from "./plan.js";
+export declare function getNextReleaseFile(config: VersionaryConfig): string;
+export declare function readNextReleaseHighlights(cwd: string, config: VersionaryConfig): {
+    content: string;
+    filePath: string;
+} | null;
+export declare function consumeNextReleaseFile(cwd: string, filePath: string): {
+    tracked: boolean;
+};
 export declare function splitSafeDirtyFiles(files: string[]): {
     ignored: string[];
     blocking: string[];
@@ -15,10 +24,12 @@ export declare function prepareReleasePr(cwd?: string, options?: {
     commits: ParsedCommit[];
     plan: ReleasePlan;
     updated: boolean;
+    highlights: string;
 };
-export declare function renderSimpleReviewRequestBody(version: string, previousVersion: string, commits: ParsedCommit[], plan?: SimplePlan | null, cwd?: string): string;
+export declare function renderSimpleReviewRequestBody(version: string, previousVersion: string, commits: ParsedCommit[], plan?: SimplePlan | null, cwd?: string, highlights?: string): string;
 export declare function openOrUpdateReviewRequest(cwd: string, branch: string, title: string, version: string, previousVersion: string, commits: ParsedCommit[], plan?: SimplePlan | null, options?: {
     logger?: VersionaryPluginContext["logger"];
+    highlights?: string;
 }): Promise<string>;
 export declare function closeStaleReviewRequestIfExists(cwd?: string, options?: {
     logger?: VersionaryPluginContext["logger"];
@@ -34,6 +45,7 @@ export declare function prepareSimpleReleasePr(cwd?: string, options?: {
 /** @deprecated Use openOrUpdateReviewRequest. */
 export declare function openOrUpdateSimpleReviewRequest(cwd: string, branch: string, title: string, version: string, previousVersion: string, commits: ParsedCommit[], plan?: SimplePlan | null, options?: {
     logger?: VersionaryPluginContext["logger"];
+    highlights?: string;
 }): Promise<string>;
 export declare function pushReleaseBranch(cwd: string, branch: string): void;
 export declare function isReleaseCommitMessage(commitMessage: string): boolean;

package/dist/release/pr.js

@@ -3,6 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNextReleaseFile = getNextReleaseFile;
+exports.readNextReleaseHighlights = readNextReleaseHighlights;
+exports.consumeNextReleaseFile = consumeNextReleaseFile;
 exports.splitSafeDirtyFiles = splitSafeDirtyFiles;
 exports.prepareReleasePr = prepareReleasePr;
 exports.renderSimpleReviewRequestBody = renderSimpleReviewRequestBody;
@@ -13,6 +16,7 @@ exports.openOrUpdateSimpleReviewRequest = openOrUpdateSimpleReviewRequest;
 exports.pushReleaseBranch = pushReleaseBranch;
 exports.isReleaseCommitMessage = isReleaseCommitMessage;
 const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const load_config_js_1 = require("../config/load-config.js");
 const client_js_1 = require("../scm/client.js");
@@ -29,6 +33,38 @@ const SAFE_DIRTY_FILES = new Set([
     "npm-shrinkwrap.json",
 ]);
 const VERSIONARY_RELEASE_TRAILER = "Versionary-Release: true";
+function getNextReleaseFile(config) {
+    return config["next-release-file"] ?? "NEXT_RELEASE.md";
+}
+function readNextReleaseHighlights(cwd, config) {
+    const filePath = getNextReleaseFile(config);
+    const fullPath = node_path_1.default.join(cwd, filePath);
+    if (!node_fs_1.default.existsSync(fullPath)) {
+        return null;
+    }
+    const content = node_fs_1.default.readFileSync(fullPath, "utf8").trim();
+    return { content, filePath };
+}
+function isTrackedFile(cwd, filePath) {
+    try {
+        (0, node_child_process_1.execFileSync)("git", ["ls-files", "--error-unmatch", "--", filePath], {
+            cwd,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function consumeNextReleaseFile(cwd, filePath) {
+    const tracked = isTrackedFile(cwd, filePath);
+    const fullPath = node_path_1.default.join(cwd, filePath);
+    if (node_fs_1.default.existsSync(fullPath)) {
+        node_fs_1.default.rmSync(fullPath);
+    }
+    return { tracked };
+}
 function listTrackedDirtyFiles(cwd) {
     const status = (0, node_child_process_1.execFileSync)("git", ["status", "--porcelain", "--untracked-files=no"], {
         cwd,
@@ -251,9 +287,18 @@ function prepareReleasePr(cwd = process.cwd(), options = {}) {
     }
     const updatedArtifactFiles = (0, artifact_rules_js_1.applyConfiguredArtifactRules)(cwd, loaded.config, plan);
     const packageReleaseMetadata = buildPackageReleaseMetadata(cwd, plan, loaded.config);
-    const section = (0, changelog_js_1.renderReleasePlanChangelog)(plan);
+    const nextReleaseRead = readNextReleaseHighlights(cwd, loaded.config);
+    const highlights = nextReleaseRead?.content ?? "";
+    const section = (0, changelog_js_1.renderReleasePlanChangelog)(plan, { highlights, cwd });
     (0, changelog_js_1.prependChangelog)(cwd, plan.changelogFile, section, plan.changelogFormat);
     const updatedChangelogFiles = [plan.changelogFile];
+    let consumedHighlightsPath = null;
+    if (nextReleaseRead) {
+        const { tracked } = consumeNextReleaseFile(cwd, nextReleaseRead.filePath);
+        if (tracked) {
+            consumedHighlightsPath = nextReleaseRead.filePath;
+        }
+    }
     for (const packagePlan of plan.packages ?? []) {
         if (!packagePlan.nextVersion || packagePlan.path === ".") {
             continue;
@@ -296,6 +341,7 @@ function prepareReleasePr(cwd = process.cwd(), options = {}) {
             ...updatedVersionFiles,
             ...updatedArtifactFiles,
             ...updatedChangelogFiles,
+            ...(consumedHighlightsPath ? [consumedHighlightsPath] : []),
         ]),
     ];
     (0, node_child_process_1.execFileSync)("git", ["add", ...filesToAdd], {
@@ -325,9 +371,10 @@ function prepareReleasePr(cwd = process.cwd(), options = {}) {
         commits: plan.commits,
         plan,
         updated,
+        highlights,
     };
 }
-function renderSimpleReviewRequestBody(version, previousVersion, commits, plan = null, cwd = process.cwd()) {
+function renderSimpleReviewRequestBody(version, previousVersion, commits, plan = null, cwd = process.cwd(), highlights = "") {
     const rootPackageLabel = node_path_1.default.basename(cwd);
     const formatPackageLabel = (packagePath) => packagePath === "." ? rootPackageLabel : packagePath;
     const isDirectBump = (pkg) => pkg.bumpReason === "direct" ||
@@ -361,6 +408,7 @@ function renderSimpleReviewRequestBody(version, previousVersion, commits, plan =
             const rootNotes = (0, changelog_js_1.renderReleasePlanChangelog)(plan, {
                 headerLabel: `${formatPackageLabel(".")}: ${rootPackage.nextVersion}`,
                 cwd,
+                highlights,
             });
             sections.push(rootNotes);
         }
@@ -393,6 +441,7 @@ function renderSimpleReviewRequestBody(version, previousVersion, commits, plan =
         nextVersion: version,
         commits,
         cwd,
+        highlights,
     }, { includeFooter: true });
 }
 async function openOrUpdateReviewRequest(cwd, branch, title, version, previousVersion, commits, plan = null, options = {}) {
@@ -406,7 +455,7 @@ async function openOrUpdateReviewRequest(cwd, branch, title, version, previousVe
         baseBranch: process.env.VERSIONARY_BASE_BRANCH ?? "main",
         headBranch: branch,
         title,
-        body: renderSimpleReviewRequestBody(version, previousVersion, commits, plan, cwd),
+        body: renderSimpleReviewRequestBody(version, previousVersion, commits, plan, cwd, options.highlights ?? ""),
         labels: ["release"],
     }, {
         cwd,

package/dist/types/config.d.ts

@@ -26,6 +26,7 @@ export interface VersionaryConfig {
     "release-reference-comments"?: ReleaseReferenceCommentsMode;
     "release-branch"?: string;
     "baseline-file"?: string;
+    "next-release-file"?: string;
     "bootstrap-sha"?: string;
     "monorepo-mode"?: "independent" | "fixed";
     "bump-minor-pre-major"?: boolean;

package/package.json

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