versionary 1.4.0 → 1.4.1

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "versionary",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "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",