versionary 0.2.0 → 0.4.0

package/dist/{simple → app/release}/pr.js

@@ -9,16 +9,15 @@ exports.renderSimpleReviewRequestBody = renderSimpleReviewRequestBody;
 exports.openOrUpdateSimpleReviewRequest = openOrUpdateSimpleReviewRequest;
 exports.pushReleaseBranch = pushReleaseBranch;
 exports.isReleaseCommitMessage = isReleaseCommitMessage;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
 const node_child_process_1 = require("node:child_process");
-const load_config_js_1 = require("../config/load-config.js");
-const capabilities_js_1 = require("../plugins/capabilities.js");
-const runtime_js_1 = require("../plugins/runtime.js");
-const plan_js_1 = require("./plan.js");
-const git_js_1 = require("./git.js");
-const repo_url_js_1 = require("./repo-url.js");
-const changelog_js_1 = require("./changelog.js");
+const node_path_1 = __importDefault(require("node:path"));
+const load_config_js_1 = require("../../config/load-config.js");
+const changelog_js_1 = require("../../domain/release/changelog.js");
+const plan_js_1 = require("../../domain/release/plan.js");
+const resolve_js_1 = require("../../domain/strategy/resolve.js");
+const capabilities_js_1 = require("../../plugins/capabilities.js");
+const runtime_js_1 = require("../../plugins/runtime.js");
+const artifact_rules_js_1 = require("./artifact-rules.js");
 const state_js_1 = require("./state.js");
 const SAFE_DIRTY_FILES = new Set([
     "pnpm-lock.yaml",
@@ -57,106 +56,118 @@ function splitSafeDirtyFiles(files) {
     }
     return { ignored, blocking };
 }
-function ensureCleanWorktree(cwd) {
+function ensureCleanWorktree(cwd, logger) {
     const dirtyFiles = listTrackedDirtyFiles(cwd);
     const { ignored, blocking } = splitSafeDirtyFiles(dirtyFiles);
     if (blocking.length > 0) {
         throw new Error(`Working tree has tracked modifications before versionary pr:\n${blocking.join("\n")}\nCommit/stash tracked changes first.`);
     }
     if (ignored.length > 0) {
-        console.warn(`Ignoring safe tracked changes before versionary pr:\n${ignored.join("\n")}`);
+        logger?.warn(`Ignoring safe tracked changes before versionary pr:\n${ignored.join("\n")}`);
     }
 }
-function prepareSimpleReleasePr(cwd = process.cwd()) {
+function prepareSimpleReleasePr(cwd = process.cwd(), options = {}) {
     const plan = (0, plan_js_1.createSimplePlan)(cwd);
+    const loaded = (0, load_config_js_1.loadConfig)(cwd);
+    const strategy = (0, resolve_js_1.resolveVersionStrategy)(loaded.config);
     if (!plan.nextVersion) {
         throw new Error("No releasable commits found. Nothing to open a release PR for.");
     }
-    ensureCleanWorktree(cwd);
-    const versionPath = node_path_1.default.join(cwd, plan.versionFile);
-    node_fs_1.default.writeFileSync(versionPath, `${plan.nextVersion}\n`, "utf8");
+    ensureCleanWorktree(cwd, options.logger);
+    const updatedVersionFiles = strategy.writeVersion(cwd, loaded.config, plan.nextVersion);
+    const updatedArtifactFiles = (0, artifact_rules_js_1.applyConfiguredArtifactRules)(cwd, loaded.config, plan);
     const section = (0, changelog_js_1.renderSimpleChangelog)(plan);
     (0, changelog_js_1.prependChangelog)(cwd, plan.changelogFile, section);
     const branch = plan.releaseBranchPrefix;
     const title = `chore(release): v${plan.nextVersion}`;
-    (0, node_child_process_1.execFileSync)("git", ["checkout", "-B", branch], { cwd, stdio: ["ignore", "pipe", "ignore"] });
-    (0, node_child_process_1.execFileSync)("git", ["add", plan.versionFile, plan.changelogFile], {
+    (0, node_child_process_1.execFileSync)("git", ["checkout", "-B", branch], {
+        cwd,
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+    const filesToAdd = [
+        ...new Set([
+            ...updatedVersionFiles,
+            ...updatedArtifactFiles,
+            plan.changelogFile,
+        ]),
+    ];
+    (0, node_child_process_1.execFileSync)("git", ["add", ...filesToAdd], {
         cwd,
         stdio: ["ignore", "pipe", "ignore"],
     });
-    (0, node_child_process_1.execFileSync)("git", ["commit", "-m", title], { cwd, stdio: ["ignore", "pipe", "ignore"] });
-    (0, state_js_1.writeBaselineSha)(cwd);
+    (0, node_child_process_1.execFileSync)("git", ["commit", "-m", title], {
+        cwd,
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+    const releaseTargets = plan.packages
+        ? plan.packages
+            .filter((pkg) => pkg.nextVersion)
+            .map((pkg) => ({
+            path: pkg.path,
+            version: pkg.nextVersion ?? "",
+            tag: pkg.path === "."
+                ? `v${pkg.nextVersion ?? ""}`
+                : `${pkg.path.replaceAll("/", "-")}-v${pkg.nextVersion ?? ""}`,
+        }))
+        : [
+            {
+                path: ".",
+                version: plan.nextVersion,
+                tag: `v${plan.nextVersion}`,
+            },
+        ];
+    (0, state_js_1.writeBaselineSha)(cwd, undefined, releaseTargets);
     (0, node_child_process_1.execFileSync)("git", ["add", (0, state_js_1.getBaselineStatePath)(cwd)], {
         cwd,
         stdio: ["ignore", "pipe", "ignore"],
     });
-    (0, node_child_process_1.execFileSync)("git", ["commit", "--amend", "--no-edit"], { cwd, stdio: ["ignore", "pipe", "ignore"] });
+    (0, node_child_process_1.execFileSync)("git", ["commit", "--amend", "--no-edit"], {
+        cwd,
+        stdio: ["ignore", "pipe", "ignore"],
+    });
     return {
         branch,
         title,
         version: plan.nextVersion,
+        previousVersion: plan.currentVersion,
         commits: plan.commits,
+        plan,
     };
 }
-function formatCommitMessage(subject) {
-    const conventional = subject.match(/^[a-z]+(?:\(([^)]+)\))?!?:\s+(.+)$/iu);
-    if (!conventional) {
-        return { label: "", message: subject };
+function renderSimpleReviewRequestBody(version, previousVersion, commits, plan = null, cwd = process.cwd()) {
+    if (plan?.packages && plan.packages.length > 1) {
+        const sections = plan.packages
+            .filter((pkg) => pkg.nextVersion)
+            .map((pkg) => {
+            const notes = (0, changelog_js_1.renderSimpleReleaseNotes)({
+                currentVersion: pkg.currentVersion,
+                nextVersion: pkg.nextVersion ?? "",
+                commits: pkg.commits,
+                cwd,
+            }, { includeFooter: false });
+            const linkedHeader = notes.match(/^##\s+\[([^\]]+)\]\(([^)]+)\)\s+\(([^)]+)\)/u);
+            if (linkedHeader) {
+                const [, , compareUrl, date] = linkedHeader;
+                return notes.replace(/^##\s+\[[^\]]+\]\([^)]+\)\s+\([^)]+\)/u, `## [${pkg.path}: ${pkg.nextVersion ?? ""}](${compareUrl}) (${date})`);
+            }
+            const plainHeader = notes.match(/^##\s+([^\s]+)\s+\(([^)]+)\)/u);
+            if (plainHeader) {
+                const [, , date] = plainHeader;
+                return notes.replace(/^##\s+[^\s]+\s+\([^)]+\)/u, `## ${pkg.path}: ${pkg.nextVersion ?? ""} (${date})`);
+            }
+            return notes;
+        })
+            .join("\n\n");
+        return `${sections}\n\nThis PR was generated by Versionary.`;
     }
-    const scope = conventional[1]?.trim();
-    const message = conventional[2]?.trim() ?? subject;
-    const label = scope ? `**${scope}:** ` : "";
-    return { label, message };
-}
-function renderSimpleReviewRequestBody(version, commits, cwd = process.cwd()) {
-    const breaking = [];
-    const features = [];
-    const fixes = [];
-    const commitBaseUrl = (0, repo_url_js_1.resolveRepositoryWebBaseUrl)(cwd);
-    for (const commit of commits) {
-        const subject = commit.subject;
-        const { label, message } = formatCommitMessage(subject);
-        const hash = commit.hash.slice(0, 7);
-        const hashLabel = commitBaseUrl ? `[\`${hash}\`](${commitBaseUrl}/commit/${commit.hash})` : `\`${hash}\``;
-        const type = (0, git_js_1.inferReleaseTypeFromSubject)(subject);
-        if (!type) {
-            continue;
-        }
-        const item = `- ${label}${message} (${hashLabel})`;
-        if (type === "major") {
-            breaking.push(item);
-            continue;
-        }
-        if (type === "minor") {
-            features.push(item);
-            continue;
-        }
-        fixes.push(item);
-    }
-    const sections = [];
-    if (breaking.length > 0) {
-        sections.push("### Breaking changes", ...breaking, "");
-    }
-    if (features.length > 0) {
-        sections.push("### Features", ...features, "");
-    }
-    if (fixes.length > 0) {
-        sections.push("### Fixes", ...fixes, "");
-    }
-    return [
-        ":robot: I have created a release PR for this repository.",
-        "",
-        `## Version`,
-        "",
-        `This PR prepares **v${version}**.`,
-        "",
-        "## Release notes preview",
-        "",
-        ...sections,
-        "This PR was generated by Versionary.",
-    ].join("\n");
+    return (0, changelog_js_1.renderSimpleReleaseNotes)({
+        currentVersion: previousVersion,
+        nextVersion: version,
+        commits,
+        cwd,
+    }, { includeFooter: true });
 }
-async function openOrUpdateSimpleReviewRequest(cwd, branch, title, version, commits) {
+async function openOrUpdateSimpleReviewRequest(cwd, branch, title, version, previousVersion, commits, plan = null, options = {}) {
     const loaded = (0, load_config_js_1.loadConfig)(cwd);
     const releaseFlow = loaded.config["review-mode"] ?? "direct";
     if (releaseFlow !== "review") {
@@ -175,11 +186,11 @@ async function openOrUpdateSimpleReviewRequest(cwd, branch, title, version, comm
         baseBranch: process.env.VERSIONARY_BASE_BRANCH ?? "main",
         headBranch: branch,
         title,
-        body: renderSimpleReviewRequestBody(version, commits, cwd),
+        body: renderSimpleReviewRequestBody(version, previousVersion, commits, plan, cwd),
         labels: ["release"],
     }, {
         cwd,
-        logger: console,
+        logger: options.logger,
     });
     return result.url;
 }

package/dist/app/release/recovery.d.ts

@@ -0,0 +1,20 @@
+import type { VersionaryScmReleaseMetadataResult } from "../../types/plugins.js";
+export type TagStepResult = "created" | "exists";
+export interface ReleaseTargetInput {
+    tag: string;
+    version: string;
+    notes: string;
+}
+export interface ReleaseExecutionContext {
+    createReleaseMetadata: (input: ReleaseTargetInput) => Promise<VersionaryScmReleaseMetadataResult>;
+    logger?: {
+        info: (message: string) => void;
+    };
+}
+export interface ReleaseTargetOutcome {
+    tag: string;
+    tagStatus: TagStepResult;
+    metadataStatus: "created" | "exists";
+    url: string;
+}
+export declare function executeIdempotentReleaseTarget(cwd: string, target: ReleaseTargetInput, context: ReleaseExecutionContext): Promise<ReleaseTargetOutcome>;

package/dist/app/release/recovery.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeIdempotentReleaseTarget = executeIdempotentReleaseTarget;
+const node_child_process_1 = require("node:child_process");
+function hasRemoteTag(cwd, tag) {
+    try {
+        const output = (0, node_child_process_1.execFileSync)("git", ["ls-remote", "--tags", "origin", `refs/tags/${tag}`], {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        return output.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+function readRemoteTagSha(cwd, tag) {
+    try {
+        const output = (0, node_child_process_1.execFileSync)("git", ["ls-remote", "--tags", "origin", `refs/tags/${tag}`], {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        if (!output) {
+            return null;
+        }
+        const [sha] = output.split(/\s+/u);
+        return sha ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function createTagWithRecovery(cwd, tag) {
+    const localTag = (0, node_child_process_1.execFileSync)("git", ["tag", "--list", tag], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    if (localTag.length > 0) {
+        const localSha = (0, node_child_process_1.execFileSync)("git", ["rev-parse", `refs/tags/${tag}`], {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        const remoteSha = readRemoteTagSha(cwd, tag);
+        if (remoteSha && remoteSha !== localSha) {
+            throw new Error(`Tag drift detected for "${tag}": local tag (${localSha.slice(0, 7)}) differs from remote (${remoteSha.slice(0, 7)}). Resolve the tag mismatch before retrying release.`);
+        }
+        return "exists";
+    }
+    try {
+        (0, node_child_process_1.execFileSync)("git", ["tag", tag], {
+            cwd,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+    }
+    catch {
+        throw new Error(`Failed creating local tag "${tag}". Ensure repository is writable and retry.`);
+    }
+    try {
+        (0, node_child_process_1.execFileSync)("git", ["push", "origin", tag], {
+            cwd,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return "created";
+    }
+    catch {
+        if (hasRemoteTag(cwd, tag)) {
+            const localSha = (0, node_child_process_1.execFileSync)("git", ["rev-parse", `refs/tags/${tag}`], {
+                cwd,
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "ignore"],
+            }).trim();
+            const remoteSha = readRemoteTagSha(cwd, tag);
+            if (remoteSha && remoteSha !== localSha) {
+                throw new Error(`Tag drift detected for "${tag}": local tag (${localSha.slice(0, 7)}) differs from remote (${remoteSha.slice(0, 7)}). Resolve the tag mismatch before retrying release.`);
+            }
+            return "exists";
+        }
+        throw new Error(`Failed pushing tag "${tag}" to origin. Check push permissions and remote connectivity, then retry.`);
+    }
+}
+async function executeIdempotentReleaseTarget(cwd, target, context) {
+    const tagStatus = createTagWithRecovery(cwd, target.tag);
+    const metadata = await context.createReleaseMetadata(target);
+    const metadataStatus = metadata.status ?? "created";
+    if (tagStatus === "exists" && metadataStatus === "created") {
+        context.logger?.info(`Recovered drift for ${target.tag}: tag already existed and release metadata has now been created.`);
+    }
+    if (!metadata.url) {
+        throw new Error(`Release metadata for "${target.tag}" did not return a URL. Verify SCM API permissions and retry.`);
+    }
+    return {
+        tag: target.tag,
+        tagStatus,
+        metadataStatus,
+        url: metadata.url,
+    };
+}

package/dist/app/release/release.d.ts

@@ -0,0 +1,19 @@
+import type { VersionaryPluginContext } from "../../types/plugins.js";
+export declare function runSimpleRelease(cwd?: string): Promise<string>;
+export type SimpleRunReleaseResult = {
+    action: "release-skipped";
+    reason: string;
+} | {
+    action: "release-published";
+    message: string;
+    releases: {
+        tag: string;
+        url: string;
+        tagStatus: "created" | "exists";
+        metadataStatus: "created" | "exists";
+    }[];
+};
+export interface RunSimpleReleaseOptions {
+    logger?: VersionaryPluginContext["logger"];
+}
+export declare function runSimpleReleaseDetailed(cwd?: string, options?: RunSimpleReleaseOptions): Promise<SimpleRunReleaseResult>;

package/dist/app/release/release.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSimpleRelease = runSimpleRelease;
+exports.runSimpleReleaseDetailed = runSimpleReleaseDetailed;
+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 resolve_js_1 = require("../../domain/strategy/resolve.js");
+const capabilities_js_1 = require("../../plugins/capabilities.js");
+const runtime_js_1 = require("../../plugins/runtime.js");
+const pr_js_1 = require("./pr.js");
+const recovery_js_1 = require("./recovery.js");
+const state_js_1 = require("./state.js");
+function getHeadCommitSubject(cwd) {
+    return (0, node_child_process_1.execFileSync)("git", ["log", "-1", "--pretty=%s"], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+}
+function readReleaseNotes(cwd, version, changelogFile) {
+    const changelogPath = node_path_1.default.join(cwd, changelogFile);
+    if (!node_fs_1.default.existsSync(changelogPath)) {
+        return `Automated release for v${version}`;
+    }
+    const content = node_fs_1.default.readFileSync(changelogPath, "utf8");
+    const lines = content.split("\n");
+    const start = lines.findIndex((line) => line.startsWith(`## ${version} -`) || line.startsWith(`## [${version}](`));
+    if (start < 0) {
+        return `Automated release for v${version}`;
+    }
+    let end = lines.length;
+    for (let idx = start + 1; idx < lines.length; idx += 1) {
+        if (lines[idx]?.startsWith("## ")) {
+            end = idx;
+            break;
+        }
+    }
+    const notes = lines
+        .slice(start + 1, end)
+        .join("\n")
+        .trim();
+    return notes.length > 0 ? notes : `Automated release for v${version}`;
+}
+async function runSimpleRelease(cwd = process.cwd()) {
+    const result = await runSimpleReleaseDetailed(cwd, { logger: console });
+    if (result.action === "release-skipped") {
+        return result.reason;
+    }
+    return result.message;
+}
+async function runSimpleReleaseDetailed(cwd = process.cwd(), options = {}) {
+    const subject = getHeadCommitSubject(cwd);
+    if (!(0, pr_js_1.isReleaseCommitMessage)(subject)) {
+        return {
+            action: "release-skipped",
+            reason: "No release commit context detected; skipping release stage.",
+        };
+    }
+    const loaded = (0, load_config_js_1.loadConfig)(cwd);
+    const strategy = (0, resolve_js_1.resolveVersionStrategy)(loaded.config);
+    const changelogFile = loaded.config["changelog-file"] ?? "CHANGELOG.md";
+    const version = strategy.readVersion(cwd, loaded.config);
+    const defaultTag = `v${version}`;
+    const plugins = (0, runtime_js_1.loadRuntimePlugins)();
+    const scmPlugins = (0, capabilities_js_1.findPluginsByCapability)(plugins, "scm.releaseMetadata");
+    if (scmPlugins.length === 0) {
+        throw new Error("No scm.releaseMetadata plugin is available.");
+    }
+    const plugin = scmPlugins[0];
+    if (!plugin?.createReleaseMetadata) {
+        throw new Error(`Plugin "${plugin?.name ?? "unknown"}" does not implement createReleaseMetadata.`);
+    }
+    const releaseTargets = (0, state_js_1.readReleaseTargets)(cwd);
+    const targets = releaseTargets.length > 0
+        ? releaseTargets
+        : [
+            {
+                path: ".",
+                version,
+                tag: defaultTag,
+            },
+        ];
+    const releases = [];
+    for (const target of targets) {
+        const outcome = await (0, recovery_js_1.executeIdempotentReleaseTarget)(cwd, {
+            tag: target.tag,
+            version: target.version,
+            notes: readReleaseNotes(cwd, target.version, changelogFile),
+        }, {
+            createReleaseMetadata: (input) => plugin.createReleaseMetadata(input, { cwd, logger: options.logger }),
+            logger: options.logger,
+        });
+        releases.push({
+            tag: outcome.tag,
+            url: outcome.url,
+            tagStatus: outcome.tagStatus,
+            metadataStatus: outcome.metadataStatus,
+        });
+    }
+    const published = releases.map((outcome) => `${outcome.tag}: ${outcome.url} (tag=${outcome.tagStatus}, metadata=${outcome.metadataStatus})`);
+    return {
+        action: "release-published",
+        releases,
+        message: `Published releases ${published.join(", ")}`,
+    };
+}

package/dist/app/release/state.d.ts

@@ -0,0 +1,9 @@
+export interface ReleaseTargetState {
+    path: string;
+    version: string;
+    tag: string;
+}
+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 writeBaselineSha(cwd?: string, sha?: string, releaseTargets?: ReleaseTargetState[]): void;

package/dist/app/release/state.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBaselineStatePath = getBaselineStatePath;
+exports.readBaselineSha = readBaselineSha;
+exports.readReleaseTargets = readReleaseTargets;
+exports.writeBaselineSha = writeBaselineSha;
+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");
+function parseStateFile(raw, filePath) {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`Invalid release manifest at ${filePath}: expected an object.`);
+    }
+    const manifest = parsed;
+    if (manifest.manifestVersion !== undefined &&
+        manifest.manifestVersion !== 1) {
+        throw new Error(`Unsupported manifestVersion in ${filePath}: ${String(manifest.manifestVersion)}.`);
+    }
+    if (manifest.baselineSha !== undefined &&
+        typeof manifest.baselineSha !== "string") {
+        throw new Error(`Invalid release manifest at ${filePath}: baselineSha must be a string.`);
+    }
+    if (manifest.releaseTargets !== undefined &&
+        !Array.isArray(manifest.releaseTargets)) {
+        throw new Error(`Invalid release manifest at ${filePath}: releaseTargets must be an array.`);
+    }
+    if (Array.isArray(manifest.releaseTargets)) {
+        for (const target of manifest.releaseTargets) {
+            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}: releaseTargets must contain string path, version, and tag.`);
+            }
+        }
+    }
+    return manifest;
+}
+function getBaselineStatePath(cwd) {
+    const loaded = (0, load_config_js_1.loadConfig)(cwd);
+    const configured = loaded.config["baseline-file"];
+    if (configured) {
+        return node_path_1.default.join(cwd, configured);
+    }
+    const preferred = node_path_1.default.join(cwd, ".versionary-manifest.json");
+    if (node_fs_1.default.existsSync(preferred)) {
+        return preferred;
+    }
+    const legacy = node_path_1.default.join(cwd, "versionary.versions.json");
+    if (node_fs_1.default.existsSync(legacy)) {
+        return legacy;
+    }
+    return preferred;
+}
+function readBaselineSha(cwd = process.cwd()) {
+    const filePath = getBaselineStatePath(cwd);
+    if (!node_fs_1.default.existsSync(filePath)) {
+        return null;
+    }
+    const parsed = parseStateFile(node_fs_1.default.readFileSync(filePath, "utf8"), filePath);
+    return parsed.baselineSha ?? null;
+}
+function readReleaseTargets(cwd = process.cwd()) {
+    const filePath = getBaselineStatePath(cwd);
+    if (!node_fs_1.default.existsSync(filePath)) {
+        return [];
+    }
+    const parsed = parseStateFile(node_fs_1.default.readFileSync(filePath, "utf8"), filePath);
+    return parsed.releaseTargets ?? [];
+}
+function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets = []) {
+    const baselineSha = sha ??
+        (0, node_child_process_1.execFileSync)("git", ["rev-parse", "HEAD"], {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    const filePath = getBaselineStatePath(cwd);
+    const next = {
+        manifestVersion: 1,
+        baselineSha,
+        releaseTargets,
+    };
+    node_fs_1.default.writeFileSync(filePath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+}

package/dist/app/release/verify.d.ts

@@ -0,0 +1,2 @@
+export type { VerifyResult } from "../../verify/verify-project.js";
+export { verifyProject } from "../../verify/verify-project.js";

package/dist/app/release/verify.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyProject = void 0;
+var verify_project_js_1 = require("../../verify/verify-project.js");
+Object.defineProperty(exports, "verifyProject", { enumerable: true, get: function () { return verify_project_js_1.verifyProject; } });