versionary 0.27.0 → 0.28.1

package/dist/action/index.js

@@ -1,8 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_child_process_1 = require("node:child_process");
-const node_crypto_1 = require("node:crypto");
-const node_fs_1 = require("node:fs");
+import { execFileSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { appendFileSync } from "node:fs";
 function getInput(name) {
     const canonical = `INPUT_${name.replace(/ /g, "_").toUpperCase()}`;
     const underscoreAlias = canonical.replace(/-/g, "_");
@@ -12,7 +10,7 @@ function getInput(name) {
         "").trim();
 }
 function runGit(cwd, args) {
-    return (0, node_child_process_1.execFileSync)("git", args, {
+    return execFileSync("git", args, {
         cwd,
         encoding: "utf8",
         stdio: ["ignore", "pipe", "pipe"],
@@ -55,8 +53,8 @@ function setOutput(name, value) {
     if (!outputPath) {
         throw new Error("GITHUB_OUTPUT is not set.");
     }
-    const delimiter = `versionary-${(0, node_crypto_1.randomUUID)()}`;
-    (0, node_fs_1.appendFileSync)(outputPath, `${name}<<${delimiter}\n${value}\n${delimiter}\n`, "utf8");
+    const delimiter = `versionary-${randomUUID()}`;
+    appendFileSync(outputPath, `${name}<<${delimiter}\n${value}\n${delimiter}\n`, "utf8");
 }
 function main() {
     const token = getInput("token") || getInput("github-token");
@@ -120,7 +118,7 @@ function main() {
             return;
         }
     }
-    const raw = (0, node_child_process_1.execFileSync)("npx", ["--yes", `versionary@${versionaryVersion}`, "run", "--json"], {
+    const raw = execFileSync("npx", ["--yes", `versionary@${versionaryVersion}`, "run", "--json"], {
         cwd,
         encoding: "utf8",
         stdio: ["ignore", "pipe", "pipe"],

package/dist/cli/index.js

@@ -1,15 +1,13 @@
 #!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_child_process_1 = require("node:child_process");
-const load_config_js_1 = require("../config/load-config.js");
-const changelog_js_1 = require("../release/changelog.js");
-const plan_js_1 = require("../release/plan.js");
-const pr_js_1 = require("../release/pr.js");
-const release_js_1 = require("../release/release.js");
-const verify_project_js_1 = require("../release/verify-project.js");
+import { execFileSync } from "node:child_process";
+import { loadConfig } from "../config/load-config.js";
+import { prependChangelog, renderReleasePlanChangelog, } from "../release/changelog.js";
+import { createReleasePlan } from "../release/plan.js";
+import { closeStaleReviewRequestIfExists, consumeNextReleaseFile, isReleaseCommitMessage, openOrUpdateReviewRequest, prepareReleasePr, pushReleaseBranch, readNextReleaseHighlights, } from "../release/pr.js";
+import { runRelease, runReleaseDetailed } from "../release/release.js";
+import { verifyProject } from "../release/verify-project.js";
 function printVerifyResult() {
-    const result = (0, verify_project_js_1.verifyProject)();
+    const result = verifyProject();
     const categories = [
         { key: "config", title: "Config" },
         { key: "paths", title: "Paths" },
@@ -47,13 +45,13 @@ async function main() {
     const flags = parseFlags(args);
     const logger = flags.json ? undefined : console;
     if (!command || command === "run") {
-        const commitMessage = (0, node_child_process_1.execFileSync)("git", ["log", "-1", "--pretty=%B"], {
+        const commitMessage = execFileSync("git", ["log", "-1", "--pretty=%B"], {
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"],
         }).trim();
-        if ((0, pr_js_1.isReleaseCommitMessage)(commitMessage)) {
+        if (isReleaseCommitMessage(commitMessage)) {
             if (flags["dry-run"] && !flags.json) {
-                const release = await (0, release_js_1.runReleaseDetailed)(process.cwd(), {
+                const release = await runReleaseDetailed(process.cwd(), {
                     logger,
                     "dry-run": true,
                 });
@@ -63,7 +61,7 @@ async function main() {
                 }
             }
             if (flags.json) {
-                const release = await (0, release_js_1.runReleaseDetailed)(process.cwd(), {
+                const release = await runReleaseDetailed(process.cwd(), {
                     logger,
                     "dry-run": flags["dry-run"],
                 });
@@ -94,14 +92,14 @@ async function main() {
                 });
                 return 0;
             }
-            const message = await (0, release_js_1.runRelease)(process.cwd());
+            const message = await runRelease(process.cwd());
             console.log(message);
             return 0;
         }
-        const plan = (0, plan_js_1.createReleasePlan)();
+        const plan = createReleasePlan();
         if (!plan.nextVersion) {
             if (!flags["dry-run"]) {
-                await (0, pr_js_1.closeStaleReviewRequestIfExists)(process.cwd(), { logger });
+                await closeStaleReviewRequestIfExists(process.cwd(), { logger });
             }
             const message = "No releasable commits found. Nothing to do.";
             if (flags.json) {
@@ -144,7 +142,7 @@ async function main() {
             console.log(dryRunMessage);
             return 0;
         }
-        const pr = (0, pr_js_1.prepareReleasePr)(process.cwd(), { logger });
+        const pr = prepareReleasePr(process.cwd(), { logger });
         if (!pr.updated) {
             const message = `Release PR branch ${pr.branch} is already up to date.`;
             if (flags.json) {
@@ -162,8 +160,8 @@ async function main() {
             console.log(`Title: ${pr.title}`);
             return 0;
         }
-        (0, pr_js_1.pushReleaseBranch)(process.cwd(), pr.branch);
-        const reviewResult = await (0, pr_js_1.openOrUpdateReviewRequest)(process.cwd(), pr.branch, pr.title, pr.version, pr.previousVersion, pr.commits, pr.plan, { logger, highlights: pr.highlights });
+        pushReleaseBranch(process.cwd(), pr.branch);
+        const reviewResult = await openOrUpdateReviewRequest(process.cwd(), pr.branch, pr.title, pr.version, pr.previousVersion, pr.commits, pr.plan, { logger, highlights: pr.highlights });
         const message = `Prepared release PR branch ${pr.branch}`;
         if (flags.json) {
             emitJson({
@@ -186,37 +184,37 @@ async function main() {
         return printVerifyResult();
     }
     if (command === "plan") {
-        const plan = (0, plan_js_1.createReleasePlan)();
+        const plan = createReleasePlan();
         console.log(JSON.stringify(plan, null, 2));
         return 0;
     }
     if (command === "changelog") {
         const write = args.includes("--write");
-        const plan = (0, plan_js_1.createReleasePlan)();
+        const plan = createReleasePlan();
         if (!plan.nextVersion) {
             console.log("No releasable commits found.");
             return 0;
         }
-        const loaded = (0, load_config_js_1.loadConfig)();
-        const highlightsRead = (0, pr_js_1.readNextReleaseHighlights)(process.cwd(), loaded.config);
+        const loaded = loadConfig();
+        const highlightsRead = readNextReleaseHighlights(process.cwd(), loaded.config);
         const highlights = highlightsRead?.content ?? "";
-        const section = (0, changelog_js_1.renderReleasePlanChangelog)(plan, { highlights });
+        const section = renderReleasePlanChangelog(plan, { highlights });
         if (!write) {
             console.log(section);
             return 0;
         }
-        (0, changelog_js_1.prependChangelog)(process.cwd(), plan.changelogFile, section, plan.changelogFormat);
+        prependChangelog(process.cwd(), plan.changelogFile, section, plan.changelogFormat);
         if (highlightsRead) {
-            (0, pr_js_1.consumeNextReleaseFile)(process.cwd(), highlightsRead.filePath);
+            consumeNextReleaseFile(process.cwd(), highlightsRead.filePath);
         }
         console.log(`Updated ${plan.changelogFile}`);
         return 0;
     }
     if (command === "pr") {
-        const plan = (0, plan_js_1.createReleasePlan)();
+        const plan = createReleasePlan();
         if (!plan.nextVersion) {
             if (!flags["dry-run"]) {
-                await (0, pr_js_1.closeStaleReviewRequestIfExists)(process.cwd(), {
+                await closeStaleReviewRequestIfExists(process.cwd(), {
                     logger: console,
                 });
             }
@@ -227,14 +225,14 @@ async function main() {
             console.log(`Dry run: would prepare release PR branch ${plan.releaseBranchPrefix} for ${plan.nextVersion}`);
             return 0;
         }
-        const pr = (0, pr_js_1.prepareReleasePr)(process.cwd(), { logger: console });
+        const pr = prepareReleasePr(process.cwd(), { logger: console });
         if (!pr.updated) {
             console.log(`Release PR branch ${pr.branch} is already up to date.`);
             console.log(`Title: ${pr.title}`);
             return 0;
         }
-        (0, pr_js_1.pushReleaseBranch)(process.cwd(), pr.branch);
-        const reviewResult = await (0, pr_js_1.openOrUpdateReviewRequest)(process.cwd(), pr.branch, pr.title, pr.version, pr.previousVersion, pr.commits, pr.plan, { highlights: pr.highlights });
+        pushReleaseBranch(process.cwd(), pr.branch);
+        const reviewResult = await openOrUpdateReviewRequest(process.cwd(), pr.branch, pr.title, pr.version, pr.previousVersion, pr.commits, pr.plan, { highlights: pr.highlights });
         console.log(`Prepared release PR branch ${pr.branch}`);
         console.log(`Title: ${pr.title}`);
         console.log(reviewResult);
@@ -242,7 +240,7 @@ async function main() {
     }
     if (command === "release") {
         if (flags["dry-run"]) {
-            const result = await (0, release_js_1.runReleaseDetailed)(process.cwd(), {
+            const result = await runReleaseDetailed(process.cwd(), {
                 logger,
                 "dry-run": true,
             });
@@ -257,7 +255,7 @@ async function main() {
             }
             return 0;
         }
-        const message = await (0, release_js_1.runRelease)(process.cwd());
+        const message = await runRelease(process.cwd());
         console.log(message);
         return 0;
     }

package/dist/config/load-config.js

@@ -1,22 +1,15 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findConfigFile = findConfigFile;
-exports.loadConfig = loadConfig;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const jsonc_parser_1 = require("jsonc-parser");
-const resolve_js_1 = require("../strategy/resolve.js");
-const schema_js_1 = require("./schema.js");
+import fs from "node:fs";
+import path from "node:path";
+import { parse as parseJsonc } from "jsonc-parser";
+import { listKnownReleaseTypes, resolveVersionStrategy, } from "../strategy/resolve.js";
+import { configSchema } from "./schema.js";
 const SUPPORTED_FILES = [
     { file: "versionary.jsonc", format: "jsonc" },
     { file: "versionary.json", format: "json" },
 ];
 function parseConfig(raw, format) {
     if (format === "json" || format === "jsonc") {
-        return (0, jsonc_parser_1.parse)(raw);
+        return parseJsonc(raw);
     }
     throw new Error("Unsupported config format. Use versionary.jsonc or versionary.json.");
 }
@@ -25,13 +18,13 @@ function isRecord(value) {
 }
 function validateReleaseTypes(config) {
     try {
-        (0, resolve_js_1.resolveVersionStrategy)(config);
+        resolveVersionStrategy(config);
     }
     catch (error) {
         if (error instanceof Error) {
             throw error;
         }
-        const known = (0, resolve_js_1.listKnownReleaseTypes)().join(", ");
+        const known = listKnownReleaseTypes().join(", ");
         throw new Error(`Unsupported release-type. Supported release types: ${known}.`);
     }
     for (const [packagePath, packageConfig] of Object.entries(config.packages ?? {})) {
@@ -40,32 +33,32 @@ function validateReleaseTypes(config) {
             continue;
         }
         try {
-            (0, resolve_js_1.resolveVersionStrategy)({ ...config, "release-type": packageReleaseType });
+            resolveVersionStrategy({ ...config, "release-type": packageReleaseType });
         }
         catch (error) {
             if (error instanceof Error) {
                 throw new Error(`${error.message} (in packages["${packagePath}"])`);
             }
-            const known = (0, resolve_js_1.listKnownReleaseTypes)().join(", ");
+            const known = listKnownReleaseTypes().join(", ");
             throw new Error(`Unsupported release-type in packages["${packagePath}"]. Supported release types: ${known}.`);
         }
     }
 }
-function findConfigFile(cwd) {
+export function findConfigFile(cwd) {
     for (const candidate of SUPPORTED_FILES) {
-        const candidatePath = node_path_1.default.join(cwd, candidate.file);
-        if (node_fs_1.default.existsSync(candidatePath)) {
+        const candidatePath = path.join(cwd, candidate.file);
+        if (fs.existsSync(candidatePath)) {
             return { path: candidatePath, format: candidate.format };
         }
     }
     return null;
 }
-function loadConfig(cwd = process.cwd()) {
+export function loadConfig(cwd = process.cwd()) {
     const found = findConfigFile(cwd);
     if (!found) {
         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 raw = fs.readFileSync(found.path, "utf8");
     const parsed = parseConfig(raw, found.format);
     if (!isRecord(parsed)) {
         throw new Error("Invalid config: expected an object at the root.");
@@ -73,7 +66,7 @@ function loadConfig(cwd = process.cwd()) {
     if (Object.hasOwn(parsed, "plugins")) {
         throw new Error('The "plugins" config key is no longer supported. Versionary uses built-in integrations only.');
     }
-    const validated = schema_js_1.configSchema.parse(parsed);
+    const validated = configSchema.parse(parsed);
     validateReleaseTypes(validated);
     return {
         path: found.path,

package/dist/config/schema.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.configSchema = void 0;
-const zod_1 = require("zod");
-const artifactRuleSchema = zod_1.z
+import { z } from "zod";
+const artifactRuleSchema = z
     .object({
-    type: zod_1.z.enum(["json", "toml", "yaml", "nix", "regex"]),
-    path: zod_1.z.string().min(1),
-    "field-path": zod_1.z.string().optional(),
-    jsonpath: zod_1.z.string().optional(),
-    pattern: zod_1.z.string().optional(),
+    type: z.enum(["json", "toml", "yaml", "nix", "regex"]),
+    path: z.string().min(1),
+    "field-path": z.string().optional(),
+    jsonpath: z.string().optional(),
+    pattern: z.string().optional(),
 })
     .superRefine((value, ctx) => {
     const needsJsonPath = value.type === "json" ||
@@ -18,77 +15,77 @@ const artifactRuleSchema = zod_1.z
     const hasFieldPath = Boolean(value["field-path"] ?? value.jsonpath);
     if (needsJsonPath && !hasFieldPath) {
         ctx.addIssue({
-            code: zod_1.z.ZodIssueCode.custom,
+            code: z.ZodIssueCode.custom,
             message: `${value.type} artifact rules require "field-path" (or deprecated "jsonpath").`,
             path: ["field-path"],
         });
     }
     if (needsJsonPath && value.pattern) {
         ctx.addIssue({
-            code: zod_1.z.ZodIssueCode.custom,
+            code: z.ZodIssueCode.custom,
             message: `${value.type} artifact rules do not support "pattern".`,
             path: ["pattern"],
         });
     }
     if (value["field-path"] && value.jsonpath) {
         ctx.addIssue({
-            code: zod_1.z.ZodIssueCode.custom,
+            code: z.ZodIssueCode.custom,
             message: 'Specify only one of "field-path" or deprecated "jsonpath".',
             path: ["field-path"],
         });
     }
     if (value.type === "regex" && !value.pattern) {
         ctx.addIssue({
-            code: zod_1.z.ZodIssueCode.custom,
+            code: z.ZodIssueCode.custom,
             message: 'regex artifact rules require "pattern".',
             path: ["pattern"],
         });
     }
     if (value.type === "regex" && (value["field-path"] || value.jsonpath)) {
         ctx.addIssue({
-            code: zod_1.z.ZodIssueCode.custom,
+            code: z.ZodIssueCode.custom,
             message: 'regex artifact rules do not support "field-path" or deprecated "jsonpath".',
             path: ["field-path"],
         });
     }
 });
-const packageSchema = zod_1.z
+const packageSchema = z
     .object({
-    "release-type": zod_1.z
-        .union([zod_1.z.string().min(1), zod_1.z.array(zod_1.z.string().min(1)).min(1)])
+    "release-type": z
+        .union([z.string().min(1), z.array(z.string().min(1)).min(1)])
         .optional(),
-    "package-name": zod_1.z.string().optional(),
-    "changelog-file": zod_1.z.string().optional(),
-    "changelog-format": zod_1.z.enum(["markdown-changelog", "r-news"]).optional(),
-    "exclude-paths": zod_1.z.array(zod_1.z.string()).optional(),
-    "extra-files": zod_1.z.array(artifactRuleSchema).optional(),
-    follows: zod_1.z.array(zod_1.z.string().min(1)).optional(),
+    "package-name": z.string().optional(),
+    "changelog-file": z.string().optional(),
+    "changelog-format": z.enum(["markdown-changelog", "r-news"]).optional(),
+    "exclude-paths": z.array(z.string()).optional(),
+    "extra-files": z.array(artifactRuleSchema).optional(),
+    follows: z.array(z.string().min(1)).optional(),
 })
     .strict();
-exports.configSchema = zod_1.z
+export const configSchema = z
     .object({
-    $schema: zod_1.z.string().optional(),
-    version: zod_1.z.literal(1),
-    "review-mode": zod_1.z.enum(["direct", "pr", "review"]).optional(),
-    "version-file": zod_1.z.string().optional(),
-    "changelog-file": zod_1.z.string().optional(),
-    "changelog-format": zod_1.z.enum(["markdown-changelog", "r-news"]).optional(),
-    "release-draft": zod_1.z.boolean().optional(),
-    "release-reference-comments": zod_1.z
+    $schema: z.string().optional(),
+    version: z.literal(1),
+    "review-mode": z.enum(["direct", "pr", "review"]).optional(),
+    "version-file": z.string().optional(),
+    "changelog-file": z.string().optional(),
+    "changelog-format": z.enum(["markdown-changelog", "r-news"]).optional(),
+    "release-draft": z.boolean().optional(),
+    "release-reference-comments": z
         .enum(["off", "best-effort", "strict"])
         .optional(),
-    "release-branch": zod_1.z.string().optional(),
-    "baseline-file": zod_1.z.string().optional(),
-    "next-release-file": zod_1.z.string().optional(),
-    "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
-        .union([zod_1.z.string().min(1), zod_1.z.array(zod_1.z.string().min(1)).min(1)])
+    "release-branch": z.string().optional(),
+    "baseline-file": z.string().optional(),
+    "next-release-file": z.string().optional(),
+    "bootstrap-sha": z.string().optional(),
+    "monorepo-mode": z.enum(["independent", "fixed"]).optional(),
+    "bump-minor-pre-major": z.boolean().optional(),
+    "allow-stable-major": z.boolean().optional(),
+    "include-commit-authors": z.boolean().optional(),
+    "release-type": z
+        .union([z.string().min(1), z.array(z.string().min(1)).min(1)])
         .optional(),
-    packages: zod_1.z.record(zod_1.z.string().min(1), packageSchema).optional(),
+    packages: z.record(z.string().min(1), packageSchema).optional(),
 })
     .strict()
     .superRefine((value, ctx) => {
@@ -107,7 +104,7 @@ exports.configSchema = zod_1.z
         for (const sourcePath of follows) {
             if (sourcePath === packagePath) {
                 ctx.addIssue({
-                    code: zod_1.z.ZodIssueCode.custom,
+                    code: z.ZodIssueCode.custom,
                     message: `Package "${packagePath}" cannot follow itself.`,
                     path: ["packages", packagePath, "follows"],
                 });
@@ -115,7 +112,7 @@ exports.configSchema = zod_1.z
             }
             if (!knownPaths.has(sourcePath)) {
                 ctx.addIssue({
-                    code: zod_1.z.ZodIssueCode.custom,
+                    code: z.ZodIssueCode.custom,
                     message: `Package "${packagePath}" follows unknown package "${sourcePath}".`,
                     path: ["packages", packagePath, "follows"],
                 });
@@ -125,7 +122,7 @@ exports.configSchema = zod_1.z
     if (followsByPath.size > 0 && value["monorepo-mode"] === "fixed") {
         for (const followerPath of followsByPath.keys()) {
             ctx.addIssue({
-                code: zod_1.z.ZodIssueCode.custom,
+                code: z.ZodIssueCode.custom,
                 message: 'Package "follows" cannot be combined with monorepo-mode "fixed" (fixed mode already pins all package versions together).',
                 path: ["packages", followerPath, "follows"],
             });
@@ -169,7 +166,7 @@ exports.configSchema = zod_1.z
         }
         reportedCycles.add(key);
         ctx.addIssue({
-            code: zod_1.z.ZodIssueCode.custom,
+            code: z.ZodIssueCode.custom,
             message: `Package "follows" cycle detected: ${cycle.join(" -> ")}.`,
             path: ["packages", cycle[0] ?? followerPath, "follows"],
         });

package/dist/git/commits.js

@@ -1,26 +1,7 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseConventionalCommitMessage = parseConventionalCommitMessage;
-exports.parseConventionalCommitMessageDetailed = parseConventionalCommitMessageDetailed;
-exports.getCommitsSinceLastTag = getCommitsSinceLastTag;
-exports.getCommitsForPath = getCommitsForPath;
-exports.getParsedCommitsSinceLastTag = getParsedCommitsSinceLastTag;
-exports.getParsedCommitsForPath = getParsedCommitsForPath;
-exports.inferReleaseTypeFromParsedCommit = inferReleaseTypeFromParsedCommit;
-exports.inferReleaseTypeFromSubject = inferReleaseTypeFromSubject;
-exports.isReleasableCommit = isReleasableCommit;
-exports.getCommitParseDiagnostics = getCommitParseDiagnostics;
-exports.analyzeCommits = analyzeCommits;
-exports.applyRevertSuppression = applyRevertSuppression;
-exports.analyzeParsedCommits = analyzeParsedCommits;
-exports.isReleasableParsedCommit = isReleasableParsedCommit;
-const node_child_process_1 = require("node:child_process");
-const node_path_1 = __importDefault(require("node:path"));
+import { execFileSync } from "node:child_process";
+import path from "node:path";
 function getReleaseBranchExcludeArgs(cwd) {
-    const releaseBranchesRaw = (0, node_child_process_1.execFileSync)("git", ["branch", "--list", "--format", "%(refname:short)"], {
+    const releaseBranchesRaw = execFileSync("git", ["branch", "--list", "--format", "%(refname:short)"], {
         cwd,
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"],
@@ -42,7 +23,7 @@ function getLatestReleaseTag(cwd) {
             "v[0-9]*",
             ...excludeArgs,
         ];
-        return (0, node_child_process_1.execFileSync)("git", cmd, {
+        return execFileSync("git", cmd, {
             cwd,
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"],
@@ -54,7 +35,7 @@ function getLatestReleaseTag(cwd) {
 }
 function isValidCommitish(cwd, ref) {
     try {
-        (0, node_child_process_1.execFileSync)("git", ["rev-parse", "--verify", `${ref}^{commit}`], {
+        execFileSync("git", ["rev-parse", "--verify", `${ref}^{commit}`], {
             cwd,
             stdio: ["ignore", "pipe", "ignore"],
         });
@@ -77,7 +58,7 @@ function resolveRange(cwd, baselineSha) {
     return latestTag ? `${latestTag}..HEAD` : "HEAD";
 }
 function readGitLog(cwd, range, pathspecs = []) {
-    const output = (0, node_child_process_1.execFileSync)("git", ["log", range, "--pretty=format:%H%x09%s", "--", ...pathspecs], {
+    const output = execFileSync("git", ["log", range, "--pretty=format:%H%x09%s", "--", ...pathspecs], {
         cwd,
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"],
@@ -96,7 +77,7 @@ function readGitLog(cwd, range, pathspecs = []) {
 function readGitLogFull(cwd, range, pathspecs = []) {
     const recordSeparator = "\x1e";
     const fieldSeparator = "\x1f";
-    const output = (0, node_child_process_1.execFileSync)("git", [
+    const output = execFileSync("git", [
         "log",
         range,
         `--pretty=format:%H${fieldSeparator}%s${fieldSeparator}%b${recordSeparator}`,
@@ -344,17 +325,17 @@ function parseCommitMessage(hash, subject, body) {
         diagnostics,
     };
 }
-function parseConventionalCommitMessage(subject, body = "") {
+export function parseConventionalCommitMessage(subject, body = "") {
     return parseCommitMessage("", subject.trim(), body.trim());
 }
-function parseConventionalCommitMessageDetailed(header, body = "") {
+export function parseConventionalCommitMessageDetailed(header, body = "") {
     return parseCommitMessage("", header.trim(), body.trim());
 }
-function getCommitsSinceLastTag(cwd = process.cwd(), baselineSha) {
+export function getCommitsSinceLastTag(cwd = process.cwd(), baselineSha) {
     const range = resolveRange(cwd, baselineSha);
     return readGitLog(cwd, range);
 }
-function getCommitsForPath(cwd = process.cwd(), baselineSha, packagePath = ".", excludePaths = []) {
+export function getCommitsForPath(cwd = process.cwd(), baselineSha, packagePath = ".", excludePaths = []) {
     const range = resolveRange(cwd, baselineSha);
     const normalizedPackagePath = packagePath === "." ? "." : packagePath;
     const excludes = excludePaths.flatMap((excludePath) => {
@@ -363,16 +344,16 @@ function getCommitsForPath(cwd = process.cwd(), baselineSha, packagePath = ".",
             .replace(/\/+$/u, "");
         const combined = normalizedPackagePath === "."
             ? normalizedExcludePath
-            : node_path_1.default.posix.join(normalizedPackagePath, normalizedExcludePath);
+            : path.posix.join(normalizedPackagePath, normalizedExcludePath);
         return [`:(exclude)${combined}`, `:(exclude)${combined}/**`];
     });
     return readGitLog(cwd, range, [normalizedPackagePath, ...excludes]);
 }
-function getParsedCommitsSinceLastTag(cwd = process.cwd(), baselineSha) {
+export function getParsedCommitsSinceLastTag(cwd = process.cwd(), baselineSha) {
     const range = resolveRange(cwd, baselineSha);
     return readGitLogFull(cwd, range);
 }
-function getParsedCommitsForPath(cwd = process.cwd(), baselineSha, packagePath = ".", excludePaths = []) {
+export function getParsedCommitsForPath(cwd = process.cwd(), baselineSha, packagePath = ".", excludePaths = []) {
     const range = resolveRange(cwd, baselineSha);
     const normalizedPackagePath = packagePath === "." ? "." : packagePath;
     const excludes = excludePaths.flatMap((excludePath) => {
@@ -381,12 +362,12 @@ function getParsedCommitsForPath(cwd = process.cwd(), baselineSha, packagePath =
             .replace(/\/+$/u, "");
         const combined = normalizedPackagePath === "."
             ? normalizedExcludePath
-            : node_path_1.default.posix.join(normalizedPackagePath, normalizedExcludePath);
+            : path.posix.join(normalizedPackagePath, normalizedExcludePath);
         return [`:(exclude)${combined}`, `:(exclude)${combined}/**`];
     });
     return readGitLogFull(cwd, range, [normalizedPackagePath, ...excludes]);
 }
-function inferReleaseTypeFromParsedCommit(commit) {
+export function inferReleaseTypeFromParsedCommit(commit) {
     if (commit.isBreaking) {
         return "major";
     }
@@ -405,16 +386,16 @@ function inferReleaseTypeFromParsedCommit(commit) {
     }
     return null;
 }
-function inferReleaseTypeFromSubject(subject) {
+export function inferReleaseTypeFromSubject(subject) {
     return inferReleaseTypeFromParsedCommit(parseCommitMessage("", subject.trim(), ""));
 }
-function isReleasableCommit(subject) {
+export function isReleasableCommit(subject) {
     return inferReleaseTypeFromSubject(subject) !== null;
 }
-function getCommitParseDiagnostics(commit) {
+export function getCommitParseDiagnostics(commit) {
     return commit.diagnostics ?? [];
 }
-function analyzeCommits(commits) {
+export function analyzeCommits(commits) {
     let result = null;
     for (const commit of commits) {
         const type = inferReleaseTypeFromSubject(commit.subject);
@@ -431,7 +412,7 @@ function analyzeCommits(commits) {
     }
     return result;
 }
-function applyRevertSuppression(commits) {
+export function applyRevertSuppression(commits) {
     if (commits.length === 0) {
         return commits;
     }
@@ -458,7 +439,7 @@ function applyRevertSuppression(commits) {
         return !reverted.has(hash) && !suppressedReverts.has(hash);
     });
 }
-function analyzeParsedCommits(commits) {
+export function analyzeParsedCommits(commits) {
     let result = null;
     const effectiveCommits = applyRevertSuppression(commits);
     for (const commit of effectiveCommits) {
@@ -476,6 +457,6 @@ function analyzeParsedCommits(commits) {
     }
     return result;
 }
-function isReleasableParsedCommit(commit) {
+export function isReleasableParsedCommit(commit) {
     return inferReleaseTypeFromParsedCommit(commit) !== null;
 }