versionary 0.11.1 → 0.13.0

package/dist/{app/release → release}/release.js

@@ -3,68 +3,107 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractReleaseNotes = extractReleaseNotes;
 exports.resolveTargetChangelogFile = resolveTargetChangelogFile;
+exports.runRelease = runRelease;
+exports.runReleaseDetailed = runReleaseDetailed;
 exports.runSimpleRelease = runSimpleRelease;
 exports.runSimpleReleaseDetailed = runSimpleReleaseDetailed;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const load_config_js_1 = require("../../config/load-config.js");
-const resolve_js_1 = require("../../domain/strategy/resolve.js");
-const capabilities_js_1 = require("../../plugins/capabilities.js");
-const runtime_js_1 = require("../../plugins/runtime.js");
+const load_config_js_1 = require("../config/load-config.js");
+const client_js_1 = require("../scm/client.js");
+const resolve_js_1 = require("../strategy/resolve.js");
+const plan_js_1 = require("./plan.js");
 const pr_js_1 = require("./pr.js");
 const recovery_js_1 = require("./recovery.js");
 const state_js_1 = require("./state.js");
-function getHeadCommitMessage(cwd) {
-    return (0, node_child_process_1.execFileSync)("git", ["log", "-1", "--pretty=%B"], {
-        cwd,
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
+function escapeRegExp(input) {
+    return input.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
 }
-function readReleaseNotes(cwd, version, changelogFile) {
-    const changelogPath = node_path_1.default.join(cwd, changelogFile);
-    if (!node_fs_1.default.existsSync(changelogPath)) {
-        return `Automated release for v${version}`;
-    }
-    const content = node_fs_1.default.readFileSync(changelogPath, "utf8");
+function extractReleaseNotes(content, version, changelogFormat) {
     const lines = content.split("\n");
-    const start = lines.findIndex((line) => line.startsWith(`## ${version} -`) || line.startsWith(`## [${version}](`));
+    const shortVersion = version.replace(/\.\d+$/u, "");
+    const start = changelogFormat === "r-news"
+        ? lines.findIndex((line) => {
+            const fullMatch = new RegExp(`^#\\s+.+\\s+${escapeRegExp(version)}\\s*$`, "u");
+            const shortMatch = new RegExp(`^#\\s+.+\\s+${escapeRegExp(shortVersion)}\\s*$`, "u");
+            return fullMatch.test(line) || shortMatch.test(line);
+        })
+        : lines.findIndex((line) => line.startsWith(`## ${version} -`) ||
+            line.startsWith(`## [${version}](`) ||
+            line.startsWith(`# ${shortVersion} -`) ||
+            line.startsWith(`# [${shortVersion}](`) ||
+            new RegExp(`^#\\s+.+\\s+${shortVersion}\\s*$`, "u").test(line));
     if (start < 0) {
-        return `Automated release for v${version}`;
+        return "";
     }
     let end = lines.length;
     for (let idx = start + 1; idx < lines.length; idx += 1) {
-        if (lines[idx]?.startsWith("## ")) {
+        const line = lines[idx] ?? "";
+        if (changelogFormat === "r-news") {
+            if (/^#(?!#)\s+/u.test(line)) {
+                end = idx;
+                break;
+            }
+            continue;
+        }
+        if (line.startsWith("## ")) {
             end = idx;
             break;
         }
     }
-    const notes = lines
+    return lines
         .slice(start + 1, end)
         .join("\n")
         .trim();
+}
+function getHeadCommitMessage(cwd) {
+    return (0, node_child_process_1.execFileSync)("git", ["log", "-1", "--pretty=%B"], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+}
+function readReleaseNotes(cwd, version, changelogFile, changelogFormat) {
+    const changelogPath = node_path_1.default.join(cwd, changelogFile);
+    if (!node_fs_1.default.existsSync(changelogPath)) {
+        return `Automated release for v${version}`;
+    }
+    const content = node_fs_1.default.readFileSync(changelogPath, "utf8");
+    const notes = extractReleaseNotes(content, version, changelogFormat);
     return notes.length > 0 ? notes : `Automated release for v${version}`;
 }
 function resolveTargetChangelogFile(config, rootChangelogFile, targetPath) {
     if (targetPath === ".") {
         return rootChangelogFile;
     }
-    const packageChangelogFile = config.packages?.[targetPath]?.["changelog-file"];
-    if (!packageChangelogFile) {
-        return rootChangelogFile;
-    }
+    const packageConfig = config.packages?.[targetPath];
+    const { changelogFile: packageChangelogFile } = (0, plan_js_1.getChangelogDefaults)({
+        "release-type": packageConfig?.["release-type"] ?? config["release-type"],
+        "changelog-file": packageConfig?.["changelog-file"] ?? config["changelog-file"],
+        "changelog-format": packageConfig?.["changelog-format"] ?? config["changelog-format"],
+    });
     return node_path_1.default.posix.join(targetPath, packageChangelogFile);
 }
-async function runSimpleRelease(cwd = process.cwd()) {
-    const result = await runSimpleReleaseDetailed(cwd, { logger: console });
+function resolveTargetChangelogFormat(config, targetPath) {
+    const packageConfig = targetPath === "." ? undefined : config.packages?.[targetPath];
+    const { changelogFormat } = (0, plan_js_1.getChangelogDefaults)({
+        "release-type": packageConfig?.["release-type"] ?? config["release-type"],
+        "changelog-file": packageConfig?.["changelog-file"] ?? config["changelog-file"],
+        "changelog-format": packageConfig?.["changelog-format"] ?? config["changelog-format"],
+    });
+    return changelogFormat;
+}
+async function runRelease(cwd = process.cwd()) {
+    const result = await runReleaseDetailed(cwd, { logger: console });
     if (result.action === "release-skipped") {
         return result.reason;
     }
     return result.message;
 }
-async function runSimpleReleaseDetailed(cwd = process.cwd(), options = {}) {
+async function runReleaseDetailed(cwd = process.cwd(), options = {}) {
     const commitMessage = getHeadCommitMessage(cwd);
     if (!(0, pr_js_1.isReleaseCommitMessage)(commitMessage)) {
         return {
@@ -74,7 +113,7 @@ async function runSimpleReleaseDetailed(cwd = process.cwd(), options = {}) {
     }
     const loaded = (0, load_config_js_1.loadConfig)(cwd);
     const strategy = (0, resolve_js_1.resolveVersionStrategy)(loaded.config);
-    const changelogFile = loaded.config["changelog-file"] ?? "CHANGELOG.md";
+    const { changelogFile } = (0, plan_js_1.getChangelogDefaults)(loaded.config);
     const version = strategy.readVersion(cwd, loaded.config);
     const defaultTag = `v${version}`;
     const releaseTargets = (0, state_js_1.readReleaseTargets)(cwd);
@@ -98,25 +137,18 @@ async function runSimpleReleaseDetailed(cwd = process.cwd(), options = {}) {
             message: `Dry run: would publish releases ${targetList.join(", ")}`,
         };
     }
-    const plugins = (0, runtime_js_1.loadRuntimePlugins)();
-    const scmPlugins = (0, capabilities_js_1.findPluginsByCapability)(plugins, "scm.releaseMetadata");
-    if (scmPlugins.length === 0) {
-        throw new Error("No scm.releaseMetadata plugin is available.");
-    }
-    const plugin = scmPlugins[0];
-    if (!plugin?.createReleaseMetadata) {
-        throw new Error(`Plugin "${plugin?.name ?? "unknown"}" does not implement createReleaseMetadata.`);
-    }
-    const createReleaseMetadata = plugin.createReleaseMetadata;
+    const scmClient = (0, client_js_1.getScmClient)();
     const releases = [];
     for (const target of targets) {
         const targetChangelogFile = resolveTargetChangelogFile(loaded.config, changelogFile, target.path);
+        const targetChangelogFormat = resolveTargetChangelogFormat(loaded.config, target.path);
         const outcome = await (0, recovery_js_1.executeIdempotentReleaseTarget)(cwd, {
             tag: target.tag,
             version: target.version,
-            notes: readReleaseNotes(cwd, target.version, targetChangelogFile),
+            notes: readReleaseNotes(cwd, target.version, targetChangelogFile, targetChangelogFormat),
+            draft: loaded.config["release-draft"] ?? false,
         }, {
-            createReleaseMetadata: (input) => createReleaseMetadata(input, {
+            createReleaseMetadata: (input) => scmClient.createReleaseMetadata(input, {
                 cwd,
                 logger: options.logger,
             }),
@@ -136,3 +168,11 @@ async function runSimpleReleaseDetailed(cwd = process.cwd(), options = {}) {
         message: `Published releases ${published.join(", ")}`,
     };
 }
+/** @deprecated Use runRelease. */
+async function runSimpleRelease(cwd = process.cwd()) {
+    return runRelease(cwd);
+}
+/** @deprecated Use runReleaseDetailed. */
+async function runSimpleReleaseDetailed(cwd = process.cwd(), options = {}) {
+    return runReleaseDetailed(cwd, options);
+}

package/dist/{domain/release → release}/semver.js

@@ -5,10 +5,21 @@ 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;
+const COMPAT_DOTTED_PRERELEASE_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/u;
+function normalizeVersionInput(version) {
+    const trimmed = version.trim();
+    const compatMatch = trimmed.match(COMPAT_DOTTED_PRERELEASE_PATTERN);
+    if (!compatMatch) {
+        return trimmed;
+    }
+    const [, major, minor, patch, prerelease] = compatMatch;
+    return `${major}.${minor}.${patch}-${prerelease}`;
+}
 function parseVersion(version) {
-    const match = version.trim().match(SEMVER_PATTERN);
+    const normalized = normalizeVersionInput(version);
+    const match = normalized.match(SEMVER_PATTERN);
     if (!match) {
-        throw new Error(`Invalid version in version file: "${version}". Expected SemVer 2.0.0 format.`);
+        throw new Error(`Invalid version in version file: "${version}". Expected SemVer 2.0.0 format (or compatibility form X.Y.Z.W).`);
     }
     return {
         major: Number(match[1]),
@@ -19,7 +30,7 @@ function parseVersion(version) {
     };
 }
 function isValidVersion(version) {
-    return SEMVER_PATTERN.test(version.trim());
+    return SEMVER_PATTERN.test(normalizeVersionInput(version));
 }
 function isNumericIdentifier(identifier) {
     return /^(0|[1-9]\d*)$/u.test(identifier);

package/dist/{app/release → release}/state.js

@@ -10,7 +10,7 @@ exports.writeBaselineSha = writeBaselineSha;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const load_config_js_1 = require("../../config/load-config.js");
+const load_config_js_1 = require("../config/load-config.js");
 const MANIFEST_VERSION_KEY = "manifest-version";
 const BASELINE_SHA_KEY = "baseline-sha";
 const RELEASE_TARGETS_KEY = "release-targets";

package/dist/{verify → release}/verify-project.js

@@ -7,8 +7,8 @@ exports.verifyProject = verifyProject;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const load_config_js_1 = require("../config/load-config.js");
-const package_context_js_1 = require("../domain/strategy/package-context.js");
-const resolve_js_1 = require("../domain/strategy/resolve.js");
+const package_context_js_1 = require("../strategy/package-context.js");
+const resolve_js_1 = require("../strategy/resolve.js");
 function verifyProject(cwd = process.cwd()) {
     const checks = [];
     const config = (0, load_config_js_1.loadConfig)(cwd);

package/dist/scm/client.d.ts

@@ -0,0 +1,2 @@
+import type { ScmClient } from "./types.js";
+export declare function getScmClient(): ScmClient;

package/dist/scm/client.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScmClient = getScmClient;
+const github_plugin_js_1 = require("./github-plugin.js");
+function getScmClient() {
+    return (0, github_plugin_js_1.createGitHubPlugin)();
+}

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

@@ -1,2 +1,3 @@
 import type { VersionaryPluginRuntime } from "../types/plugins.js";
-export declare function createGitHubPlugin(): VersionaryPluginRuntime;
+import type { ScmClient } from "./types.js";
+export declare function createGitHubPlugin(): VersionaryPluginRuntime & ScmClient;

package/dist/scm/github-plugin.js

@@ -90,6 +90,7 @@ function createGitHubPlugin() {
     return {
         name: "github",
         capabilities: ["scm.reviewRequest", "scm.releaseMetadata"],
+        provider: "github",
         async createOrUpdateReviewRequest(input, _context) {
             const repo = getRepoFromEnv();
             const octokit = new rest_1.Octokit({ auth: getGitHubToken() });
@@ -194,6 +195,7 @@ function createGitHubPlugin() {
                     tag_name: input.tag,
                     name: input.tag,
                     body: input.notes,
+                    draft: input.draft ?? false,
                 });
                 data = response.data;
             }

package/dist/scm/types.d.ts

@@ -0,0 +1,37 @@
+export type ScmProvider = "github";
+export interface ScmClientContext {
+    cwd: string;
+    logger?: {
+        info: (message: string) => void;
+        warn: (message: string) => void;
+        error: (message: string) => void;
+    };
+}
+export interface ScmReviewRequestInput {
+    baseBranch: string;
+    headBranch: string;
+    title: string;
+    body: string;
+    labels?: string[];
+}
+export interface ScmReviewRequestResult {
+    id: string;
+    number?: number;
+    url: string;
+    state: "open" | "closed" | "merged";
+}
+export interface ScmReleaseMetadataInput {
+    tag: string;
+    version: string;
+    notes: string;
+    draft?: boolean;
+}
+export interface ScmReleaseMetadataResult {
+    url: string;
+    status?: "created" | "exists";
+}
+export interface ScmClient {
+    provider: ScmProvider;
+    createOrUpdateReviewRequest: (input: ScmReviewRequestInput, context: ScmClientContext) => Promise<ScmReviewRequestResult>;
+    createReleaseMetadata: (input: ScmReleaseMetadataInput, context: ScmClientContext) => Promise<ScmReleaseMetadataResult>;
+}

package/dist/{domain/strategy → strategy}/node.js

@@ -64,4 +64,17 @@ exports.nodeVersionStrategy = {
         ];
         return updatedFiles;
     },
+    readPackageName(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);
+        const name = packageJson.name;
+        if (typeof name !== "string" || name.trim().length === 0) {
+            return null;
+        }
+        return name.trim();
+    },
 };

package/dist/{domain/strategy → strategy}/package-context.d.ts

@@ -1,4 +1,4 @@
-import type { VersionaryConfig, VersionaryPackage } from "../../types/config.js";
+import type { VersionaryConfig, VersionaryPackage } from "../types/config.js";
 import type { VersionStrategy } from "./types.js";
 export declare function resolvePackageStrategyContext(rootConfig: VersionaryConfig, packagePath: string, packageConfig: VersionaryPackage): {
     strategy: VersionStrategy;

package/dist/{domain/strategy → strategy}/package-context.js

@@ -34,7 +34,7 @@ function resolvePackageStrategyContext(rootConfig, packagePath, packageConfig) {
                 }));
         const config = withVersionFile({
             ...baseConfig,
-            packages: undefined,
+            packages: packagePath === "." ? baseConfig.packages : undefined,
         }, versionFile);
         return {
             strategy: baseStrategy,
@@ -50,7 +50,7 @@ function resolvePackageStrategyContext(rootConfig, packagePath, packageConfig) {
         }));
     const config = withVersionFile({
         ...baseConfig,
-        packages: undefined,
+        packages: packagePath === "." ? baseConfig.packages : undefined,
     }, packageVersionFile);
     const strategy = (0, resolve_js_1.resolveVersionStrategy)(config);
     return {

package/dist/{domain/strategy → strategy}/r.js

@@ -43,4 +43,18 @@ exports.rVersionStrategy = {
         node_fs_1.default.writeFileSync(versionPath, updated, "utf8");
         return [versionFile];
     },
+    readPackageName(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 content = node_fs_1.default.readFileSync(versionPath, "utf8");
+        const match = content.match(/^Package:\s*(.+)\s*$/mu);
+        if (!match?.[1]) {
+            return null;
+        }
+        const name = match[1].trim();
+        return name.length > 0 ? name : null;
+    },
 };

package/dist/{domain/strategy → strategy}/resolve.d.ts

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

package/dist/strategy/resolve.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listKnownReleaseTypes = listKnownReleaseTypes;
+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");
+const strategyRegistry = {
+    simple: simple_js_1.simpleVersionStrategy,
+    node: node_js_1.nodeVersionStrategy,
+    rust: rust_js_1.rustVersionStrategy,
+    r: r_js_1.rVersionStrategy,
+};
+function listKnownReleaseTypes() {
+    return Object.keys(strategyRegistry).sort((a, b) => a.localeCompare(b));
+}
+function resolveVersionStrategy(config) {
+    const releaseType = config["release-type"] ?? "simple";
+    return strategyRegistry[releaseType] ?? simple_js_1.simpleVersionStrategy;
+}

package/dist/{domain/strategy → strategy}/rust.js

@@ -613,4 +613,46 @@ exports.rustVersionStrategy = {
         }
         return updatedFiles.sort((a, b) => a.localeCompare(b));
     },
+    readPackageName(cwd, config) {
+        const versionFile = this.getVersionFile(config);
+        const manifests = collectRustTargetManifests(cwd, versionFile, !config.packages);
+        const selectedManifest = manifests[0];
+        if (!selectedManifest) {
+            throw new Error(`Configured rust target "${versionFile}" did not resolve to a Rust crate manifest.`);
+        }
+        const versionPath = node_path_1.default.join(cwd, selectedManifest);
+        if (!node_fs_1.default.existsSync(versionPath)) {
+            throw new Error(`Versionary requires ${selectedManifest} to exist.`);
+        }
+        const cargoTomlRaw = node_fs_1.default.readFileSync(versionPath, "utf8");
+        if (!isCrateManifest(selectedManifest, cargoTomlRaw)) {
+            return null;
+        }
+        return readCargoPackageName(cargoTomlRaw, selectedManifest);
+    },
+    propagateDependentPatchImpacts(cwd, packages) {
+        const manifestToVersion = {};
+        const candidateManifests = [];
+        const manifestToPath = new Map();
+        for (const pkg of packages) {
+            const manifest = pkg.versionFile;
+            candidateManifests.push(manifest);
+            manifestToPath.set(manifest, pkg.packagePath);
+            if (pkg.nextVersion) {
+                manifestToVersion[manifest] = pkg.nextVersion;
+            }
+        }
+        const impactedManifests = detectRustDependencyImpact(cwd, manifestToVersion, candidateManifests);
+        return impactedManifests
+            .map((manifest) => manifestToPath.get(manifest))
+            .filter((pkgPath) => Boolean(pkgPath))
+            .sort((a, b) => a.localeCompare(b));
+    },
+    finalizeVersionWrites(cwd, writes) {
+        const manifestToVersion = {};
+        for (const write of writes) {
+            manifestToVersion[write.versionFile] = write.version;
+        }
+        return applyRustWorkspaceDependencyUpdates(cwd, manifestToVersion);
+    },
 };

package/dist/strategy/types.d.ts

@@ -0,0 +1,21 @@
+import type { VersionaryConfig } from "../types/config.js";
+export interface StrategyPackagePlanContext {
+    packagePath: string;
+    versionFile: string;
+    currentVersion: string;
+    nextVersion: string | null;
+}
+export interface StrategyVersionWriteContext {
+    packagePath: string;
+    versionFile: string;
+    version: string;
+}
+export interface VersionStrategy {
+    name: string;
+    getVersionFile(config: VersionaryConfig): string;
+    readVersion(cwd: string, config: VersionaryConfig): string;
+    writeVersion(cwd: string, config: VersionaryConfig, version: string): string[];
+    readPackageName?(cwd: string, config: VersionaryConfig): string | null;
+    propagateDependentPatchImpacts?(cwd: string, packages: StrategyPackagePlanContext[]): string[];
+    finalizeVersionWrites?(cwd: string, writes: StrategyVersionWriteContext[]): string[];
+}

package/dist/types/config.d.ts

@@ -1,4 +1,5 @@
 export type ConfigFileFormat = "jsonc" | "json" | "toml" | "js";
+export type VersionaryChangelogFormat = "markdown-changelog" | "r-news";
 export interface VersionaryArtifactRule {
     type: "json" | "toml" | "yaml" | "regex";
     path: string;
@@ -10,6 +11,7 @@ export interface VersionaryPackage {
     "release-type"?: string;
     "package-name"?: string;
     "changelog-file"?: string;
+    "changelog-format"?: VersionaryChangelogFormat;
     "exclude-paths"?: string[];
     "extra-files"?: VersionaryArtifactRule[];
 }
@@ -18,6 +20,8 @@ export interface VersionaryConfig {
     "review-mode"?: "direct" | "pr" | "review";
     "version-file"?: string;
     "changelog-file"?: string;
+    "changelog-format"?: VersionaryChangelogFormat;
+    "release-draft"?: boolean;
     "release-branch"?: string;
     "baseline-file"?: string;
     "bootstrap-sha"?: string;

package/dist/types/plugins.d.ts

@@ -1,37 +1,14 @@
+import type { ScmClientContext, ScmProvider, ScmReleaseMetadataInput, ScmReleaseMetadataResult, ScmReviewRequestInput, ScmReviewRequestResult } from "../scm/types.js";
 export type VersionaryPluginCapability = "scm.reviewRequest" | "scm.releaseMetadata";
-export interface VersionaryScmReviewRequestInput {
-    baseBranch: string;
-    headBranch: string;
-    title: string;
-    body: string;
-    labels?: string[];
-}
-export interface VersionaryScmReviewRequestResult {
-    id: string;
-    number?: number;
-    url: string;
-    state: "open" | "closed" | "merged";
-}
-export interface VersionaryScmReleaseMetadataInput {
-    tag: string;
-    version: string;
-    notes: string;
-}
-export interface VersionaryScmReleaseMetadataResult {
-    url: string;
-    status?: "created" | "exists";
-}
-export interface VersionaryPluginContext {
-    cwd: string;
-    logger?: {
-        info: (message: string) => void;
-        warn: (message: string) => void;
-        error: (message: string) => void;
-    };
-}
+export type VersionaryScmReviewRequestInput = ScmReviewRequestInput;
+export type VersionaryScmReviewRequestResult = ScmReviewRequestResult;
+export type VersionaryScmReleaseMetadataInput = ScmReleaseMetadataInput;
+export type VersionaryScmReleaseMetadataResult = ScmReleaseMetadataResult;
+export type VersionaryPluginContext = ScmClientContext;
 export interface VersionaryPluginRuntime {
     name: string;
     capabilities: VersionaryPluginCapability[];
+    provider?: ScmProvider;
     createOrUpdateReviewRequest?: (input: VersionaryScmReviewRequestInput, context: VersionaryPluginContext) => Promise<VersionaryScmReviewRequestResult>;
     createReleaseMetadata?: (input: VersionaryScmReleaseMetadataInput, context: VersionaryPluginContext) => Promise<VersionaryScmReleaseMetadataResult>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "versionary",
-  "version": "0.11.1",
+  "version": "0.13.0",
   "description": "Automatic release framework based on conventional commits and semantic versioning",
   "keywords": [
     "releasing",

package/dist/app/release/artifact-rules.d.ts

@@ -1,3 +0,0 @@
-import type { SimplePlan } from "../../domain/release/plan.js";
-import type { VersionaryConfig } from "../../types/config.js";
-export declare function applyConfiguredArtifactRules(cwd: string, config: VersionaryConfig, plan: SimplePlan): string[];

package/dist/app/release/verify.d.ts

@@ -1,2 +0,0 @@
-export type { VerifyResult } from "../../verify/verify-project.js";
-export { verifyProject } from "../../verify/verify-project.js";

package/dist/app/release/verify.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifyProject = void 0;
-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/domain/release/changelog.d.ts

@@ -1,19 +0,0 @@
-import { type ParsedCommit } from "../../infra/git/commits.js";
-import type { SimplePlan } from "./plan.js";
-export declare function renderSimpleReleaseNotes(input: {
-    currentVersion: string;
-    nextVersion: string;
-    commits: ParsedCommit[];
-    cwd?: string;
-}, options?: {
-    includeFooter?: boolean;
-}): string;
-export declare function renderSimpleChangelog(plan: SimplePlan): string;
-export declare function renderPackageChangelogSection(input: {
-    currentVersion: string;
-    nextVersion: string;
-    commits: ParsedCommit[];
-    tagPrefix: string;
-    cwd?: string;
-}): string;
-export declare function prependChangelog(cwd: string, changelogFile: string, section: string): void;

package/dist/domain/release/plan.d.ts

@@ -1,21 +0,0 @@
-import { type ParsedCommit } from "../../infra/git/commits.js";
-import { type ReleaseType } from "./semver.js";
-export interface SimplePlan {
-    mode: "simple";
-    releaseType: ReleaseType;
-    currentVersion: string;
-    nextVersion: string | null;
-    versionFile: string;
-    changelogFile: string;
-    releaseBranchPrefix: string;
-    baselineSha: string | null;
-    commits: ParsedCommit[];
-    packages?: Array<{
-        path: string;
-        releaseType: ReleaseType;
-        currentVersion: string;
-        nextVersion: string | null;
-        commits: ParsedCommit[];
-    }>;
-}
-export declare function createSimplePlan(cwd?: string): SimplePlan;

package/dist/domain/strategy/resolve.js

@@ -1,19 +0,0 @@
-"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/types.d.ts

@@ -1,7 +0,0 @@
-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/infra/scm/github/plugin.d.ts

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