versionary 0.2.0 → 0.4.0

package/dist/domain/strategy/node.js

@@ -0,0 +1,67 @@
+"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"));
+function readJsonFile(targetPath) {
+    return JSON.parse(node_fs_1.default.readFileSync(targetPath, "utf8"));
+}
+function writeJsonFile(targetPath, value) {
+    node_fs_1.default.writeFileSync(targetPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+function updateNodeLockfileVersion(cwd, version) {
+    const updated = [];
+    for (const lockfile of ["package-lock.json", "npm-shrinkwrap.json"]) {
+        const lockfilePath = node_path_1.default.join(cwd, lockfile);
+        if (!node_fs_1.default.existsSync(lockfilePath)) {
+            continue;
+        }
+        const parsed = readJsonFile(lockfilePath);
+        parsed.version = version;
+        if (parsed.packages?.[""]) {
+            parsed.packages[""].version = version;
+        }
+        writeJsonFile(lockfilePath, parsed);
+        updated.push(lockfile);
+    }
+    return updated;
+}
+exports.nodeVersionStrategy = {
+    name: "node",
+    getVersionFile(config) {
+        return config["version-file"] ?? "package.json";
+    },
+    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.`);
+        }
+        const packageJson = readJsonFile(versionPath);
+        if (!packageJson.version || typeof packageJson.version !== "string") {
+            throw new Error(`${versionFile} is missing a valid "version" field required by release-type "node".`);
+        }
+        return packageJson.version.trim();
+    },
+    writeVersion(cwd, config, version) {
+        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.`);
+        }
+        const packageJson = readJsonFile(versionPath);
+        if (!packageJson.version || typeof packageJson.version !== "string") {
+            throw new Error(`${versionFile} is missing a valid "version" field required by release-type "node".`);
+        }
+        packageJson.version = version;
+        writeJsonFile(versionPath, packageJson);
+        const updatedFiles = [
+            versionFile,
+            ...updateNodeLockfileVersion(cwd, version),
+        ];
+        return updatedFiles;
+    },
+};

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

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

package/dist/domain/strategy/r.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rVersionStrategy = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function readDescriptionVersion(content, versionFile) {
+    const match = content.match(/^Version:\s*(.+)\s*$/mu);
+    if (!match || !match[1]) {
+        throw new Error(`${versionFile} is missing a valid "Version:" field required by release-type "r".`);
+    }
+    return match[1].trim();
+}
+function writeDescriptionVersion(content, versionFile, version) {
+    if (!/^Version:\s*/mu.test(content)) {
+        throw new Error(`${versionFile} is missing a valid "Version:" field required by release-type "r".`);
+    }
+    return content.replace(/^Version:\s*.*$/mu, `Version: ${version}`);
+}
+exports.rVersionStrategy = {
+    name: "r",
+    getVersionFile(config) {
+        return config["version-file"] ?? "DESCRIPTION";
+    },
+    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 readDescriptionVersion(node_fs_1.default.readFileSync(versionPath, "utf8"), versionFile);
+    },
+    writeVersion(cwd, config, version) {
+        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.`);
+        }
+        const existing = node_fs_1.default.readFileSync(versionPath, "utf8");
+        const updated = writeDescriptionVersion(existing, versionFile, version);
+        node_fs_1.default.writeFileSync(versionPath, updated, "utf8");
+        return [versionFile];
+    },
+};

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,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveVersionStrategy = resolveVersionStrategy;
+const node_js_1 = require("./node.js");
+const r_js_1 = require("./r.js");
+const rust_js_1 = require("./rust.js");
+const simple_js_1 = require("./simple.js");
+function resolveVersionStrategy(config) {
+    if (config["release-type"] === "node") {
+        return node_js_1.nodeVersionStrategy;
+    }
+    if (config["release-type"] === "rust") {
+        return rust_js_1.rustVersionStrategy;
+    }
+    if (config["release-type"] === "r") {
+        return r_js_1.rVersionStrategy;
+    }
+    return simple_js_1.simpleVersionStrategy;
+}

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

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

package/dist/domain/strategy/rust.js

@@ -0,0 +1,369 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rustVersionStrategy = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const toml_1 = __importDefault(require("@iarna/toml"));
+const ROOT_DEPENDENCY_SECTIONS = new Set([
+    "dependencies",
+    "dev-dependencies",
+    "build-dependencies",
+]);
+function normalizeSlashPath(input) {
+    return input.replaceAll("\\", "/");
+}
+function hasGlobPattern(pattern) {
+    return /[*?]/u.test(pattern);
+}
+function escapeRegex(input) {
+    return input.replace(/[.+^${}()|\\]/gu, "\\$&");
+}
+function globToRegex(pattern) {
+    const normalized = normalizeSlashPath(pattern);
+    let source = "^";
+    for (let index = 0; index < normalized.length; index += 1) {
+        const current = normalized[index] ?? "";
+        const next = normalized[index + 1] ?? "";
+        if (current === "*" && next === "*") {
+            source += ".*";
+            index += 1;
+            continue;
+        }
+        if (current === "*") {
+            source += "[^/]*";
+            continue;
+        }
+        if (current === "?") {
+            source += "[^/]";
+            continue;
+        }
+        source += escapeRegex(current);
+    }
+    source += "$";
+    return new RegExp(source, "u");
+}
+function findCargoManifestDirectories(rootDir) {
+    const results = new Set();
+    const queue = [rootDir];
+    while (queue.length > 0) {
+        const currentDir = queue.shift();
+        if (!currentDir) {
+            continue;
+        }
+        const entries = node_fs_1.default.readdirSync(currentDir, {
+            withFileTypes: true,
+        });
+        let hasCargoManifest = false;
+        for (const entry of entries) {
+            const fullPath = node_path_1.default.join(currentDir, entry.name);
+            if (entry.isFile() && entry.name === "Cargo.toml") {
+                hasCargoManifest = true;
+                continue;
+            }
+            if (entry.isDirectory()) {
+                queue.push(fullPath);
+            }
+        }
+        if (hasCargoManifest) {
+            const rel = normalizeSlashPath(node_path_1.default.relative(rootDir, currentDir));
+            results.add(rel === "" ? "." : rel);
+        }
+    }
+    return [...results].sort((a, b) => a.localeCompare(b));
+}
+function parseCargoManifest(versionFile, cargoTomlRaw) {
+    let parsed;
+    try {
+        parsed = toml_1.default.parse(cargoTomlRaw);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to parse ${versionFile}: ${message}`);
+    }
+    const parsedRecord = parsed;
+    const packageTable = parsedRecord.package && typeof parsedRecord.package === "object"
+        ? parsedRecord.package
+        : null;
+    const workspaceTable = parsedRecord.workspace && typeof parsedRecord.workspace === "object"
+        ? parsedRecord.workspace
+        : null;
+    return { packageTable, workspaceTable };
+}
+function isCrateManifest(versionFile, cargoTomlRaw) {
+    const parsed = parseCargoManifest(versionFile, cargoTomlRaw);
+    return parsed.packageTable !== null;
+}
+function readWorkspaceMemberPatterns(workspaceTable) {
+    if (!workspaceTable) {
+        return [];
+    }
+    const members = workspaceTable.members;
+    if (!Array.isArray(members)) {
+        return [];
+    }
+    return members
+        .filter((member) => typeof member === "string")
+        .map((member) => normalizeSlashPath(member.trim()))
+        .filter((member) => member.length > 0);
+}
+function readWorkspaceExcludes(workspaceTable) {
+    if (!workspaceTable) {
+        return [];
+    }
+    const excludes = workspaceTable.exclude;
+    if (!Array.isArray(excludes)) {
+        return [];
+    }
+    return excludes
+        .filter((entry) => typeof entry === "string")
+        .map((entry) => normalizeSlashPath(entry.trim()))
+        .filter((entry) => entry.length > 0);
+}
+function resolveWorkspaceMemberManifests(rootDir, workspaceTable) {
+    const memberPatterns = readWorkspaceMemberPatterns(workspaceTable);
+    if (memberPatterns.length === 0) {
+        return [];
+    }
+    const excludes = readWorkspaceExcludes(workspaceTable);
+    const excludeRegexes = excludes.map((pattern) => globToRegex(pattern));
+    const cargoDirs = findCargoManifestDirectories(rootDir);
+    const manifests = new Set();
+    for (const pattern of memberPatterns) {
+        if (hasGlobPattern(pattern)) {
+            const regex = globToRegex(pattern);
+            for (const dir of cargoDirs) {
+                if (regex.test(dir)) {
+                    manifests.add(normalizeSlashPath(node_path_1.default.posix.join(dir, "Cargo.toml")));
+                }
+            }
+            continue;
+        }
+        const candidateDir = normalizeSlashPath(pattern);
+        if (excludeRegexes.some((regex) => regex.test(candidateDir))) {
+            continue;
+        }
+        const cargoPath = node_path_1.default.join(rootDir, candidateDir, "Cargo.toml");
+        if (node_fs_1.default.existsSync(cargoPath)) {
+            manifests.add(normalizeSlashPath(node_path_1.default.posix.join(candidateDir, "Cargo.toml")));
+        }
+    }
+    const filtered = [...manifests].filter((manifestPath) => {
+        const dir = normalizeSlashPath(node_path_1.default.posix.dirname(manifestPath));
+        return !excludeRegexes.some((regex) => regex.test(dir));
+    });
+    return filtered.sort((a, b) => a.localeCompare(b));
+}
+function collectRustTargetManifests(cwd, versionFile) {
+    if (node_path_1.default.basename(versionFile) !== "Cargo.toml") {
+        throw new Error(`Rust strategy requires "version-file" to point to a Cargo.toml manifest (received "${versionFile}").`);
+    }
+    const rootManifestPath = node_path_1.default.join(cwd, versionFile);
+    if (!node_fs_1.default.existsSync(rootManifestPath)) {
+        throw new Error(`Versionary requires ${versionFile} to exist.`);
+    }
+    const rootRaw = node_fs_1.default.readFileSync(rootManifestPath, "utf8");
+    const parsedRoot = parseCargoManifest(versionFile, rootRaw);
+    const rootIsCrate = parsedRoot.packageTable !== null;
+    const rootDir = node_path_1.default.dirname(rootManifestPath);
+    const workspaceMembers = resolveWorkspaceMemberManifests(rootDir, parsedRoot.workspaceTable);
+    if (rootIsCrate) {
+        const relRoot = normalizeSlashPath(node_path_1.default.relative(cwd, rootManifestPath));
+        return [...new Set([relRoot, ...workspaceMembers])].sort((a, b) => a.localeCompare(b));
+    }
+    if (workspaceMembers.length > 0) {
+        return workspaceMembers;
+    }
+    throw new Error(`Configured rust target "${versionFile}" is not a Rust crate manifest. Expected [package].version or [workspace].members with crate Cargo.toml files.`);
+}
+function readCargoVersion(cargoTomlRaw, versionFile) {
+    const { packageTable } = parseCargoManifest(versionFile, cargoTomlRaw);
+    if (!packageTable || typeof packageTable !== "object") {
+        throw new Error(`${versionFile} is missing [package].version. Add [package] with a SemVer version.`);
+    }
+    const rawVersion = packageTable.version;
+    if (rawVersion === undefined) {
+        throw new Error(`${versionFile} is missing [package].version. Add [package] with a SemVer version.`);
+    }
+    if (typeof rawVersion !== "string" || rawVersion.trim().length === 0) {
+        throw new Error(`${versionFile} has invalid [package].version. Expected a non-empty SemVer string.`);
+    }
+    return rawVersion.trim();
+}
+function readCargoPackageName(cargoTomlRaw, versionFile) {
+    const { packageTable } = parseCargoManifest(versionFile, cargoTomlRaw);
+    if (!packageTable || typeof packageTable !== "object") {
+        throw new Error(`${versionFile} is missing [package].name. Add [package] with a crate name.`);
+    }
+    const rawName = packageTable.name;
+    if (typeof rawName !== "string" || rawName.trim().length === 0) {
+        throw new Error(`${versionFile} has invalid [package].name. Expected a non-empty crate name.`);
+    }
+    return rawName.trim();
+}
+function writeCargoVersion(cargoTomlRaw, versionFile, version) {
+    const lineEnding = cargoTomlRaw.includes("\r\n") ? "\r\n" : "\n";
+    const hasFinalLineEnding = cargoTomlRaw.endsWith("\n") || cargoTomlRaw.endsWith("\r\n");
+    const lines = cargoTomlRaw.split(/\r?\n/u);
+    let inPackageSection = false;
+    let foundPackageSection = false;
+    let replacedVersion = false;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        const sectionMatch = line.match(/^\s*\[([^\]]+)\]\s*(?:#.*)?$/u);
+        if (sectionMatch) {
+            const section = sectionMatch[1]?.trim();
+            inPackageSection = section === "package";
+            if (inPackageSection) {
+                foundPackageSection = true;
+            }
+            continue;
+        }
+        if (!inPackageSection) {
+            continue;
+        }
+        const versionMatch = line.match(/^(\s*version\s*=\s*)(["'])([^"']*)(\2)(\s*(?:#.*)?)?$/u);
+        if (!versionMatch) {
+            continue;
+        }
+        const [, prefix = "", quote = '"', , , suffix = ""] = versionMatch;
+        lines[index] = `${prefix}${quote}${version}${quote}${suffix}`;
+        replacedVersion = true;
+        break;
+    }
+    if (!foundPackageSection) {
+        throw new Error(`${versionFile} is missing [package].version. Add [package] with a SemVer version.`);
+    }
+    if (!replacedVersion) {
+        throw new Error(`${versionFile} is missing [package].version. Add [package] with a SemVer version.`);
+    }
+    let updated = lines.join(lineEnding);
+    if (hasFinalLineEnding && !updated.endsWith(lineEnding)) {
+        updated += lineEnding;
+    }
+    if (!hasFinalLineEnding && updated.endsWith(lineEnding)) {
+        updated = updated.slice(0, -lineEnding.length);
+    }
+    return updated;
+}
+function isDependencySection(section) {
+    if (ROOT_DEPENDENCY_SECTIONS.has(section)) {
+        return true;
+    }
+    if (!section.startsWith("target.")) {
+        return false;
+    }
+    return (section.endsWith(".dependencies") ||
+        section.endsWith(".dev-dependencies") ||
+        section.endsWith(".build-dependencies"));
+}
+function parseDependencyName(line) {
+    const match = line.match(/^\s*(?:"([^"]+)"|'([^']+)'|([A-Za-z0-9_-]+))\s*=/u);
+    return match?.[1] ?? match?.[2] ?? match?.[3] ?? null;
+}
+function writeInternalDependencyVersionInLine(line, dependencyName, internalCrates, version) {
+    if (!internalCrates.has(dependencyName)) {
+        return line;
+    }
+    const stringVersionMatch = line.match(/^(\s*(?:"[^"]+"|'[^']+'|[A-Za-z0-9_-]+)\s*=\s*)(["'])([^"']*)(\2)(\s*(?:#.*)?)?$/u);
+    if (stringVersionMatch) {
+        const [, prefix = "", quote = '"', , , suffix = ""] = stringVersionMatch;
+        return `${prefix}${quote}${version}${quote}${suffix}`;
+    }
+    const inlineTableMatch = line.match(/^(\s*(?:"[^"]+"|'[^']+'|[A-Za-z0-9_-]+)\s*=\s*\{)(.*)(\}\s*(?:#.*)?)$/u);
+    if (!inlineTableMatch) {
+        return line;
+    }
+    const [, prefix = "", tableBody = "", suffix = ""] = inlineTableMatch;
+    const updatedTableBody = tableBody.replace(/(\bversion\s*=\s*)(["'])([^"']*)(\2)/u, `$1$2${version}$4`);
+    if (updatedTableBody === tableBody) {
+        return line;
+    }
+    return `${prefix}${updatedTableBody}${suffix}`;
+}
+function writeInternalDependencyVersions(cargoTomlRaw, internalCrates, version) {
+    if (internalCrates.size === 0) {
+        return cargoTomlRaw;
+    }
+    const lineEnding = cargoTomlRaw.includes("\r\n") ? "\r\n" : "\n";
+    const hasFinalLineEnding = cargoTomlRaw.endsWith("\n") || cargoTomlRaw.endsWith("\r\n");
+    const lines = cargoTomlRaw.split(/\r?\n/u);
+    let currentSection = null;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        const sectionMatch = line.match(/^\s*\[([^\]]+)\]\s*(?:#.*)?$/u);
+        if (sectionMatch) {
+            currentSection = sectionMatch[1]?.trim() ?? null;
+            continue;
+        }
+        if (!currentSection || !isDependencySection(currentSection)) {
+            continue;
+        }
+        const dependencyName = parseDependencyName(line);
+        if (!dependencyName) {
+            continue;
+        }
+        lines[index] = writeInternalDependencyVersionInLine(line, dependencyName, internalCrates, version);
+    }
+    let updated = lines.join(lineEnding);
+    if (hasFinalLineEnding && !updated.endsWith(lineEnding)) {
+        updated += lineEnding;
+    }
+    if (!hasFinalLineEnding && updated.endsWith(lineEnding)) {
+        updated = updated.slice(0, -lineEnding.length);
+    }
+    return updated;
+}
+exports.rustVersionStrategy = {
+    name: "rust",
+    getVersionFile(config) {
+        return config["version-file"] ?? "Cargo.toml";
+    },
+    readVersion(cwd, config) {
+        const versionFile = this.getVersionFile(config);
+        const manifests = collectRustTargetManifests(cwd, versionFile);
+        const selectedManifest = manifests[0];
+        if (!selectedManifest) {
+            throw new Error(`Configured rust target "${versionFile}" did not resolve to a Rust crate manifest.`);
+        }
+        const cargoTomlRaw = node_fs_1.default.readFileSync(node_path_1.default.join(cwd, selectedManifest), "utf8");
+        return readCargoVersion(cargoTomlRaw, selectedManifest);
+    },
+    writeVersion(cwd, config, version) {
+        const versionFile = this.getVersionFile(config);
+        const manifests = collectRustTargetManifests(cwd, versionFile);
+        const updatedFiles = [];
+        const internalCrates = new Set();
+        for (const manifest of manifests) {
+            const versionPath = node_path_1.default.join(cwd, manifest);
+            if (!node_fs_1.default.existsSync(versionPath)) {
+                continue;
+            }
+            const cargoTomlRaw = node_fs_1.default.readFileSync(versionPath, "utf8");
+            if (!isCrateManifest(manifest, cargoTomlRaw)) {
+                continue;
+            }
+            internalCrates.add(readCargoPackageName(cargoTomlRaw, manifest));
+        }
+        for (const manifest of manifests) {
+            const versionPath = node_path_1.default.join(cwd, manifest);
+            if (!node_fs_1.default.existsSync(versionPath)) {
+                continue;
+            }
+            const cargoTomlRaw = node_fs_1.default.readFileSync(versionPath, "utf8");
+            if (!isCrateManifest(manifest, cargoTomlRaw)) {
+                continue;
+            }
+            readCargoVersion(cargoTomlRaw, manifest);
+            const updatedCargoToml = writeInternalDependencyVersions(writeCargoVersion(cargoTomlRaw, manifest, version), internalCrates, version);
+            node_fs_1.default.writeFileSync(versionPath, updatedCargoToml, "utf8");
+            updatedFiles.push(manifest);
+        }
+        if (updatedFiles.length === 0) {
+            throw new Error(`Configured rust target "${versionFile}" did not resolve to a Rust crate manifest to update.`);
+        }
+        return updatedFiles.sort((a, b) => a.localeCompare(b));
+    },
+};

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;