versionary 0.2.0 → 0.4.0

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 });

package/dist/plugins/runtime.d.ts

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

package/dist/plugins/runtime.js

@@ -1,24 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadRuntimePlugins = loadRuntimePlugins;
-const load_config_js_1 = require("../config/load-config.js");
-const github_plugin_js_1 = require("../scm/github-plugin.js");
-const BUILTIN_PLUGIN_FACTORIES = {
-    github: 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, github_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;
-}
+exports.loadRuntimePlugins = void 0;
+var runtime_js_1 = require("../infra/scm/runtime.js");
+Object.defineProperty(exports, "loadRuntimePlugins", { enumerable: true, get: function () { return runtime_js_1.loadRuntimePlugins; } });