versionary 0.2.0 → 0.3.0

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

@@ -4,13 +4,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runSimpleRelease = runSimpleRelease;
+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 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 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,
@@ -18,18 +21,6 @@ function getHeadCommitSubject(cwd) {
         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)) {
@@ -48,7 +39,10 @@ function readReleaseNotes(cwd, version, changelogFile) {
             break;
         }
     }
-    const notes = lines.slice(start + 1, end).join("\n").trim();
+    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()) {
@@ -57,11 +51,10 @@ async function runSimpleRelease(cwd = process.cwd()) {
         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 strategy = (0, resolve_js_1.resolveVersionStrategy)(loaded.config);
     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 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) {
@@ -71,7 +64,27 @@ async function runSimpleRelease(cwd = process.cwd()) {
     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}`;
+    const releaseTargets = (0, state_js_1.readReleaseTargets)(cwd);
+    const targets = releaseTargets.length > 0
+        ? releaseTargets
+        : [
+            {
+                path: ".",
+                version,
+                tag: defaultTag,
+                notes: readReleaseNotes(cwd, version, changelogFile),
+            },
+        ];
+    const published = [];
+    for (const target of targets) {
+        const outcome = await (0, recovery_js_1.executeIdempotentReleaseTarget)(cwd, {
+            tag: target.tag,
+            version: target.version,
+            notes: target.notes ?? readReleaseNotes(cwd, target.version, changelogFile),
+        }, {
+            createReleaseMetadata: (input) => plugin.createReleaseMetadata(input, { cwd, logger: console }),
+        });
+        published.push(`${outcome.tag}: ${outcome.url} (tag=${outcome.tagStatus}, metadata=${outcome.metadataStatus})`);
+    }
+    return `Published releases ${published.join(", ")}`;
 }

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

@@ -0,0 +1,10 @@
+export interface ReleaseTargetState {
+    path: string;
+    version: string;
+    tag: string;
+    notes?: 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/{simple → app/release}/state.js

@@ -5,11 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (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 node_child_process_1 = require("node:child_process");
-const load_config_js_1 = require("../config/load-config.js");
+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"];
@@ -34,7 +35,15 @@ function readBaselineSha(cwd = process.cwd()) {
     const parsed = JSON.parse(node_fs_1.default.readFileSync(filePath, "utf8"));
     return parsed.baselineSha ?? null;
 }
-function writeBaselineSha(cwd = process.cwd(), sha) {
+function readReleaseTargets(cwd = process.cwd()) {
+    const filePath = getBaselineStatePath(cwd);
+    if (!node_fs_1.default.existsSync(filePath)) {
+        return [];
+    }
+    const parsed = JSON.parse(node_fs_1.default.readFileSync(filePath, "utf8"));
+    return parsed.releaseTargets ?? [];
+}
+function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets = []) {
     const baselineSha = sha ??
         (0, node_child_process_1.execFileSync)("git", ["rev-parse", "HEAD"], {
             cwd,
@@ -42,6 +51,9 @@ function writeBaselineSha(cwd = process.cwd(), sha) {
             stdio: ["ignore", "pipe", "ignore"],
         }).trim();
     const filePath = getBaselineStatePath(cwd);
-    const next = { baselineSha };
+    const next = {
+        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; } });

package/dist/cli/index.js

@@ -4,16 +4,16 @@ 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}`);
@@ -39,7 +39,7 @@ async function main() {
         }
         const pr = (0, pr_js_1.prepareSimpleReleasePr)();
         (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);
@@ -66,7 +66,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");
@@ -76,7 +78,7 @@ async function main() {
     if (command === "pr") {
         const pr = (0, pr_js_1.prepareSimpleReleasePr)();
         (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);

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

@@ -24,6 +24,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("This PR was generated by 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;