versionary 1.4.0 → 1.5.0

package/dist/action/index.js

@@ -1,6 +1,6 @@
 import { execFileSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { appendFileSync } from "node:fs";
+import { appendFileSync, readFileSync } from "node:fs";
 function getInput(name) {
     const canonical = `INPUT_${name.replace(/ /g, "_").toUpperCase()}`;
     const underscoreAlias = canonical.replace(/-/g, "_");
@@ -74,9 +74,41 @@ function setOutput(name, value) {
     const delimiter = `versionary-${randomUUID()}`;
     appendFileSync(outputPath, `${name}<<${delimiter}\n${value}\n${delimiter}\n`, "utf8");
 }
+function isForkRepository() {
+    const eventPath = process.env.GITHUB_EVENT_PATH;
+    if (!eventPath) {
+        return false;
+    }
+    try {
+        const event = JSON.parse(readFileSync(eventPath, "utf8"));
+        return event?.repository?.fork === true;
+    }
+    catch {
+        // Only a confirmed fork may bypass the token requirement.
+        return false;
+    }
+}
+function skipRun(action, message) {
+    const payload = { action, message, releaseCreated: false, tagNames: [] };
+    process.stdout.write(`${JSON.stringify(payload)}\n`);
+    setOutput("action", action);
+    setOutput("message", message);
+    setOutput("release_created", "false");
+    setOutput("tag_name", "");
+    setOutput("tag_names", "[]");
+    setOutput("release_targets", "[]");
+    setOutput("review_url", "");
+    setOutput("review_requests", "[]");
+    setOutput("branch", "");
+    setOutput("title", "");
+}
 function main() {
     const token = getInput("token");
     if (!token) {
+        if (isForkRepository()) {
+            skipRun("fork-skipped", "Skipping release automation in a fork without a release token.");
+            return;
+        }
         throw new Error("Input required and not supplied: token.");
     }
     const versionaryVersion = getInput("versionary-version") || "0.7.0";
@@ -120,25 +152,8 @@ function main() {
             // recovery cycle.
             const releaseCanPublish = hasVersionaryReleaseMarker(cwd, sha) && isAncestor(cwd, sha, remoteSha);
             if (!releaseCanPublish) {
-                const staleMessage = `Skipping stale push run for ${sha.slice(0, 7)}; ` +
-                    `${ref} now points to ${remoteSha.slice(0, 7)}.`;
-                const stalePayload = {
-                    action: "stale-run-skipped",
-                    message: staleMessage,
-                    releaseCreated: false,
-                    tagNames: [],
-                };
-                process.stdout.write(`${JSON.stringify(stalePayload)}\n`);
-                setOutput("action", stalePayload.action);
-                setOutput("message", stalePayload.message);
-                setOutput("release_created", "false");
-                setOutput("tag_name", "");
-                setOutput("tag_names", "[]");
-                setOutput("release_targets", "[]");
-                setOutput("review_url", "");
-                setOutput("review_requests", "[]");
-                setOutput("branch", "");
-                setOutput("title", "");
+                skipRun("stale-run-skipped", `Skipping stale push run for ${sha.slice(0, 7)}; ` +
+                    `${ref} now points to ${remoteSha.slice(0, 7)}.`);
                 return;
             }
         }

package/dist/cli/index.js

@@ -2,6 +2,7 @@
 import { execFileSync } from "node:child_process";
 import { loadConfig } from "../config/load-config.js";
 import { prependChangelog, renderReleasePlanChangelog, } from "../release/changelog.js";
+import { runDirectRelease } from "../release/direct.js";
 import { createReleasePlan } from "../release/plan.js";
 import { closeStaleReviewRequestIfExists, isReleaseCommitMessage, openOrUpdateReviewRequest, preparePendingReleasePr, preparePendingSeparateReleasePrs, prepareReleasePr, prepareSeparateReleasePrs, pushReleaseBranch, reconcileSeparateReviewRequests, resolveReleaseHighlights, } from "../release/pr.js";
 import { runRelease, runReleaseDetailed } from "../release/release.js";
@@ -194,6 +195,36 @@ async function main() {
     const flags = parseFlags(args);
     const logger = flags.json ? undefined : console;
     if (!command || command === "run") {
+        if (loadConfig(process.cwd()).config["review-mode"] === "direct") {
+            const release = await runDirectRelease(process.cwd(), {
+                logger,
+                "dry-run": flags["dry-run"],
+            });
+            const message = release.action === "release-skipped" ? release.reason : release.message;
+            if (flags.json) {
+                emitJson({
+                    action: release.action,
+                    message,
+                    releaseCreated: release.action === "release-published" &&
+                        release.releases.length > 0,
+                    tagNames: release.action === "release-published"
+                        ? release.releases.map((target) => target.tag)
+                        : release.action === "release-dry-run"
+                            ? release.targets.map((target) => target.tag)
+                            : [],
+                    ...("releaseTargets" in release
+                        ? { releaseTargets: release.releaseTargets }
+                        : {}),
+                    ...(release.action === "release-dry-run"
+                        ? { targets: release.targets }
+                        : {}),
+                });
+            }
+            else {
+                console.log(message);
+            }
+            return 0;
+        }
         const commitMessage = execFileSync("git", ["log", "-1", "--pretty=%B"], {
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"],

package/dist/config/schema.d.ts

@@ -13,6 +13,7 @@ export declare const configSchema: z.ZodObject<{
         "r-news": "r-news";
     }>>;
     "release-draft": z.ZodOptional<z.ZodBoolean>;
+    "release-latest": z.ZodOptional<z.ZodBoolean>;
     "release-reference-comments": z.ZodOptional<z.ZodEnum<{
         "best-effort": "best-effort";
         off: "off";
@@ -40,6 +41,7 @@ export declare const configSchema: z.ZodObject<{
             "r-news": "r-news";
         }>>;
         "release-draft": z.ZodOptional<z.ZodBoolean>;
+        "release-latest": z.ZodOptional<z.ZodBoolean>;
         "bump-minor-pre-major": z.ZodOptional<z.ZodBoolean>;
         "allow-stable-major": z.ZodOptional<z.ZodBoolean>;
         "exclude-paths": z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/config/schema.js

@@ -69,6 +69,7 @@ const packageSchema = z
     "changelog-file": z.string().optional(),
     "changelog-format": z.enum(["markdown-changelog", "r-news"]).optional(),
     "release-draft": z.boolean().optional(),
+    "release-latest": z.boolean().optional(),
     "bump-minor-pre-major": deprecatedBumpMinorPreMajorSchema,
     "allow-stable-major": z.boolean().optional(),
     "exclude-paths": z.array(z.string()).optional(),
@@ -95,6 +96,7 @@ export const configSchema = z
     "changelog-file": z.string().optional(),
     "changelog-format": z.enum(["markdown-changelog", "r-news"]).optional(),
     "release-draft": z.boolean().optional(),
+    "release-latest": z.boolean().optional(),
     "release-reference-comments": z
         .enum(["off", "best-effort", "strict"])
         .optional(),

package/dist/release/direct.d.ts

@@ -0,0 +1,5 @@
+import { type RunReleaseOptions, type RunReleaseResult } from "./release.js";
+export declare function runDirectRelease(cwd?: string, options?: RunReleaseOptions): Promise<RunReleaseResult | {
+    action: "noop";
+    message: string;
+}>;

package/dist/release/direct.js

@@ -0,0 +1,80 @@
+import { execFileSync } from "node:child_process";
+import { loadConfig } from "../config/load-config.js";
+import { createReleasePlan } from "./plan.js";
+import { buildReleaseTargets, isReleaseCommitMessage, preparePendingReleasePr, prepareReleasePr, } from "./pr.js";
+import { runReleaseDetailed, } from "./release.js";
+import { hasFullyUntaggedPendingRelease, hasReleaseStateChangeAtHead, readPendingReleaseTargets, } from "./state.js";
+import { releaseTargetHandoff } from "./targets.js";
+function git(cwd, ...args) {
+    return execFileSync("git", args, {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+}
+function resolveDirectBranch(cwd) {
+    const ref = process.env.GITHUB_REF ?? "";
+    const branch = process.env.VERSIONARY_BASE_BRANCH ||
+        (ref.startsWith("refs/heads/") ? ref.slice("refs/heads/".length) : "") ||
+        git(cwd, "branch", "--show-current");
+    if (!branch) {
+        throw new Error("Direct releases require a branch. Check out the release base branch or set VERSIONARY_BASE_BRANCH.");
+    }
+    git(cwd, "check-ref-format", `refs/heads/${branch}`);
+    return branch;
+}
+function pushDirectRelease(cwd, branch) {
+    git(cwd, "fetch", "origin", `refs/heads/${branch}`);
+    try {
+        // An earlier release may finish after a newer commit has reached trunk.
+        git(cwd, "merge-base", "--is-ancestor", "HEAD", "FETCH_HEAD");
+        return;
+    }
+    catch {
+        // A normal push rejects concurrent divergent updates without rewriting trunk.
+    }
+    try {
+        git(cwd, "push", "origin", `HEAD:refs/heads/${branch}`);
+    }
+    catch (error) {
+        throw new Error(`Failed pushing direct release commit to ${branch}; no release was published. Check branch permissions and whether the branch advanced, then retry.`, { cause: error });
+    }
+}
+export async function runDirectRelease(cwd = process.cwd(), options = {}) {
+    const releaseContext = isReleaseCommitMessage(git(cwd, "log", "-1", "--pretty=%B")) ||
+        hasReleaseStateChangeAtHead(cwd);
+    if (!releaseContext) {
+        const pending = hasFullyUntaggedPendingRelease(cwd);
+        const plan = pending ? undefined : createReleasePlan(cwd);
+        if (plan && !plan.nextVersion) {
+            return {
+                action: "noop",
+                message: "No releasable commits found. Nothing to do.",
+            };
+        }
+        if (options["dry-run"]) {
+            const targets = plan
+                ? buildReleaseTargets(cwd, plan, loadConfig(cwd).config)
+                : readPendingReleaseTargets(cwd);
+            return {
+                action: "release-dry-run",
+                message: `Dry run: would ${pending ? "recover and publish" : "prepare and publish"} releases ${targets.map((target) => target.tag).join(", ")}`,
+                targets: targets.map(({ tag, version }) => ({ tag, version })),
+                releaseTargets: releaseTargetHandoff(targets, options.logger),
+            };
+        }
+        const branch = resolveDirectBranch(cwd);
+        if (pending) {
+            preparePendingReleasePr(cwd, { logger: options.logger, branch });
+        }
+        else {
+            prepareReleasePr(cwd, { logger: options.logger, branch });
+        }
+        pushDirectRelease(cwd, branch);
+    }
+    else if (!options["dry-run"]) {
+        // A retry may start at a release commit whose previous branch push failed.
+        pushDirectRelease(cwd, resolveDirectBranch(cwd));
+    }
+    return runReleaseDetailed(cwd, options);
+}

package/dist/release/pr.d.ts

@@ -1,3 +1,4 @@
+import { loadConfig } from "../config/load-config.js";
 import type { ParsedCommit } from "../git/commits.js";
 import type { VersionaryChangelogFormat, VersionaryConfig } from "../types/config.js";
 import type { VersionaryPluginContext } from "../types/plugins.js";
@@ -21,6 +22,7 @@ export declare function splitSafeDirtyFiles(files: string[]): {
     ignored: string[];
     blocking: string[];
 };
+export declare function buildReleaseTargets(cwd: string, plan: ReleasePlan, loadedConfig: ReturnType<typeof loadConfig>["config"]): ReleaseTargetState[];
 export interface PendingReleasePrResult {
     branch: string;
     title: string;
@@ -36,6 +38,7 @@ export declare function renderPendingReleaseReviewRequestBody(targets: ReleaseTa
  */
 export declare function preparePendingReleasePr(cwd?: string, options?: {
     logger?: VersionaryPluginContext["logger"];
+    branch?: string;
 }): PendingReleasePrResult;
 /**
  * Recreate each unpublished package cohort on its own corrected-base branch.
@@ -48,6 +51,7 @@ export declare function preparePendingSeparateReleasePrs(cwd?: string, options?:
 }): SeparateReviewCandidate[];
 export declare function prepareReleasePr(cwd?: string, options?: {
     logger?: VersionaryPluginContext["logger"];
+    branch?: string;
 }): {
     branch: string;
     title: string;

package/dist/release/pr.js

@@ -133,7 +133,7 @@ function fetchRemoteReleaseBranch(cwd, branch) {
     });
     return remoteRef;
 }
-function buildReleaseTargets(cwd, plan, loadedConfig) {
+export function buildReleaseTargets(cwd, plan, loadedConfig) {
     const releasingPaths = new Set(plan.packages?.filter((pkg) => pkg.nextVersion).map((pkg) => pkg.path) ?? [
         ".",
     ]);
@@ -237,7 +237,7 @@ export function preparePendingReleasePr(cwd = process.cwd(), options = {}) {
     }
     ensureCleanWorktree(cwd, options.logger);
     const loaded = loadConfig(cwd);
-    const branch = loaded.config["release-branch"] ?? "versionary/release";
+    const branch = options.branch ?? loaded.config["release-branch"] ?? "versionary/release";
     const title = formatReleaseCommitTitle(targets);
     const releaseBaselineSha = execFileSync("git", ["rev-parse", "HEAD"], {
         cwd,
@@ -466,7 +466,7 @@ export function prepareReleasePr(cwd = process.cwd(), options = {}) {
         updatedChangelogFiles.push(packageChangelogPath);
     }
     const releaseTargets = buildReleaseTargets(cwd, plan, loaded.config);
-    const branch = plan.releaseBranchPrefix;
+    const branch = options.branch ?? plan.releaseBranchPrefix;
     const title = formatReleaseCommitTitle(releaseTargets);
     const hasRemoteReleaseBranch = remoteReleaseBranchExists(cwd, branch);
     const remoteReleaseRef = hasRemoteReleaseBranch

package/dist/release/release.d.ts

@@ -2,6 +2,7 @@ import type { VersionaryConfig } from "../types/config.js";
 import type { VersionaryPluginContext } from "../types/plugins.js";
 export declare function resolveTargetPackageName(cwd: string, config: VersionaryConfig, targetPath: string): string | undefined;
 export declare function resolveTargetReleaseDraft(config: VersionaryConfig, targetPath: string): boolean;
+export declare function resolveTargetReleaseLatest(config: VersionaryConfig, targetPath: string): boolean;
 export declare function extractReleaseNotes(content: string, version: string, changelogFormat: "markdown-changelog" | "r-news"): string;
 export declare function extractClosingReferencesFromNotes(notes: string): number[];
 export declare function resolveTargetChangelogFile(config: VersionaryConfig, rootChangelogFile: string, targetPath: string): string;

package/dist/release/release.js

@@ -27,6 +27,11 @@ export function resolveTargetReleaseDraft(config, targetPath) {
         config["release-draft"] ??
         false);
 }
+export function resolveTargetReleaseLatest(config, targetPath) {
+    return (config.packages?.[targetPath]?.["release-latest"] ??
+        config["release-latest"] ??
+        targetPath === ".");
+}
 export function extractReleaseNotes(content, version, changelogFormat) {
     const lines = content.split("\n");
     const shortVersion = version.replace(/\.\d+$/u, "");
@@ -204,7 +209,9 @@ export async function runReleaseDetailed(cwd = process.cwd(), options = {}) {
             version: target.version,
             notes: releaseNotes,
             draft: resolveTargetReleaseDraft(loaded.config, target.path),
-            makeLatest: target.path === "." ? "true" : "false",
+            makeLatest: resolveTargetReleaseLatest(loaded.config, target.path)
+                ? "true"
+                : "false",
         }, {
             createReleaseMetadata: (input) => scmClient.createReleaseMetadata(input, {
                 cwd,

package/dist/strategy/package-context.js

@@ -5,7 +5,8 @@ export function resolveReleaseName(cwd, packagePath, packageConfig, strategy, st
     if (configuredName) {
         return configuredName;
     }
-    return strategy.readPackageName?.(cwd, strategyConfig) ?? packagePath;
+    return (strategy.readPackageName?.(cwd, strategyConfig) ??
+        (packagePath === "." ? path.basename(cwd) : packagePath));
 }
 function withVersionFile(config, versionFile) {
     return {

package/dist/strategy/rust.js

@@ -758,20 +758,16 @@ export const rustVersionStrategy = {
     },
     readPackageName(cwd, config) {
         const versionFile = this.getVersionFile(config);
-        const manifests = collectRustTargetManifests(cwd, versionFile, !config.packages);
-        const selectedManifest = manifests[0];
-        if (!selectedManifest) {
-            throw new Error(`Configured rust target "${versionFile}" did not resolve to a Rust crate manifest.`);
-        }
-        const versionPath = path.join(cwd, selectedManifest);
+        const versionPath = path.join(cwd, versionFile);
         if (!fs.existsSync(versionPath)) {
-            throw new Error(`Versionary requires ${selectedManifest} to exist.`);
+            throw new Error(`Versionary requires ${versionFile} to exist.`);
         }
         const cargoTomlRaw = fs.readFileSync(versionPath, "utf8");
-        if (!isCrateManifest(selectedManifest, cargoTomlRaw)) {
+        // A virtual workspace has no package name of its own to return.
+        if (!isCrateManifest(versionFile, cargoTomlRaw)) {
             return null;
         }
-        return readCargoPackageName(cargoTomlRaw, selectedManifest);
+        return readCargoPackageName(cargoTomlRaw, versionFile);
     },
     isPublishable(cwd, pkg) {
         const manifest = normalizeSlashPath(pkg.versionFile);

package/dist/types/config.d.ts

@@ -15,6 +15,7 @@ export interface VersionaryPackage {
     "changelog-file"?: string;
     "changelog-format"?: VersionaryChangelogFormat;
     "release-draft"?: boolean;
+    "release-latest"?: boolean;
     /** @deprecated Use `allow-stable-major` with the inverse value. */
     "bump-minor-pre-major"?: boolean;
     "allow-stable-major"?: boolean;
@@ -29,6 +30,7 @@ export interface VersionaryConfig {
     "changelog-file"?: string;
     "changelog-format"?: VersionaryChangelogFormat;
     "release-draft"?: boolean;
+    "release-latest"?: boolean;
     "release-reference-comments"?: ReleaseReferenceCommentsMode;
     "release-branch"?: string;
     "separate-release-prs"?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "versionary",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Automatic release framework based on conventional commits and semantic versioning",
   "keywords": [
     "releasing",
@@ -39,7 +39,7 @@
     "typescript": "^7.0.2",
     "vite": "^8.0.0",
     "vitepress": "^1.6.4",
-    "vitest": "^4.1.4"
+    "vitest": "^5.0.0"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",