versionary 0.29.0 → 0.30.0

package/README.md

@@ -190,6 +190,12 @@ For a quick trial, use:
     combining `follows` with `monorepo-mode: "fixed"` are config errors.
     `follows` is non-transitive: A follows B does not imply A follows what B
     follows.
+  - per-package `exclude-paths` drops commits that only touch the listed paths
+    (relative to the package) from that package's bump and changelog. A
+    top-level `exclude-paths` applies to every package; the effective excludes
+    for a package are the union of the top-level list and the package's own
+    list. The top-level list also applies to a single-package (non-`packages`)
+    repository.
 
 ```jsonc
 // Editor extension that bundles the root CLI artifact

package/dist/config/schema.d.ts

@@ -30,6 +30,7 @@ export declare const configSchema: z.ZodObject<{
     "bump-minor-pre-major": z.ZodOptional<z.ZodBoolean>;
     "allow-stable-major": z.ZodOptional<z.ZodBoolean>;
     "include-commit-authors": z.ZodOptional<z.ZodBoolean>;
+    "exclude-paths": z.ZodOptional<z.ZodArray<z.ZodString>>;
     "release-type": z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
     packages: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         "release-type": z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;

package/dist/config/schema.js

@@ -82,6 +82,7 @@ export const configSchema = z
     "bump-minor-pre-major": z.boolean().optional(),
     "allow-stable-major": z.boolean().optional(),
     "include-commit-authors": z.boolean().optional(),
+    "exclude-paths": z.array(z.string()).optional(),
     "release-type": z
         .union([z.string().min(1), z.array(z.string().min(1)).min(1)])
         .optional(),

package/dist/release/plan.js

@@ -58,9 +58,22 @@ export function createReleasePlan(cwd = process.cwd()) {
             throw new Error(`Versionary requires ${packageContext.versionFile} to exist for package "${pkg.path}".`);
         }
         const packageCurrentVersion = packageContext.strategy.readVersion(cwd, packageContext.config);
-        const parsedCommits = !hasPackages && pkg.path === "."
-            ? getParsedCommitsSinceLastTag(cwd, baselineSha)
-            : getParsedCommitsForPath(cwd, releaseTargetByPath.get(pkg.path)?.tag ?? baselineSha, pkg.path, pkg.config["exclude-paths"] ?? []);
+        const excludePaths = [
+            ...new Set([
+                ...(loaded.config["exclude-paths"] ?? []),
+                ...(pkg.config["exclude-paths"] ?? []),
+            ]),
+        ];
+        const isImplicitRoot = !hasPackages && pkg.path === ".";
+        let parsedCommits;
+        if (isImplicitRoot && excludePaths.length === 0) {
+            parsedCommits = getParsedCommitsSinceLastTag(cwd, baselineSha);
+        }
+        else {
+            parsedCommits = getParsedCommitsForPath(cwd, isImplicitRoot
+                ? baselineSha
+                : (releaseTargetByPath.get(pkg.path)?.tag ?? baselineSha), pkg.path, excludePaths);
+        }
         const effectiveCommits = applyRevertSuppression(parsedCommits);
         const commits = effectiveCommits;
         const releaseType = analyzeParsedCommits(parsedCommits);

package/dist/release/release.js

@@ -8,7 +8,7 @@ import { resolveVersionStrategy } from "../strategy/resolve.js";
 import { getChangelogDefaults } from "./plan.js";
 import { isReleaseCommitMessage } from "./pr.js";
 import { executeIdempotentReleaseTarget } from "./recovery.js";
-import { readReleaseTargets } from "./state.js";
+import { readPendingReleaseTargets } from "./state.js";
 function escapeRegExp(input) {
     return input.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
@@ -147,7 +147,7 @@ export async function runReleaseDetailed(cwd = process.cwd(), options = {}) {
     const referenceCommentMode = loaded.config["release-reference-comments"] ?? "off";
     const version = strategy.readVersion(cwd, loaded.config);
     const defaultTag = `v${version}`;
-    const releaseTargets = readReleaseTargets(cwd);
+    const releaseTargets = readPendingReleaseTargets(cwd);
     const targets = releaseTargets.length > 0
         ? releaseTargets
         : [
@@ -195,7 +195,8 @@ export async function runReleaseDetailed(cwd = process.cwd(), options = {}) {
             tagStatus: outcome.tagStatus,
             metadataStatus: outcome.metadataStatus,
         });
-        if (references.length > 0) {
+        const releaseWasCreated = outcome.tagStatus === "created" || outcome.metadataStatus === "created";
+        if (references.length > 0 && releaseWasCreated) {
             referenceReleases.push({
                 name: resolveTargetPackageName(cwd, loaded.config, target.path),
                 tag: outcome.tag,

package/dist/release/state.d.ts

@@ -6,4 +6,5 @@ export interface ReleaseTargetState {
 export declare function getBaselineStatePath(cwd: string): string;
 export declare function readBaselineSha(cwd?: string): string | null;
 export declare function readReleaseTargets(cwd?: string): ReleaseTargetState[];
+export declare function readPendingReleaseTargets(cwd?: string): ReleaseTargetState[];
 export declare function writeBaselineSha(cwd?: string, sha?: string, releaseTargets?: ReleaseTargetState[]): void;

package/dist/release/state.js

@@ -5,6 +5,7 @@ import { loadConfig } from "../config/load-config.js";
 const MANIFEST_VERSION_KEY = "manifest-version";
 const BASELINE_SHA_KEY = "baseline-sha";
 const RELEASE_TARGETS_KEY = "release-targets";
+const PENDING_RELEASE_TARGETS_KEY = "pending-release-targets";
 function parseStateFile(raw, filePath) {
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
@@ -19,24 +20,28 @@ function parseStateFile(raw, filePath) {
         typeof manifest[BASELINE_SHA_KEY] !== "string") {
         throw new Error(`Invalid release manifest at ${filePath}: ${BASELINE_SHA_KEY} must be a string.`);
     }
-    if (manifest[RELEASE_TARGETS_KEY] !== undefined &&
-        !Array.isArray(manifest[RELEASE_TARGETS_KEY])) {
-        throw new Error(`Invalid release manifest at ${filePath}: ${RELEASE_TARGETS_KEY} must be an array.`);
+    validateReleaseTargets(manifest[RELEASE_TARGETS_KEY], RELEASE_TARGETS_KEY, filePath);
+    validateReleaseTargets(manifest[PENDING_RELEASE_TARGETS_KEY], PENDING_RELEASE_TARGETS_KEY, filePath);
+    return manifest;
+}
+function validateReleaseTargets(value, key, filePath) {
+    if (value === undefined) {
+        return;
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`Invalid release manifest at ${filePath}: ${key} must be an array.`);
     }
-    if (Array.isArray(manifest[RELEASE_TARGETS_KEY])) {
-        for (const target of manifest[RELEASE_TARGETS_KEY]) {
-            if (!target || typeof target !== "object" || Array.isArray(target)) {
-                throw new Error(`Invalid release manifest at ${filePath}: each release target must be an object.`);
-            }
-            const record = target;
-            if (typeof record.path !== "string" ||
-                typeof record.version !== "string" ||
-                typeof record.tag !== "string") {
-                throw new Error(`Invalid release manifest at ${filePath}: ${RELEASE_TARGETS_KEY} must contain string path, version, and tag.`);
-            }
+    for (const target of value) {
+        if (!target || typeof target !== "object" || Array.isArray(target)) {
+            throw new Error(`Invalid release manifest at ${filePath}: each release target must be an object.`);
+        }
+        const record = target;
+        if (typeof record.path !== "string" ||
+            typeof record.version !== "string" ||
+            typeof record.tag !== "string") {
+            throw new Error(`Invalid release manifest at ${filePath}: ${key} must contain string path, version, and tag.`);
         }
     }
-    return manifest;
 }
 export function getBaselineStatePath(cwd) {
     const loaded = loadConfig(cwd);
@@ -62,6 +67,9 @@ export function readBaselineSha(cwd = process.cwd()) {
     const parsed = parseStateFile(fs.readFileSync(filePath, "utf8"), filePath);
     return parsed[BASELINE_SHA_KEY] ?? null;
 }
+// Accumulated per-package baseline: the latest released tag for every package
+// ever released. `plan` uses these tags as the commit-range floor per package,
+// so this list must persist entries across releases rather than be replaced.
 export function readReleaseTargets(cwd = process.cwd()) {
     const filePath = getBaselineStatePath(cwd);
     if (!fs.existsSync(filePath)) {
@@ -70,6 +78,18 @@ export function readReleaseTargets(cwd = process.cwd()) {
     const parsed = parseStateFile(fs.readFileSync(filePath, "utf8"), filePath);
     return parsed[RELEASE_TARGETS_KEY] ?? [];
 }
+// The publish set introduced by the current release PR. `release` consumes this
+// so it only publishes/announces what this PR bumped, not every package in the
+// accumulated baseline. Falls back to the accumulated targets for manifests
+// written before this key existed (legacy compatibility).
+export function readPendingReleaseTargets(cwd = process.cwd()) {
+    const filePath = getBaselineStatePath(cwd);
+    if (!fs.existsSync(filePath)) {
+        return [];
+    }
+    const parsed = parseStateFile(fs.readFileSync(filePath, "utf8"), filePath);
+    return (parsed[PENDING_RELEASE_TARGETS_KEY] ?? parsed[RELEASE_TARGETS_KEY] ?? []);
+}
 export function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets) {
     const baselineShaValue = sha ??
         execFileSync("git", ["rev-parse", "HEAD"], {
@@ -82,6 +102,9 @@ export function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets) {
         ? parseStateFile(fs.readFileSync(filePath, "utf8"), filePath)
         : {};
     const existingTargets = existing[RELEASE_TARGETS_KEY] ?? [];
+    // Merge the current targets into the accumulated baseline (latest tag per
+    // path wins, since `releaseTargets` is appended last), but record the current
+    // targets verbatim as the pending publish set.
     const nextTargets = releaseTargets === undefined
         ? existingTargets
         : [
@@ -90,10 +113,14 @@ export function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets) {
                 target,
             ])).values(),
         ].sort((a, b) => a.path.localeCompare(b.path));
+    const nextPending = releaseTargets === undefined
+        ? (existing[PENDING_RELEASE_TARGETS_KEY] ?? [])
+        : [...releaseTargets].sort((a, b) => a.path.localeCompare(b.path));
     const next = {
         [MANIFEST_VERSION_KEY]: 1,
         [BASELINE_SHA_KEY]: baselineShaValue,
         [RELEASE_TARGETS_KEY]: nextTargets,
+        [PENDING_RELEASE_TARGETS_KEY]: nextPending,
     };
     fs.writeFileSync(filePath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
 }

package/dist/scm/github-plugin.js

@@ -99,14 +99,30 @@ function groupReleasesByIssue(releases) {
     }
     return new Map([...byIssue.entries()].sort(([a], [b]) => a - b));
 }
+const RELEASE_REFERENCE_COMMENT_FOOTER = "Released by [Versionary](https://github.com/jolars/versionary).";
 function renderReleaseLink(release) {
     if (release.name) {
         return `[\`${release.name}\` v${release.version}](${release.releaseUrl})`;
     }
     return `[version ${release.version}](${release.releaseUrl})`;
 }
+// Reads bodies of prior Versionary release-reference comments on an issue so we
+// can avoid re-announcing a release that has already been posted (e.g. when an
+// already-published target is re-processed on a later release run).
+async function readExistingReferenceComments(octokit, repo, issueNumber) {
+    const response = await octokit.issues.listComments({
+        owner: repo.owner,
+        repo: repo.repo,
+        issue_number: issueNumber,
+        per_page: 100,
+    });
+    return response.data
+        .map((comment) => comment.body ?? "")
+        .filter((body) => body.includes(RELEASE_REFERENCE_COMMENT_FOOTER))
+        .join("\n");
+}
 function renderReleaseReferenceCommentBody(releases) {
-    const footer = "Released by [Versionary](https://github.com/jolars/versionary).";
+    const footer = RELEASE_REFERENCE_COMMENT_FOOTER;
     if (releases.length === 1) {
         const release = releases[0];
         if (!release) {
@@ -312,7 +328,24 @@ export function createGitHubPlugin() {
             const releasesByIssue = groupReleasesByIssue(input.releases);
             const commented = [];
             for (const [reference, releases] of releasesByIssue) {
-                const body = renderReleaseReferenceCommentBody(releases);
+                let announcedText;
+                try {
+                    announcedText = await readExistingReferenceComments(octokit, repo, reference);
+                }
+                catch (error) {
+                    const { message } = parseGitHubError(error);
+                    if (mode === "strict") {
+                        throw new Error(`Failed listing existing comments on #${reference}: [${repoRef(repo)}] ${message}`);
+                    }
+                    context.logger?.warn(`Could not check existing comments on #${reference}, posting anyway: [${repoRef(repo)}] ${message}`);
+                    announcedText = "";
+                }
+                const pendingReleases = releases.filter((release) => !announcedText.includes(release.releaseUrl));
+                if (pendingReleases.length === 0) {
+                    context.logger?.info(`Skipping release reference comment on #${reference}: already announced.`);
+                    continue;
+                }
+                const body = renderReleaseReferenceCommentBody(pendingReleases);
                 try {
                     await octokit.issues.createComment({
                         owner: repo.owner,

package/dist/types/config.d.ts

@@ -33,6 +33,7 @@ export interface VersionaryConfig {
     "bump-minor-pre-major"?: boolean;
     "allow-stable-major"?: boolean;
     "include-commit-authors"?: boolean;
+    "exclude-paths"?: string[];
     "release-type"?: string | string[];
     packages?: Record<string, VersionaryPackage>;
 }

package/package.json

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