versionary 0.1.0 → 0.2.0

package/dist/simple/git.js

@@ -1,17 +1,47 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCommitsSinceLastTag = getCommitsSinceLastTag;
+exports.getCommitsForPath = getCommitsForPath;
+exports.inferReleaseTypeFromSubject = inferReleaseTypeFromSubject;
+exports.isReleasableCommit = isReleasableCommit;
 exports.analyzeCommits = analyzeCommits;
+const node_path_1 = __importDefault(require("node:path"));
 const node_child_process_1 = require("node:child_process");
-function getCommitsSinceLastTag(cwd = process.cwd()) {
-    const tagsOutput = (0, node_child_process_1.execFileSync)("git", ["tag", "--sort=-v:refname"], {
+function getReleaseBranchExcludeArgs(cwd) {
+    const releaseBranchesRaw = (0, node_child_process_1.execFileSync)("git", ["branch", "--list", "--format", "%(refname:short)"], {
         cwd,
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"],
     });
-    const baseRef = tagsOutput.trim().split("\n")[0] ?? "";
-    const range = baseRef ? `${baseRef}..HEAD` : "HEAD";
-    const output = (0, node_child_process_1.execFileSync)("git", ["log", range, "--pretty=format:%H%x09%s"], {
+    const releaseBranches = releaseBranchesRaw
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith("versionary/release"));
+    return releaseBranches.flatMap((branch) => ["--exclude", branch]);
+}
+function resolveBaseRef(cwd, baselineSha) {
+    const excludeArgs = getReleaseBranchExcludeArgs(cwd);
+    let baseRef = baselineSha ?? "";
+    if (!baseRef) {
+        try {
+            const cmd = ["describe", "--tags", "--abbrev=0", "--match", "v[0-9]*", ...excludeArgs];
+            baseRef = (0, node_child_process_1.execFileSync)("git", cmd, {
+                cwd,
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "ignore"],
+            }).trim();
+        }
+        catch {
+            baseRef = "";
+        }
+    }
+    return baseRef;
+}
+function readGitLog(cwd, range, pathspecs = []) {
+    const output = (0, node_child_process_1.execFileSync)("git", ["log", range, "--pretty=format:%H%x09%s", "--", ...pathspecs], {
         cwd,
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"],
@@ -27,21 +57,44 @@ function getCommitsSinceLastTag(cwd = process.cwd()) {
         return { hash, subject };
     });
 }
+function getCommitsSinceLastTag(cwd = process.cwd(), baselineSha) {
+    const baseRef = resolveBaseRef(cwd, baselineSha);
+    const range = baseRef ? `${baseRef}..HEAD` : "HEAD";
+    return readGitLog(cwd, range);
+}
+function getCommitsForPath(cwd = process.cwd(), baselineSha, packagePath = ".", excludePaths = []) {
+    const baseRef = resolveBaseRef(cwd, baselineSha);
+    const range = baseRef ? `${baseRef}..HEAD` : "HEAD";
+    const normalizedPackagePath = packagePath === "." ? "." : packagePath;
+    const excludes = excludePaths.map((excludePath) => {
+        const combined = normalizedPackagePath === "."
+            ? excludePath
+            : node_path_1.default.posix.join(normalizedPackagePath, excludePath);
+        return `:(exclude)${combined}`;
+    });
+    return readGitLog(cwd, range, [normalizedPackagePath, ...excludes]);
+}
 function inferReleaseTypeFromSubject(subject) {
     if (/^revert:\s/i.test(subject)) {
         return null;
     }
+    if (/^chore(\(.+\))?:\s/i.test(subject)) {
+        return null;
+    }
     if (/!:/u.test(subject) || /BREAKING CHANGE/u.test(subject)) {
         return "major";
     }
     if (/^feat(\(.+\))?:\s/i.test(subject)) {
         return "minor";
     }
-    if (/^(fix|perf|refactor)(\(.+\))?:\s/i.test(subject)) {
+    if (/^(fix|perf)(\(.+\))?:\s/i.test(subject)) {
         return "patch";
     }
     return null;
 }
+function isReleasableCommit(subject) {
+    return inferReleaseTypeFromSubject(subject) !== null;
+}
 function analyzeCommits(commits) {
     let result = null;
     for (const commit of commits) {

package/dist/simple/plan.d.ts

@@ -7,6 +7,14 @@ export interface SimplePlan {
     nextVersion: string | null;
     versionFile: string;
     changelogFile: string;
+    releaseBranchPrefix: string;
+    baselineSha: string | null;
     commits: CommitInfo[];
+    packages?: Array<{
+        path: string;
+        releaseType: ReleaseType;
+        nextVersion: string | null;
+        commits: CommitInfo[];
+    }>;
 }
 export declare function createSimplePlan(cwd?: string): SimplePlan;

package/dist/simple/plan.js

@@ -9,29 +9,89 @@ const node_path_1 = __importDefault(require("node:path"));
 const load_config_js_1 = require("../config/load-config.js");
 const git_js_1 = require("./git.js");
 const semver_js_1 = require("./semver.js");
+const state_js_1 = require("./state.js");
+function getMode(configMode) {
+    return configMode ?? "independent";
+}
 function createSimplePlan(cwd = process.cwd()) {
     const loaded = (0, load_config_js_1.loadConfig)(cwd);
-    const mode = loaded.config.mode ?? "simple";
-    if (mode !== "simple") {
-        throw new Error("Simple plan requires mode: simple in config.");
-    }
-    const versionFile = loaded.config.simple?.versionFile ?? "version.txt";
-    const changelogFile = loaded.config.simple?.changelogFile ?? "CHANGELOG.md";
+    const versionFile = loaded.config["version-file"] ?? "version.txt";
+    const changelogFile = loaded.config["changelog-file"] ?? "CHANGELOG.md";
+    const releaseBranchPrefix = loaded.config["release-branch"] ?? "versionary/release";
+    const baselineSha = (0, state_js_1.readBaselineSha)(cwd) ?? loaded.config["bootstrap-sha"] ?? null;
     const versionPath = node_path_1.default.join(cwd, versionFile);
     if (!node_fs_1.default.existsSync(versionPath)) {
-        throw new Error(`Simple mode requires ${versionFile} to exist.`);
+        throw new Error(`Versionary requires ${versionFile} to exist.`);
     }
     const currentVersion = node_fs_1.default.readFileSync(versionPath, "utf8").trim();
-    const commits = (0, git_js_1.getCommitsSinceLastTag)(cwd);
-    const releaseType = (0, git_js_1.analyzeCommits)(commits);
-    const nextVersion = releaseType ? (0, semver_js_1.bumpVersion)(currentVersion, releaseType) : null;
+    const configuredPackages = Object.entries(loaded.config.packages ?? {}).map(([pkgPath, cfg]) => ({
+        path: pkgPath,
+        ...cfg,
+    }));
+    const monorepoMode = getMode(loaded.config["monorepo-mode"]);
+    const hasPackages = configuredPackages.length > 0;
+    if (!hasPackages) {
+        const commits = (0, git_js_1.getCommitsSinceLastTag)(cwd, baselineSha);
+        const releaseType = (0, git_js_1.analyzeCommits)(commits);
+        const nextVersion = releaseType ? (0, semver_js_1.bumpVersion)(currentVersion, releaseType) : null;
+        return {
+            mode: "simple",
+            releaseType,
+            currentVersion,
+            nextVersion,
+            versionFile,
+            changelogFile,
+            releaseBranchPrefix,
+            baselineSha,
+            commits,
+        };
+    }
+    const packagePlans = configuredPackages
+        .map((pkg) => {
+        const commits = (0, git_js_1.getCommitsForPath)(cwd, baselineSha, pkg.path, pkg["exclude-paths"] ?? []);
+        const releaseType = (0, git_js_1.analyzeCommits)(commits);
+        const nextVersion = releaseType ? (0, semver_js_1.bumpVersion)(currentVersion, releaseType) : null;
+        return {
+            path: pkg.path,
+            releaseType,
+            nextVersion,
+            commits,
+        };
+    })
+        .sort((a, b) => a.path.localeCompare(b.path));
+    if (monorepoMode === "fixed") {
+        const fixedType = (0, git_js_1.analyzeCommits)(packagePlans.flatMap((pkgPlan) => pkgPlan.commits));
+        const fixedNextVersion = fixedType ? (0, semver_js_1.bumpVersion)(currentVersion, fixedType) : null;
+        const adjusted = packagePlans.map((pkgPlan) => ({
+            ...pkgPlan,
+            releaseType: fixedType,
+            nextVersion: fixedNextVersion,
+        }));
+        return {
+            mode: "simple",
+            releaseType: fixedType,
+            currentVersion,
+            nextVersion: fixedNextVersion,
+            versionFile,
+            changelogFile,
+            releaseBranchPrefix,
+            baselineSha,
+            commits: adjusted.flatMap((pkgPlan) => pkgPlan.commits),
+            packages: adjusted,
+        };
+    }
+    const overallType = (0, git_js_1.analyzeCommits)(packagePlans.flatMap((pkgPlan) => pkgPlan.commits));
+    const overallNextVersion = overallType ? (0, semver_js_1.bumpVersion)(currentVersion, overallType) : null;
     return {
         mode: "simple",
-        releaseType,
+        releaseType: overallType,
         currentVersion,
-        nextVersion,
+        nextVersion: overallNextVersion,
         versionFile,
         changelogFile,
-        commits,
+        releaseBranchPrefix,
+        baselineSha,
+        commits: packagePlans.flatMap((pkgPlan) => pkgPlan.commits),
+        packages: packagePlans,
     };
 }

package/dist/simple/pr.d.ts

@@ -1,5 +1,15 @@
+import type { CommitInfo } from "./git.js";
+export declare function splitSafeDirtyFiles(files: string[]): {
+    ignored: string[];
+    blocking: string[];
+};
 export declare function prepareSimpleReleasePr(cwd?: string): {
     branch: string;
     title: string;
     version: string;
+    commits: CommitInfo[];
 };
+export declare function renderSimpleReviewRequestBody(version: string, commits: CommitInfo[], cwd?: string): string;
+export declare function openOrUpdateSimpleReviewRequest(cwd: string, branch: string, title: string, version: string, commits: CommitInfo[]): Promise<string>;
+export declare function pushReleaseBranch(cwd: string, branch: string): void;
+export declare function isReleaseCommitMessage(subject: string): boolean;

package/dist/simple/pr.js

@@ -3,20 +3,68 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitSafeDirtyFiles = splitSafeDirtyFiles;
 exports.prepareSimpleReleasePr = prepareSimpleReleasePr;
+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");
-function ensureCleanWorktree(cwd) {
-    const status = (0, node_child_process_1.execFileSync)("git", ["status", "--porcelain"], {
+const state_js_1 = require("./state.js");
+const SAFE_DIRTY_FILES = new Set([
+    "pnpm-lock.yaml",
+    "package-lock.json",
+    "yarn.lock",
+    "bun.lockb",
+    "npm-shrinkwrap.json",
+]);
+function listTrackedDirtyFiles(cwd) {
+    const status = (0, node_child_process_1.execFileSync)("git", ["status", "--porcelain", "--untracked-files=no"], {
         cwd,
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
-    if (status.length > 0) {
-        throw new Error("Working tree is not clean. Commit or stash changes before `versionary pr`.");
+    });
+    return status
+        .split("\n")
+        .filter((line) => line.length > 0)
+        .map((line) => line.slice(3))
+        .map((pathPart) => {
+        const renameParts = pathPart.split(" -> ");
+        return renameParts.at(-1) ?? pathPart;
+    })
+        .map((filePath) => filePath.trim())
+        .filter((filePath) => filePath.length > 0);
+}
+function splitSafeDirtyFiles(files) {
+    const ignored = [];
+    const blocking = [];
+    for (const file of files) {
+        const basename = node_path_1.default.basename(file);
+        if (SAFE_DIRTY_FILES.has(basename)) {
+            ignored.push(file);
+            continue;
+        }
+        blocking.push(file);
+    }
+    return { ignored, blocking };
+}
+function ensureCleanWorktree(cwd) {
+    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")}`);
     }
 }
 function prepareSimpleReleasePr(cwd = process.cwd()) {
@@ -29,7 +77,7 @@ function prepareSimpleReleasePr(cwd = process.cwd()) {
     node_fs_1.default.writeFileSync(versionPath, `${plan.nextVersion}\n`, "utf8");
     const section = (0, changelog_js_1.renderSimpleChangelog)(plan);
     (0, changelog_js_1.prependChangelog)(cwd, plan.changelogFile, section);
-    const branch = `versionary/release-v${plan.nextVersion}`;
+    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], {
@@ -37,9 +85,110 @@ function prepareSimpleReleasePr(cwd = process.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", ["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"] });
     return {
         branch,
         title,
         version: plan.nextVersion,
+        commits: plan.commits,
     };
 }
+function formatCommitMessage(subject) {
+    const conventional = subject.match(/^[a-z]+(?:\(([^)]+)\))?!?:\s+(.+)$/iu);
+    if (!conventional) {
+        return { label: "", message: subject };
+    }
+    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");
+}
+async function openOrUpdateSimpleReviewRequest(cwd, branch, title, version, commits) {
+    const loaded = (0, load_config_js_1.loadConfig)(cwd);
+    const releaseFlow = loaded.config["review-mode"] ?? "direct";
+    if (releaseFlow !== "review") {
+        return "Release flow mode is direct; skipping review request creation.";
+    }
+    const plugins = (0, runtime_js_1.loadRuntimePlugins)();
+    const scmPlugins = (0, capabilities_js_1.findPluginsByCapability)(plugins, "scm.reviewRequest");
+    if (scmPlugins.length === 0) {
+        throw new Error("review-mode is review but no scm.reviewRequest plugin is available.");
+    }
+    const plugin = scmPlugins[0];
+    if (!plugin?.createOrUpdateReviewRequest) {
+        throw new Error(`Plugin "${plugin?.name ?? "unknown"}" does not implement createOrUpdateReviewRequest.`);
+    }
+    const result = await plugin.createOrUpdateReviewRequest({
+        baseBranch: process.env.VERSIONARY_BASE_BRANCH ?? "main",
+        headBranch: branch,
+        title,
+        body: renderSimpleReviewRequestBody(version, commits, cwd),
+        labels: ["release"],
+    }, {
+        cwd,
+        logger: console,
+    });
+    return result.url;
+}
+function pushReleaseBranch(cwd, branch) {
+    (0, node_child_process_1.execFileSync)("git", ["push", "--force-with-lease", "origin", branch], {
+        cwd,
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+}
+function isReleaseCommitMessage(subject) {
+    return /^chore\(release\):\sv\d+\.\d+\.\d+/u.test(subject);
+}

package/dist/simple/release.d.ts

@@ -0,0 +1 @@
+export declare function runSimpleRelease(cwd?: string): Promise<string>;

package/dist/simple/release.js

@@ -0,0 +1,77 @@
+"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;
+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 pr_js_1 = require("./pr.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 createTagIfMissing(cwd, tag) {
+    const tagExists = (0, node_child_process_1.execFileSync)("git", ["tag", "--list", tag], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    if (tagExists.length > 0) {
+        return;
+    }
+    (0, node_child_process_1.execFileSync)("git", ["tag", tag], { cwd, stdio: ["ignore", "pipe", "ignore"] });
+    (0, node_child_process_1.execFileSync)("git", ["push", "origin", tag], { cwd, stdio: ["ignore", "pipe", "ignore"] });
+}
+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 subject = getHeadCommitSubject(cwd);
+    if (!(0, pr_js_1.isReleaseCommitMessage)(subject)) {
+        return "No release commit context detected; skipping release stage.";
+    }
+    const loaded = (0, load_config_js_1.loadConfig)(cwd);
+    const versionFile = loaded.config["version-file"] ?? "version.txt";
+    const changelogFile = loaded.config["changelog-file"] ?? "CHANGELOG.md";
+    const version = node_fs_1.default.readFileSync(node_path_1.default.join(cwd, versionFile), "utf8").trim();
+    const tag = `v${version}`;
+    createTagIfMissing(cwd, tag);
+    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 notes = readReleaseNotes(cwd, version, changelogFile);
+    const result = await plugin.createReleaseMetadata({ tag, version, notes }, { cwd, logger: console });
+    return `Published release ${tag}: ${result.url}`;
+}

package/dist/simple/repo-url.d.ts

@@ -0,0 +1 @@
+export declare function resolveRepositoryWebBaseUrl(cwd: string): string | null;

package/dist/simple/repo-url.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRepositoryWebBaseUrl = resolveRepositoryWebBaseUrl;
+const node_child_process_1 = require("node:child_process");
+function resolveRepositoryWebBaseUrl(cwd) {
+    const server = process.env.GITHUB_SERVER_URL;
+    const slug = process.env.GITHUB_REPOSITORY;
+    if (server && slug) {
+        return `${server.replace(/\/+$/u, "")}/${slug}`;
+    }
+    try {
+        const remote = (0, node_child_process_1.execFileSync)("git", ["remote", "get-url", "origin"], {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        const httpsMatch = remote.match(/^(?:https?:\/\/|git@)([^:/]+)[:/]([^/]+\/[^/]+?)(?:\.git)?$/u);
+        if (!httpsMatch) {
+            return null;
+        }
+        const [, host, repoPath] = httpsMatch;
+        return `https://${host}/${repoPath}`;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/simple/state.d.ts

@@ -0,0 +1,3 @@
+export declare function getBaselineStatePath(cwd: string): string;
+export declare function readBaselineSha(cwd?: string): string | null;
+export declare function writeBaselineSha(cwd?: string, sha?: string): void;

package/dist/simple/state.js

@@ -0,0 +1,47 @@
+"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.writeBaselineSha = writeBaselineSha;
+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");
+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 = JSON.parse(node_fs_1.default.readFileSync(filePath, "utf8"));
+    return parsed.baselineSha ?? null;
+}
+function writeBaselineSha(cwd = process.cwd(), sha) {
+    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 = { baselineSha };
+    node_fs_1.default.writeFileSync(filePath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+}