versionary 0.2.0 → 0.4.0

package/dist/cli/index.js

@@ -4,43 +4,97 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+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 node_child_process_1 = require("node:child_process");
-const plan_js_1 = require("../simple/plan.js");
-const changelog_js_1 = require("../simple/changelog.js");
-const pr_js_1 = require("../simple/pr.js");
-const release_js_1 = require("../simple/release.js");
-const verify_project_js_1 = require("../verify/verify-project.js");
+const pr_js_1 = require("../app/release/pr.js");
+const release_js_1 = require("../app/release/release.js");
+const verify_js_1 = require("../app/release/verify.js");
+const changelog_js_1 = require("../domain/release/changelog.js");
+const plan_js_1 = require("../domain/release/plan.js");
 function printVerifyResult() {
-    const result = (0, verify_project_js_1.verifyProject)();
+    const result = (0, verify_js_1.verifyProject)();
     for (const check of result.checks) {
         const status = check.ok ? "OK" : "FAIL";
         console.log(`[${status}] ${check.name} - ${check.details}`);
     }
     return result.ok ? 0 : 1;
 }
+function parseFlags(args) {
+    return {
+        json: args.includes("--json"),
+    };
+}
+function emitJson(payload) {
+    process.stdout.write(`${JSON.stringify(payload)}\n`);
+}
 async function main() {
     const [, , command, ...args] = process.argv;
+    const flags = parseFlags(args);
+    const logger = flags.json ? undefined : console;
     if (!command || command === "run") {
         const subject = (0, node_child_process_1.execFileSync)("git", ["log", "-1", "--pretty=%s"], {
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"],
         }).trim();
         if ((0, pr_js_1.isReleaseCommitMessage)(subject)) {
+            if (flags.json) {
+                const release = await (0, release_js_1.runSimpleReleaseDetailed)(process.cwd(), {
+                    logger,
+                });
+                if (release.action === "release-skipped") {
+                    emitJson({
+                        action: "release-skipped",
+                        message: release.reason,
+                        releaseCreated: false,
+                        tagNames: [],
+                    });
+                    return 0;
+                }
+                emitJson({
+                    action: "release-published",
+                    message: release.message,
+                    releaseCreated: release.releases.length > 0,
+                    tagNames: release.releases.map((target) => target.tag),
+                });
+                return 0;
+            }
             const message = await (0, release_js_1.runSimpleRelease)(process.cwd());
             console.log(message);
             return 0;
         }
         const plan = (0, plan_js_1.createSimplePlan)();
         if (!plan.nextVersion) {
-            console.log("No releasable commits found. Nothing to do.");
+            const message = "No releasable commits found. Nothing to do.";
+            if (flags.json) {
+                emitJson({
+                    action: "noop",
+                    message,
+                    releaseCreated: false,
+                    tagNames: [],
+                });
+                return 0;
+            }
+            console.log(message);
             return 0;
         }
-        const pr = (0, pr_js_1.prepareSimpleReleasePr)();
+        const pr = (0, pr_js_1.prepareSimpleReleasePr)(process.cwd(), { logger });
         (0, pr_js_1.pushReleaseBranch)(process.cwd(), pr.branch);
-        const reviewResult = await (0, pr_js_1.openOrUpdateSimpleReviewRequest)(process.cwd(), pr.branch, pr.title, pr.version, pr.commits);
-        console.log(`Prepared release PR branch ${pr.branch}`);
+        const reviewResult = await (0, pr_js_1.openOrUpdateSimpleReviewRequest)(process.cwd(), pr.branch, pr.title, pr.version, pr.previousVersion, pr.commits, pr.plan, { logger });
+        const message = `Prepared release PR branch ${pr.branch}`;
+        if (flags.json) {
+            emitJson({
+                action: "pr-prepared",
+                message,
+                releaseCreated: false,
+                tagNames: [],
+                reviewUrl: reviewResult,
+                branch: pr.branch,
+                title: pr.title,
+            });
+            return 0;
+        }
+        console.log(message);
         console.log(`Title: ${pr.title}`);
         console.log(reviewResult);
         return 0;
@@ -66,7 +120,9 @@ async function main() {
             return 0;
         }
         const changelogPath = node_path_1.default.join(process.cwd(), plan.changelogFile);
-        const existing = node_fs_1.default.existsSync(changelogPath) ? node_fs_1.default.readFileSync(changelogPath, "utf8") : "";
+        const existing = node_fs_1.default.existsSync(changelogPath)
+            ? node_fs_1.default.readFileSync(changelogPath, "utf8")
+            : "";
         const heading = "# Changelog\n\n";
         const body = existing.replace(/^# Changelog\s*/u, "");
         node_fs_1.default.writeFileSync(changelogPath, `${heading}${section}\n${body}`.trimEnd() + "\n", "utf8");
@@ -74,9 +130,9 @@ async function main() {
         return 0;
     }
     if (command === "pr") {
-        const pr = (0, pr_js_1.prepareSimpleReleasePr)();
+        const pr = (0, pr_js_1.prepareSimpleReleasePr)(process.cwd(), { logger: console });
         (0, pr_js_1.pushReleaseBranch)(process.cwd(), pr.branch);
-        const reviewResult = await (0, pr_js_1.openOrUpdateSimpleReviewRequest)(process.cwd(), pr.branch, pr.title, pr.version, pr.commits);
+        const reviewResult = await (0, pr_js_1.openOrUpdateSimpleReviewRequest)(process.cwd(), pr.branch, pr.title, pr.version, pr.previousVersion, pr.commits, pr.plan);
         console.log(`Prepared release PR branch ${pr.branch}`);
         console.log(`Title: ${pr.title}`);
         console.log(reviewResult);
@@ -89,7 +145,7 @@ async function main() {
     }
     console.log("Usage: versionary <command>");
     console.log("Commands:");
-    console.log("  run     Auto-dispatch release PR/update or release publish by context");
+    console.log("  run [--json]  Auto-dispatch release PR/update or release publish by context");
     console.log("  verify  Validate config and basic repository shape");
     console.log("  plan    Print release plan (simple mode)");
     console.log("  changelog [--write]  Print or write changelog section");

package/dist/config/load-config.js

@@ -7,27 +7,17 @@ exports.findConfigFile = findConfigFile;
 exports.loadConfig = loadConfig;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const toml_1 = require("@iarna/toml");
 const jsonc_parser_1 = require("jsonc-parser");
 const schema_js_1 = require("./schema.js");
 const SUPPORTED_FILES = [
     { file: "versionary.jsonc", format: "jsonc" },
     { file: "versionary.json", format: "json" },
-    { file: "versionary.toml", format: "toml" },
-    { file: "versionary.js", format: "js" },
-    { file: "versionary.config.jsonc", format: "jsonc" },
-    { file: "versionary.config.json", format: "json" },
-    { file: "versionary.config.toml", format: "toml" },
-    { file: "versionary.config.js", format: "js" },
 ];
 function parseConfig(raw, format) {
     if (format === "json" || format === "jsonc") {
         return (0, jsonc_parser_1.parse)(raw);
     }
-    if (format === "toml") {
-        return (0, toml_1.parse)(raw);
-    }
-    throw new Error("JavaScript config loading is not implemented yet. Use JSONC/JSON/TOML for now.");
+    throw new Error("Unsupported config format. Use versionary.jsonc or versionary.json.");
 }
 function isRecord(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -44,7 +34,7 @@ function findConfigFile(cwd) {
 function loadConfig(cwd = process.cwd()) {
     const found = findConfigFile(cwd);
     if (!found) {
-        throw new Error("No Versionary config found. Create versionary.jsonc (preferred), .json, or .toml.");
+        throw new Error("No Versionary config found. Create versionary.jsonc (preferred) or versionary.json.");
     }
     const raw = node_fs_1.default.readFileSync(found.path, "utf8");
     const parsed = parseConfig(raw, found.format);

package/dist/config/schema.d.ts

@@ -15,6 +15,7 @@ export declare const configSchema: z.ZodObject<{
         fixed: "fixed";
     }>>;
     "bump-minor-pre-major": z.ZodOptional<z.ZodBoolean>;
+    "allow-stable-major": z.ZodOptional<z.ZodBoolean>;
     "include-commit-authors": z.ZodOptional<z.ZodBoolean>;
     "release-type": z.ZodOptional<z.ZodString>;
     packages: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{

package/dist/config/schema.js

@@ -2,11 +2,43 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configSchema = void 0;
 const zod_1 = require("zod");
-const artifactRuleSchema = zod_1.z.object({
+const artifactRuleSchema = zod_1.z
+    .object({
     type: zod_1.z.enum(["json", "toml", "yaml", "regex"]),
     path: zod_1.z.string().min(1),
     jsonpath: zod_1.z.string().optional(),
     pattern: zod_1.z.string().optional(),
+})
+    .superRefine((value, ctx) => {
+    const needsJsonPath = value.type === "json" || value.type === "toml" || value.type === "yaml";
+    if (needsJsonPath && !value.jsonpath) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `${value.type} artifact rules require "jsonpath".`,
+            path: ["jsonpath"],
+        });
+    }
+    if (needsJsonPath && value.pattern) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `${value.type} artifact rules do not support "pattern".`,
+            path: ["pattern"],
+        });
+    }
+    if (value.type === "regex" && !value.pattern) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: 'regex artifact rules require "pattern".',
+            path: ["pattern"],
+        });
+    }
+    if (value.type === "regex" && value.jsonpath) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: 'regex artifact rules do not support "jsonpath".',
+            path: ["jsonpath"],
+        });
+    }
 });
 const packageSchema = zod_1.z.object({
     "release-type": zod_1.z.string().optional(),
@@ -24,6 +56,7 @@ exports.configSchema = zod_1.z.object({
     "bootstrap-sha": zod_1.z.string().optional(),
     "monorepo-mode": zod_1.z.enum(["independent", "fixed"]).optional(),
     "bump-minor-pre-major": zod_1.z.boolean().optional(),
+    "allow-stable-major": zod_1.z.boolean().optional(),
     "include-commit-authors": zod_1.z.boolean().optional(),
     "release-type": zod_1.z.string().optional(),
     packages: zod_1.z.record(zod_1.z.string().min(1), packageSchema).optional(),

package/dist/domain/release/changelog.d.ts

@@ -0,0 +1,12 @@
+import { type ParsedCommit } from "../../infra/git/commits.js";
+import type { SimplePlan } from "./plan.js";
+export declare function renderSimpleReleaseNotes(input: {
+    currentVersion: string;
+    nextVersion: string;
+    commits: ParsedCommit[];
+    cwd?: string;
+}, options?: {
+    includeFooter?: boolean;
+}): string;
+export declare function renderSimpleChangelog(plan: SimplePlan): string;
+export declare function prependChangelog(cwd: string, changelogFile: string, section: string): void;

package/dist/domain/release/changelog.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderSimpleReleaseNotes = renderSimpleReleaseNotes;
+exports.renderSimpleChangelog = renderSimpleChangelog;
+exports.prependChangelog = prependChangelog;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const commits_js_1 = require("../../infra/git/commits.js");
+const repo_url_js_1 = require("../../infra/git/repo-url.js");
+function formatDate() {
+    return new Date().toISOString().slice(0, 10);
+}
+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 formatCommitReferences(commit, repoBaseUrl) {
+    const references = commit.references ?? [];
+    if (references.length === 0) {
+        return "";
+    }
+    return references
+        .map((reference) => {
+        const issue = reference.issue;
+        if (!issue) {
+            return "";
+        }
+        const action = (reference.action?.trim() || "refs").toLowerCase();
+        if (!repoBaseUrl) {
+            return `${action} #${issue}`;
+        }
+        return `${action} [#${issue}](${repoBaseUrl}/issues/${issue})`;
+    })
+        .filter((entry) => entry.length > 0)
+        .join(", ");
+}
+function groupCommitLines(commits, repoUrl) {
+    const breaking = [];
+    const features = [];
+    const fixes = [];
+    for (const commit of commits) {
+        const type = (0, commits_js_1.inferReleaseTypeFromParsedCommit)(commit);
+        if (!type) {
+            continue;
+        }
+        const { label, message } = formatCommitMessage(commit.subject);
+        const short = commit.hash.slice(0, 7);
+        const hashLabel = repoUrl
+            ? `[\`${short}\`](${repoUrl}/commit/${commit.hash})`
+            : `\`${short}\``;
+        const references = formatCommitReferences(commit, repoUrl);
+        const referencesSuffix = references ? `, ${references}` : "";
+        const line = `- ${label}${message} (${hashLabel})${referencesSuffix}`;
+        const commitType = (commit.type ?? "").toLowerCase();
+        const isBreaking = type === "major";
+        if (isBreaking) {
+            breaking.push(line);
+        }
+        if (commitType === "feat" || (!isBreaking && type === "minor")) {
+            features.push(line);
+            continue;
+        }
+        if (commitType === "fix" ||
+            commitType === "perf" ||
+            (!isBreaking && type === "patch")) {
+            fixes.push(line);
+        }
+    }
+    return { breaking, features, fixes };
+}
+function renderSimpleReleaseNotes(input, options = {}) {
+    const repoUrl = (0, repo_url_js_1.resolveRepositoryWebBaseUrl)(input.cwd ?? process.cwd());
+    const header = repoUrl
+        ? `## [${input.nextVersion}](${repoUrl}/compare/v${input.currentVersion}...v${input.nextVersion}) (${formatDate()})`
+        : `## ${input.nextVersion} (${formatDate()})`;
+    const grouped = groupCommitLines(input.commits, repoUrl);
+    const sections = [];
+    if (grouped.breaking.length > 0) {
+        sections.push("### Breaking changes", ...grouped.breaking, "");
+    }
+    if (grouped.features.length > 0) {
+        sections.push("### Features", ...grouped.features, "");
+    }
+    if (grouped.fixes.length > 0) {
+        sections.push("### Bug Fixes", ...grouped.fixes, "");
+    }
+    const lines = [header, "", ...sections];
+    if (options.includeFooter) {
+        lines.push("\n---\n\nThis PR was generated by [Versionary](https://github.com/jolars/versionary).");
+    }
+    return lines.join("\n");
+}
+function renderSimpleChangelog(plan) {
+    if (!plan.nextVersion) {
+        return "";
+    }
+    return renderSimpleReleaseNotes({
+        currentVersion: plan.currentVersion,
+        nextVersion: plan.nextVersion,
+        commits: plan.commits,
+        cwd: process.cwd(),
+    });
+}
+function prependChangelog(cwd, changelogFile, section) {
+    const changelogPath = node_path_1.default.join(cwd, changelogFile);
+    const existing = node_fs_1.default.existsSync(changelogPath)
+        ? node_fs_1.default.readFileSync(changelogPath, "utf8")
+        : "";
+    const heading = existing.startsWith("# Changelog") ? "" : "# Changelog\n\n";
+    const separator = existing.length > 0 ? "\n" : "";
+    const next = `${heading}${section}${separator}${existing.replace(/^# Changelog\s*/u, "")}`.trimEnd() +
+        "\n";
+    node_fs_1.default.writeFileSync(changelogPath, next, "utf8");
+}

package/dist/{simple → domain/release}/plan.d.ts

@@ -1,4 +1,4 @@
-import { type CommitInfo } from "./git.js";
+import { type ParsedCommit } from "../../infra/git/commits.js";
 import { type ReleaseType } from "./semver.js";
 export interface SimplePlan {
     mode: "simple";
@@ -9,12 +9,13 @@ export interface SimplePlan {
     changelogFile: string;
     releaseBranchPrefix: string;
     baselineSha: string | null;
-    commits: CommitInfo[];
+    commits: ParsedCommit[];
     packages?: Array<{
         path: string;
         releaseType: ReleaseType;
+        currentVersion: string;
         nextVersion: string | null;
-        commits: CommitInfo[];
+        commits: ParsedCommit[];
     }>;
 }
 export declare function createSimplePlan(cwd?: string): SimplePlan;

package/dist/{simple → domain/release}/plan.js

@@ -6,16 +6,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSimplePlan = createSimplePlan;
 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 git_js_1 = require("./git.js");
+const state_js_1 = require("../../app/release/state.js");
+const load_config_js_1 = require("../../config/load-config.js");
+const commits_js_1 = require("../../infra/git/commits.js");
+const resolve_js_1 = require("../strategy/resolve.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 versionFile = loaded.config["version-file"] ?? "version.txt";
+    const strategy = (0, resolve_js_1.resolveVersionStrategy)(loaded.config);
+    const versionFile = strategy.getVersionFile(loaded.config);
     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;
@@ -23,7 +25,8 @@ function createSimplePlan(cwd = process.cwd()) {
     if (!node_fs_1.default.existsSync(versionPath)) {
         throw new Error(`Versionary requires ${versionFile} to exist.`);
     }
-    const currentVersion = node_fs_1.default.readFileSync(versionPath, "utf8").trim();
+    const currentVersion = strategy.readVersion(cwd, loaded.config);
+    const allowStableMajor = loaded.config["allow-stable-major"] ?? false;
     const configuredPackages = Object.entries(loaded.config.packages ?? {}).map(([pkgPath, cfg]) => ({
         path: pkgPath,
         ...cfg,
@@ -31,9 +34,13 @@ function createSimplePlan(cwd = process.cwd()) {
     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;
+        const parsedCommits = (0, commits_js_1.getParsedCommitsSinceLastTag)(cwd, baselineSha);
+        const effectiveCommits = (0, commits_js_1.applyRevertSuppression)(parsedCommits);
+        const commits = effectiveCommits;
+        const releaseType = (0, commits_js_1.analyzeParsedCommits)(parsedCommits);
+        const nextVersion = releaseType
+            ? (0, semver_js_1.bumpVersion)(currentVersion, releaseType, { allowStableMajor })
+            : null;
         return {
             mode: "simple",
             releaseType,
@@ -48,20 +55,28 @@ function createSimplePlan(cwd = process.cwd()) {
     }
     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;
+        const parsedCommits = (0, commits_js_1.getParsedCommitsForPath)(cwd, baselineSha, pkg.path, pkg["exclude-paths"] ?? []);
+        const effectiveCommits = (0, commits_js_1.applyRevertSuppression)(parsedCommits);
+        const commits = effectiveCommits;
+        const releaseType = (0, commits_js_1.analyzeParsedCommits)(parsedCommits);
+        const nextVersion = releaseType
+            ? (0, semver_js_1.bumpVersion)(currentVersion, releaseType, { allowStableMajor })
+            : null;
         return {
             path: pkg.path,
             releaseType,
+            currentVersion,
             nextVersion,
             commits,
+            parsedCommits,
         };
     })
         .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 fixedType = (0, commits_js_1.analyzeParsedCommits)(packagePlans.flatMap((pkgPlan) => pkgPlan.parsedCommits));
+        const fixedNextVersion = fixedType
+            ? (0, semver_js_1.bumpVersion)(currentVersion, fixedType, { allowStableMajor })
+            : null;
         const adjusted = packagePlans.map((pkgPlan) => ({
             ...pkgPlan,
             releaseType: fixedType,
@@ -80,8 +95,10 @@ function createSimplePlan(cwd = process.cwd()) {
             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;
+    const overallType = (0, commits_js_1.analyzeParsedCommits)(packagePlans.flatMap((pkgPlan) => pkgPlan.parsedCommits));
+    const overallNextVersion = overallType
+        ? (0, semver_js_1.bumpVersion)(currentVersion, overallType, { allowStableMajor })
+        : null;
     return {
         mode: "simple",
         releaseType: overallType,

package/dist/domain/release/semver.d.ts

@@ -0,0 +1,15 @@
+export type ReleaseType = "major" | "minor" | "patch" | null;
+export interface ParsedVersion {
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease: string[];
+    build: string[];
+}
+export interface BumpVersionOptions {
+    allowStableMajor?: boolean;
+}
+export declare function parseVersion(version: string): ParsedVersion;
+export declare function isValidVersion(version: string): boolean;
+export declare function compareVersions(leftRaw: string, rightRaw: string): number;
+export declare function bumpVersion(current: string, releaseType: Exclude<ReleaseType, null>, options?: BumpVersionOptions): string;

package/dist/domain/release/semver.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVersion = parseVersion;
+exports.isValidVersion = isValidVersion;
+exports.compareVersions = compareVersions;
+exports.bumpVersion = bumpVersion;
+const SEMVER_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/u;
+function parseVersion(version) {
+    const match = version.trim().match(SEMVER_PATTERN);
+    if (!match) {
+        throw new Error(`Invalid version in version file: "${version}". Expected SemVer 2.0.0 format.`);
+    }
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+        prerelease: match[4] ? match[4].split(".") : [],
+        build: match[5] ? match[5].split(".") : [],
+    };
+}
+function isValidVersion(version) {
+    return SEMVER_PATTERN.test(version.trim());
+}
+function isNumericIdentifier(identifier) {
+    return /^(0|[1-9]\d*)$/u.test(identifier);
+}
+function comparePreReleaseIdentifiers(left, right) {
+    const leftNumeric = isNumericIdentifier(left);
+    const rightNumeric = isNumericIdentifier(right);
+    if (leftNumeric && rightNumeric) {
+        const leftNumber = Number(left);
+        const rightNumber = Number(right);
+        if (leftNumber < rightNumber) {
+            return -1;
+        }
+        if (leftNumber > rightNumber) {
+            return 1;
+        }
+        return 0;
+    }
+    if (leftNumeric && !rightNumeric) {
+        return -1;
+    }
+    if (!leftNumeric && rightNumeric) {
+        return 1;
+    }
+    if (left < right) {
+        return -1;
+    }
+    if (left > right) {
+        return 1;
+    }
+    return 0;
+}
+function compareVersions(leftRaw, rightRaw) {
+    const left = parseVersion(leftRaw);
+    const right = parseVersion(rightRaw);
+    if (left.major !== right.major) {
+        return left.major < right.major ? -1 : 1;
+    }
+    if (left.minor !== right.minor) {
+        return left.minor < right.minor ? -1 : 1;
+    }
+    if (left.patch !== right.patch) {
+        return left.patch < right.patch ? -1 : 1;
+    }
+    const leftPre = left.prerelease;
+    const rightPre = right.prerelease;
+    if (leftPre.length === 0 && rightPre.length === 0) {
+        return 0;
+    }
+    if (leftPre.length === 0) {
+        return 1;
+    }
+    if (rightPre.length === 0) {
+        return -1;
+    }
+    const maxLength = Math.max(leftPre.length, rightPre.length);
+    for (let index = 0; index < maxLength; index += 1) {
+        const leftIdentifier = leftPre[index];
+        const rightIdentifier = rightPre[index];
+        if (leftIdentifier === undefined) {
+            return -1;
+        }
+        if (rightIdentifier === undefined) {
+            return 1;
+        }
+        const comparison = comparePreReleaseIdentifiers(leftIdentifier, rightIdentifier);
+        if (comparison !== 0) {
+            return comparison;
+        }
+    }
+    return 0;
+}
+function bumpVersion(current, releaseType, options = {}) {
+    const parsed = parseVersion(current);
+    const allowStableMajor = options.allowStableMajor ?? false;
+    if (releaseType === "major") {
+        if (parsed.major === 0 && !allowStableMajor) {
+            return `0.${parsed.minor + 1}.0`;
+        }
+        if (parsed.major === 0 && allowStableMajor) {
+            return "1.0.0";
+        }
+        return `${parsed.major + 1}.0.0`;
+    }
+    if (releaseType === "minor") {
+        return `${parsed.major}.${parsed.minor + 1}.0`;
+    }
+    return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}`;
+}

package/dist/domain/strategy/node.d.ts

@@ -0,0 +1,2 @@
+import type { VersionStrategy } from "./types.js";
+export declare const nodeVersionStrategy: VersionStrategy;