versionary 0.2.0 → 0.3.0

package/dist/domain/strategy/node.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeVersionStrategy = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+exports.nodeVersionStrategy = {
+    name: "node",
+    getVersionFile(config) {
+        return config["version-file"] ?? "version.txt";
+    },
+    readVersion(cwd, config) {
+        const versionFile = this.getVersionFile(config);
+        const versionPath = node_path_1.default.join(cwd, versionFile);
+        if (!node_fs_1.default.existsSync(versionPath)) {
+            throw new Error(`Versionary requires ${versionFile} to exist.`);
+        }
+        return node_fs_1.default.readFileSync(versionPath, "utf8").trim();
+    },
+    writeVersion(cwd, config, version) {
+        const versionFile = this.getVersionFile(config);
+        const versionPath = node_path_1.default.join(cwd, versionFile);
+        node_fs_1.default.writeFileSync(versionPath, `${version}\n`, "utf8");
+        const updatedFiles = [versionFile];
+        const packageJsonPath = node_path_1.default.join(cwd, "package.json");
+        if (node_fs_1.default.existsSync(packageJsonPath)) {
+            const packageJsonRaw = node_fs_1.default.readFileSync(packageJsonPath, "utf8");
+            const packageJson = JSON.parse(packageJsonRaw);
+            packageJson.version = version;
+            node_fs_1.default.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, "utf8");
+            updatedFiles.push("package.json");
+        }
+        return updatedFiles;
+    },
+};

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

@@ -0,0 +1,3 @@
+import type { VersionaryConfig } from "../../types/config.js";
+import type { VersionStrategy } from "./types.js";
+export declare function resolveVersionStrategy(config: VersionaryConfig): VersionStrategy;

package/dist/domain/strategy/resolve.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveVersionStrategy = resolveVersionStrategy;
+const node_js_1 = require("./node.js");
+const simple_js_1 = require("./simple.js");
+function resolveVersionStrategy(config) {
+    if (config["release-type"] === "node") {
+        return node_js_1.nodeVersionStrategy;
+    }
+    return simple_js_1.simpleVersionStrategy;
+}

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

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

package/dist/domain/strategy/simple.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simpleVersionStrategy = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+exports.simpleVersionStrategy = {
+    name: "simple",
+    getVersionFile(config) {
+        return config["version-file"] ?? "version.txt";
+    },
+    readVersion(cwd, config) {
+        const versionFile = this.getVersionFile(config);
+        const versionPath = node_path_1.default.join(cwd, versionFile);
+        if (!node_fs_1.default.existsSync(versionPath)) {
+            throw new Error(`Versionary requires ${versionFile} to exist.`);
+        }
+        return node_fs_1.default.readFileSync(versionPath, "utf8").trim();
+    },
+    writeVersion(cwd, config, version) {
+        const versionFile = this.getVersionFile(config);
+        const versionPath = node_path_1.default.join(cwd, versionFile);
+        node_fs_1.default.writeFileSync(versionPath, `${version}\n`, "utf8");
+        return [versionFile];
+    },
+};

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

@@ -0,0 +1,7 @@
+import type { VersionaryConfig } from "../../types/config.js";
+export interface VersionStrategy {
+    name: string;
+    getVersionFile(config: VersionaryConfig): string;
+    readVersion(cwd: string, config: VersionaryConfig): string;
+    writeVersion(cwd: string, config: VersionaryConfig, version: string): string[];
+}

package/dist/domain/strategy/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -1,6 +1,8 @@
-export type { VersionaryConfig, VersionaryPackage, VersionaryArtifactRule, } from "./types/config.js";
-export type { VersionaryPluginCapability, VersionaryPluginContext, VersionaryPluginRuntime, VersionaryScmReviewRequestInput, VersionaryScmReviewRequestResult, VersionaryScmReleaseMetadataInput, VersionaryScmReleaseMetadataResult, } from "./types/plugins.js";
 export { loadConfig } from "./config/load-config.js";
-export { findPluginsByCapability, pluginHasCapability } from "./plugins/capabilities.js";
+export { resolveVersionStrategy } from "./domain/strategy/resolve.js";
+export { createGitHubPlugin } from "./infra/scm/github/plugin.js";
+export { findPluginsByCapability, pluginHasCapability, } from "./plugins/capabilities.js";
 export { loadRuntimePlugins } from "./plugins/runtime.js";
+export type { VersionaryArtifactRule, VersionaryConfig, VersionaryPackage, } from "./types/config.js";
+export type { VersionaryPluginCapability, VersionaryPluginContext, VersionaryPluginRuntime, VersionaryScmReleaseMetadataInput, VersionaryScmReleaseMetadataResult, VersionaryScmReviewRequestInput, VersionaryScmReviewRequestResult, } from "./types/plugins.js";
 export { verifyProject } from "./verify/verify-project.js";

package/dist/index.js

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifyProject = exports.loadRuntimePlugins = exports.pluginHasCapability = exports.findPluginsByCapability = exports.loadConfig = void 0;
+exports.verifyProject = exports.loadRuntimePlugins = exports.pluginHasCapability = exports.findPluginsByCapability = exports.createGitHubPlugin = exports.resolveVersionStrategy = exports.loadConfig = void 0;
 var load_config_js_1 = require("./config/load-config.js");
 Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return load_config_js_1.loadConfig; } });
+var resolve_js_1 = require("./domain/strategy/resolve.js");
+Object.defineProperty(exports, "resolveVersionStrategy", { enumerable: true, get: function () { return resolve_js_1.resolveVersionStrategy; } });
+var plugin_js_1 = require("./infra/scm/github/plugin.js");
+Object.defineProperty(exports, "createGitHubPlugin", { enumerable: true, get: function () { return plugin_js_1.createGitHubPlugin; } });
 var capabilities_js_1 = require("./plugins/capabilities.js");
 Object.defineProperty(exports, "findPluginsByCapability", { enumerable: true, get: function () { return capabilities_js_1.findPluginsByCapability; } });
 Object.defineProperty(exports, "pluginHasCapability", { enumerable: true, get: function () { return capabilities_js_1.pluginHasCapability; } });

package/dist/infra/git/commits.d.ts

@@ -0,0 +1,65 @@
+import type { ReleaseType } from "../../domain/release/semver.js";
+export interface CommitInfo {
+    hash: string;
+    subject: string;
+}
+export interface ParsedCommit {
+    hash: string;
+    subject: string;
+    body: string;
+    fullMessage: string;
+    type: string | null;
+    scope: string | null;
+    description: string;
+    isBreaking: boolean;
+    isRevert: boolean;
+    footers: Array<{
+        token: string;
+        value: string;
+    }>;
+    revertedShas: string[];
+    header?: string;
+    merge?: string | null;
+    footer?: string | null;
+    notes?: CommitNote[];
+    references?: CommitReference[];
+    mentions?: string[];
+    revert?: RevertInfo | null;
+    isConventional?: boolean;
+    diagnostics?: ParseDiagnostic[];
+}
+export type CommitParseDiagnosticCode = "invalid-header" | "malformed-breaking-footer" | "malformed-reference" | "ambiguous-revert";
+export interface ParseDiagnostic {
+    code: CommitParseDiagnosticCode;
+    message: string;
+}
+export interface CommitNote {
+    title: string;
+    text: string;
+}
+export interface CommitReference {
+    action: string | null;
+    owner: string | null;
+    repository: string | null;
+    issue: string | null;
+    raw: string;
+    prefix: "#" | "GH-";
+}
+export interface RevertInfo {
+    header: string;
+    hashes: string[];
+}
+export declare function parseConventionalCommitMessage(subject: string, body?: string): ParsedCommit;
+export declare function parseConventionalCommitMessageDetailed(header: string, body?: string): ParsedCommit;
+export declare function getCommitsSinceLastTag(cwd?: string, baselineSha?: string | null): CommitInfo[];
+export declare function getCommitsForPath(cwd?: string, baselineSha?: string | null, packagePath?: string, excludePaths?: string[]): CommitInfo[];
+export declare function getParsedCommitsSinceLastTag(cwd?: string, baselineSha?: string | null): ParsedCommit[];
+export declare function getParsedCommitsForPath(cwd?: string, baselineSha?: string | null, packagePath?: string, excludePaths?: string[]): ParsedCommit[];
+export declare function inferReleaseTypeFromParsedCommit(commit: ParsedCommit): ReleaseType;
+export declare function inferReleaseTypeFromSubject(subject: string): ReleaseType;
+export declare function isReleasableCommit(subject: string): boolean;
+export declare function getCommitParseDiagnostics(commit: ParsedCommit): ParseDiagnostic[];
+export declare function analyzeCommits(commits: CommitInfo[]): ReleaseType;
+export declare function applyRevertSuppression(commits: ParsedCommit[]): ParsedCommit[];
+export declare function analyzeParsedCommits(commits: ParsedCommit[]): ReleaseType;
+export declare function isReleasableParsedCommit(commit: ParsedCommit): boolean;

package/dist/infra/git/commits.js

@@ -0,0 +1,436 @@
+"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"));
+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 releaseBranches = releaseBranchesRaw
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith("versionary/release"));
+    return releaseBranches.flatMap((branch) => ["--exclude", branch]);
+}
+function getLatestReleaseTag(cwd) {
+    const excludeArgs = getReleaseBranchExcludeArgs(cwd);
+    try {
+        const cmd = [
+            "describe",
+            "--tags",
+            "--abbrev=0",
+            "--match",
+            "v[0-9]*",
+            ...excludeArgs,
+        ];
+        return (0, node_child_process_1.execFileSync)("git", cmd, {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    }
+    catch {
+        return "";
+    }
+}
+function isValidCommitish(cwd, ref) {
+    try {
+        (0, node_child_process_1.execFileSync)("git", ["rev-parse", "--verify", `${ref}^{commit}`], {
+            cwd,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function resolveRange(cwd, baselineSha) {
+    const baseRef = baselineSha ?? "";
+    if (!baseRef) {
+        const latestTag = getLatestReleaseTag(cwd);
+        return latestTag ? `${latestTag}..HEAD` : "HEAD";
+    }
+    if (isValidCommitish(cwd, baseRef)) {
+        return `${baseRef}..HEAD`;
+    }
+    const latestTag = getLatestReleaseTag(cwd);
+    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], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+    if (!output.trim()) {
+        return [];
+    }
+    return output
+        .trim()
+        .split("\n")
+        .map((line) => {
+        const [hash, subject] = line.split("\t");
+        return { hash, subject };
+    });
+}
+function readGitLogFull(cwd, range, pathspecs = []) {
+    const recordSeparator = "\x1e";
+    const fieldSeparator = "\x1f";
+    const output = (0, node_child_process_1.execFileSync)("git", [
+        "log",
+        range,
+        `--pretty=format:%H${fieldSeparator}%s${fieldSeparator}%b${recordSeparator}`,
+        "--",
+        ...pathspecs,
+    ], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+    if (!output.trim()) {
+        return [];
+    }
+    return output
+        .split(recordSeparator)
+        .map((record) => record.trim())
+        .filter((record) => record.length > 0)
+        .map((record) => {
+        const [hash = "", subject = "", body = ""] = record.split(fieldSeparator);
+        return parseCommitMessage(hash, subject.trim(), body.trim());
+    });
+}
+function parseHeader(subject) {
+    const conventionalMatch = subject.match(/^([a-z][a-z0-9-]*)(?:\(([^)]+)\))?(!)?:\s+(.+)$/iu);
+    if (!conventionalMatch) {
+        return {
+            type: null,
+            scope: null,
+            description: subject,
+            isBreakingHeader: false,
+            isConventional: false,
+            diagnostics: [
+                {
+                    code: "invalid-header",
+                    message: "Header does not match Conventional Commits format: <type>(<scope>)?: <description>.",
+                },
+            ],
+        };
+    }
+    return {
+        type: conventionalMatch[1]?.toLowerCase() ?? null,
+        scope: conventionalMatch[2]?.trim() ?? null,
+        isBreakingHeader: conventionalMatch[3] === "!",
+        description: conventionalMatch[4]?.trim() ?? subject,
+        isConventional: true,
+        diagnostics: [],
+    };
+}
+function parseFooters(body) {
+    if (!body) {
+        return {
+            bodyText: "",
+            footerText: null,
+            footers: [],
+            diagnostics: [],
+            references: [],
+            notes: [],
+        };
+    }
+    const parseFooterLine = (line) => {
+        const colonMatch = line.match(/^(BREAKING CHANGE|BREAKING-CHANGE|[A-Za-z][A-Za-z0-9-]*):\s+(.+)$/u);
+        if (colonMatch) {
+            return {
+                token: colonMatch[1] ?? "",
+                value: colonMatch[2] ?? "",
+            };
+        }
+        const issueRefMatch = line.match(/^([A-Za-z][A-Za-z0-9-]*)\s+((?:GH-|#).+)$/u);
+        if (issueRefMatch) {
+            return {
+                token: issueRefMatch[1] ?? "",
+                value: issueRefMatch[2] ?? "",
+            };
+        }
+        return null;
+    };
+    const diagnostics = [];
+    const lines = body.split("\n");
+    for (const line of lines) {
+        if (/^\s*BREAKING(?:\s|-)?CHANGE\b/iu.test(line) &&
+            !/^\s*(BREAKING CHANGE|BREAKING-CHANGE):\s+/iu.test(line)) {
+            diagnostics.push({
+                code: "malformed-breaking-footer",
+                message: "Found BREAKING CHANGE-like footer without required ': ' separator.",
+            });
+        }
+    }
+    const footerStart = lines.findIndex((line) => parseFooterLine(line) !== null);
+    const bodyLines = footerStart < 0 ? lines : lines.slice(0, footerStart);
+    const footerLines = footerStart < 0 ? [] : lines.slice(footerStart);
+    const footers = [];
+    const references = [];
+    const notes = [];
+    let current = null;
+    const pushCurrent = () => {
+        if (!current) {
+            return;
+        }
+        footers.push({
+            token: current.token,
+            value: current.value.trim(),
+        });
+        current = null;
+    };
+    const extractReferences = (text, action) => {
+        const refs = text.match(/(?:GH-|#)[^\s,;:()]+/gu) ?? [];
+        for (const raw of refs) {
+            const issue = raw.replace(/^(GH-|#)/u, "");
+            if (!/^\d+$/u.test(issue)) {
+                diagnostics.push({
+                    code: "malformed-reference",
+                    message: `Malformed issue reference "${raw}" in footer.`,
+                });
+                continue;
+            }
+            references.push({
+                action,
+                owner: null,
+                repository: null,
+                issue,
+                raw,
+                prefix: raw.startsWith("GH-") ? "GH-" : "#",
+            });
+        }
+    };
+    for (const line of footerLines) {
+        const footerMatch = parseFooterLine(line);
+        if (footerMatch) {
+            pushCurrent();
+            current = {
+                token: footerMatch.token,
+                value: footerMatch.value,
+            };
+            continue;
+        }
+        if (current && line.trim().length > 0) {
+            current.value = `${current.value}\n${line}`;
+            continue;
+        }
+        pushCurrent();
+    }
+    pushCurrent();
+    for (const footer of footers) {
+        if (/^(BREAKING CHANGE|BREAKING-CHANGE)$/iu.test(footer.token)) {
+            notes.push({
+                title: "BREAKING CHANGE",
+                text: footer.value,
+            });
+        }
+        extractReferences(`${footer.token}: ${footer.value}`, footer.token);
+    }
+    return {
+        bodyText: bodyLines.join("\n").trim() || "",
+        footerText: footerLines.length > 0 ? footerLines.join("\n").trim() : null,
+        footers,
+        diagnostics,
+        references,
+        notes,
+    };
+}
+function extractRevertedShas(subject, body) {
+    const full = `${subject}\n${body}`;
+    const matches = full.match(/\b[0-9a-f]{7,40}\b/giu) ?? [];
+    return [...new Set(matches.map((sha) => sha.toLowerCase()))];
+}
+function extractMentions(text) {
+    const mentions = text.match(/(?:^|[^A-Za-z0-9_])@([A-Za-z0-9][A-Za-z0-9-]{0,38})/gu) ?? [];
+    return [
+        ...new Set(mentions
+            .map((mention) => mention.replace(/^.*@/u, ""))
+            .filter((mention) => mention.length > 0)),
+    ];
+}
+function parseCommitMessage(hash, subject, body) {
+    const header = parseHeader(subject);
+    const footerResult = parseFooters(body);
+    const bodyText = footerResult.bodyText;
+    const footers = footerResult.footers;
+    const hasBreakingFooter = footers.some((footer) => /^(BREAKING CHANGE|BREAKING-CHANGE)$/iu.test(footer.token));
+    const isRevert = (header.type?.toLowerCase() ?? "") === "revert" ||
+        /^revert:\s/i.test(subject);
+    const revertInfo = isRevert
+        ? {
+            header: subject,
+            hashes: extractRevertedShas(subject, body),
+        }
+        : null;
+    const diagnostics = [...header.diagnostics, ...footerResult.diagnostics];
+    if (isRevert && revertInfo && revertInfo.hashes.length === 0) {
+        diagnostics.push({
+            code: "ambiguous-revert",
+            message: "Revert commit detected but no reverted commit SHA reference was parsed.",
+        });
+    }
+    return {
+        hash,
+        subject,
+        body: bodyText,
+        fullMessage: body ? `${subject}\n\n${body}` : subject,
+        type: header.type,
+        scope: header.scope,
+        description: header.description,
+        isBreaking: header.isBreakingHeader || hasBreakingFooter,
+        isRevert,
+        footers,
+        revertedShas: isRevert ? extractRevertedShas(subject, body) : [],
+        header: subject,
+        merge: null,
+        footer: footerResult.footerText,
+        notes: footerResult.notes,
+        references: footerResult.references,
+        mentions: extractMentions(`${subject}\n${body}`),
+        revert: revertInfo,
+        isConventional: header.isConventional,
+        diagnostics,
+    };
+}
+function parseConventionalCommitMessage(subject, body = "") {
+    return parseCommitMessage("", subject.trim(), body.trim());
+}
+function parseConventionalCommitMessageDetailed(header, body = "") {
+    return parseCommitMessage("", header.trim(), body.trim());
+}
+function getCommitsSinceLastTag(cwd = process.cwd(), baselineSha) {
+    const range = resolveRange(cwd, baselineSha);
+    return readGitLog(cwd, range);
+}
+function getCommitsForPath(cwd = process.cwd(), baselineSha, packagePath = ".", excludePaths = []) {
+    const range = resolveRange(cwd, baselineSha);
+    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 getParsedCommitsSinceLastTag(cwd = process.cwd(), baselineSha) {
+    const range = resolveRange(cwd, baselineSha);
+    return readGitLogFull(cwd, range);
+}
+function getParsedCommitsForPath(cwd = process.cwd(), baselineSha, packagePath = ".", excludePaths = []) {
+    const range = resolveRange(cwd, baselineSha);
+    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 readGitLogFull(cwd, range, [normalizedPackagePath, ...excludes]);
+}
+function inferReleaseTypeFromParsedCommit(commit) {
+    if (commit.isRevert) {
+        return null;
+    }
+    if (commit.isBreaking) {
+        return "major";
+    }
+    const type = commit.type?.toLowerCase() ?? "";
+    if (type === "feat") {
+        return "minor";
+    }
+    if (type === "fix" || type === "perf") {
+        return "patch";
+    }
+    if (type === "chore") {
+        return null;
+    }
+    return null;
+}
+function inferReleaseTypeFromSubject(subject) {
+    return inferReleaseTypeFromParsedCommit(parseCommitMessage("", subject.trim(), ""));
+}
+function isReleasableCommit(subject) {
+    return inferReleaseTypeFromSubject(subject) !== null;
+}
+function getCommitParseDiagnostics(commit) {
+    return commit.diagnostics ?? [];
+}
+function analyzeCommits(commits) {
+    let result = null;
+    for (const commit of commits) {
+        const type = inferReleaseTypeFromSubject(commit.subject);
+        if (type === "major") {
+            return "major";
+        }
+        if (type === "minor") {
+            result = "minor";
+            continue;
+        }
+        if (type === "patch" && result === null) {
+            result = "patch";
+        }
+    }
+    return result;
+}
+function applyRevertSuppression(commits) {
+    if (commits.length === 0) {
+        return commits;
+    }
+    const presentShas = new Set(commits.map((commit) => commit.hash.toLowerCase()));
+    const reverted = new Set();
+    for (const commit of commits) {
+        if (!commit.isRevert) {
+            continue;
+        }
+        for (const sha of commit.revertedShas) {
+            if (presentShas.has(sha)) {
+                reverted.add(sha);
+            }
+        }
+    }
+    return commits.filter((commit) => !reverted.has(commit.hash.toLowerCase()));
+}
+function analyzeParsedCommits(commits) {
+    let result = null;
+    const effectiveCommits = applyRevertSuppression(commits);
+    for (const commit of effectiveCommits) {
+        const type = inferReleaseTypeFromParsedCommit(commit);
+        if (type === "major") {
+            return "major";
+        }
+        if (type === "minor") {
+            result = "minor";
+            continue;
+        }
+        if (type === "patch" && result === null) {
+            result = "patch";
+        }
+    }
+    return result;
+}
+function isReleasableParsedCommit(commit) {
+    return inferReleaseTypeFromParsedCommit(commit) !== null;
+}

package/dist/infra/scm/github/plugin.d.ts

@@ -0,0 +1 @@
+export { createGitHubPlugin } from "../../../scm/github-plugin.js";

package/dist/infra/scm/github/plugin.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGitHubPlugin = void 0;
+var github_plugin_js_1 = require("../../../scm/github-plugin.js");
+Object.defineProperty(exports, "createGitHubPlugin", { enumerable: true, get: function () { return github_plugin_js_1.createGitHubPlugin; } });

package/dist/infra/scm/runtime.d.ts

@@ -0,0 +1,2 @@
+import type { VersionaryPluginRuntime } from "../../types/plugins.js";
+export declare function loadRuntimePlugins(cwd?: string): VersionaryPluginRuntime[];

package/dist/infra/scm/runtime.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRuntimePlugins = loadRuntimePlugins;
+const load_config_js_1 = require("../../config/load-config.js");
+const plugin_js_1 = require("./github/plugin.js");
+const BUILTIN_PLUGIN_FACTORIES = {
+    github: plugin_js_1.createGitHubPlugin,
+};
+function loadRuntimePlugins(cwd = process.cwd()) {
+    const loaded = (0, load_config_js_1.loadConfig)(cwd);
+    const configured = loaded.config.plugins ?? [];
+    const plugins = [(0, plugin_js_1.createGitHubPlugin)()];
+    const seen = new Set(plugins.map((plugin) => plugin.name));
+    for (const name of configured) {
+        const factory = BUILTIN_PLUGIN_FACTORIES[name];
+        if (!factory || seen.has(name)) {
+            continue;
+        }
+        const plugin = factory();
+        plugins.push(plugin);
+        seen.add(plugin.name);
+    }
+    return plugins;
+}

package/dist/infra/scm/types.d.ts

@@ -0,0 +1 @@
+export type { VersionaryPluginCapability, VersionaryPluginContext, VersionaryPluginRuntime, VersionaryScmReleaseMetadataInput, VersionaryScmReleaseMetadataResult, VersionaryScmReviewRequestInput, VersionaryScmReviewRequestResult, } from "../../types/plugins.js";

package/dist/infra/scm/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });