versionary 0.1.0 → 0.3.0

package/dist/domain/release/plan.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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 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");
+function getMode(configMode) {
+    return configMode ?? "independent";
+}
+function createSimplePlan(cwd = process.cwd()) {
+    const loaded = (0, load_config_js_1.loadConfig)(cwd);
+    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;
+    const versionPath = node_path_1.default.join(cwd, versionFile);
+    if (!node_fs_1.default.existsSync(versionPath)) {
+        throw new Error(`Versionary requires ${versionFile} to exist.`);
+    }
+    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,
+    }));
+    const monorepoMode = getMode(loaded.config["monorepo-mode"]);
+    const hasPackages = configuredPackages.length > 0;
+    if (!hasPackages) {
+        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,
+            currentVersion,
+            nextVersion,
+            versionFile,
+            changelogFile,
+            releaseBranchPrefix,
+            baselineSha,
+            commits,
+        };
+    }
+    const packagePlans = configuredPackages
+        .map((pkg) => {
+        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, 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,
+            nextVersion: fixedNextVersion,
+        }));
+        return {
+            mode: "simple",
+            releaseType: fixedType,
+            currentVersion,
+            nextVersion: fixedNextVersion,
+            versionFile,
+            changelogFile,
+            releaseBranchPrefix,
+            baselineSha,
+            commits: adjusted.flatMap((pkgPlan) => pkgPlan.commits),
+            packages: adjusted,
+        };
+    }
+    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,
+        currentVersion,
+        nextVersion: overallNextVersion,
+        versionFile,
+        changelogFile,
+        releaseBranchPrefix,
+        baselineSha,
+        commits: packagePlans.flatMap((pkgPlan) => pkgPlan.commits),
+        packages: packagePlans,
+    };
+}

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;

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,3 +1,8 @@
-export type { VersionaryConfig, VersionaryPackage, VersionaryPluginRef, VersionaryArtifactRule, } from "./types/config.js";
 export { loadConfig } from "./config/load-config.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,7 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifyProject = 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; } });
+var runtime_js_1 = require("./plugins/runtime.js");
+Object.defineProperty(exports, "loadRuntimePlugins", { enumerable: true, get: function () { return runtime_js_1.loadRuntimePlugins; } });
 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/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;