versionary 0.9.0 → 0.11.0

package/README.md

@@ -22,7 +22,7 @@ Versionary is being built to:
 
 - support both direct releases and release-PR-gated releases
 - work across repository types (Node, Rust, docs/LaTeX, etc.)
-- stay SCM-agnostic at the core, with integrations via plugin capabilities
+- stay SCM-agnostic at the core with built-in integration adapters
   (GitHub first; GitLab/Codeberg later)
 - keep a small, stable core with explicit extension points
 - handle trunk-based development and monorepo workflows cleanly
@@ -40,6 +40,7 @@ Out of scope (intentional):
 
 - publishing artifacts to language registries
 - replacing package-specific publish tooling
+- external/user-provided plugin loading
 
 Use your CI/CD platform for registry publishing, triggered from a created
 release/tag.
@@ -48,7 +49,7 @@ release/tag.
 
 Current implementation focuses on:
 
-- strategy-based version updates (`simple`, `node`)
+- strategy-based version updates (`simple`, `node`, `rust`, `r`)
 - release planning and changelog generation
 - review-mode vs direct-mode release flow
 - built-in GitHub SCM plugin capabilities
@@ -56,6 +57,40 @@ Current implementation focuses on:
 Planned/harder areas include deeper monorepo ergonomics, broader SCM coverage,
 and stronger failure recovery around release steps.
 
+## Adding a new release strategy
+
+Versionary is set up so new language strategies can be added internally without
+changing release orchestration. A new strategy should implement the
+`VersionStrategy` contract in `src/domain/strategy/types.ts` and be wired in
+`src/domain/strategy/resolve.ts`.
+
+Checklist for new strategies (for example `python`):
+
+- define strategy `name`
+- define `getVersionFile(config)` defaults and config override behavior
+- implement `readVersion(cwd, config)` with explicit malformed-file errors
+- implement `writeVersion(cwd, config, version)` returning deterministic updated
+  file paths
+- add release-name extraction support if package tags should derive from
+  language metadata (similar to Node/Rust/R)
+- add focused strategy tests for ecosystem-specific behavior and edge cases
+- add/extend strategy contract tests in `tests/strategy-contract.test.ts`
+- update schema/docs for new `release-type` behavior and defaults
+
+Current ecosystem policy defaults:
+
+- changelog source for publish:
+  - root target uses root `changelog-file`
+  - package target uses `packages.<path>.changelog-file` when configured, else
+    root `changelog-file`
+- lockfiles:
+  - Node strategy updates root `package-lock.json`/`npm-shrinkwrap.json` when
+    present
+  - Rust release PR prep refreshes all discovered `Cargo.lock` files
+- workspace/inheritance:
+  - Rust supports `version.workspace = true` via `[workspace.package].version`
+  - other strategies should document equivalent inheritance behavior explicitly
+
 ## Architecture layout (current migration)
 
 The repository is moving to explicit layered modules:
@@ -95,7 +130,7 @@ For a quick trial, use:
 - pre-1.0 policy defaults to conservative major handling: for `0.y.z`, breaking
   changes bump to `0.(y+1).0`; set `allow-stable-major: true` to allow explicit
   auto-transition to `1.0.0` on a breaking release
-- review mode (`review-mode`): `review` (PR/MR style) or `direct` (no review
+- review mode (`review-mode`): `pr` (PR/MR style) or `direct` (no review
   request)
 - optional monorepo planning with `monorepo-mode` and `packages`:
   - `independent` computes package bumps per path
@@ -176,7 +211,8 @@ Release planning is based on Conventional Commit parsing semantics:
 - recognizes breaking changes from `!` and `BREAKING CHANGE` / `BREAKING-CHANGE`
   footers
 - maps release impact as `feat => minor`, `fix|perf => patch`, breaking => major
-- treats `revert:` as non-releasable commits
+- treats `revert:` commits as patch-releasable by default (and major if marked
+  breaking, e.g. `revert!:` or `BREAKING CHANGE`)
 - suppresses commits that are reverted within the analyzed release window so
   they do not affect bump/changelog output
 - emits parser diagnostics for malformed headers/footers/references and
@@ -239,7 +275,8 @@ Minimum GitHub token/repo permissions for Versionary-managed metadata:
 
 `review-mode` behavior:
 
-- `review`: `pnpm run run` prepares/updates the release branch and creates or
+- `pr` (preferred; `review` is a backward-compatible alias): `pnpm run run`
+  prepares/updates the release branch and creates or
   updates a release PR
 - `direct`: `pnpm run run` prepares/updates the release branch and skips review
   request creation

package/dist/app/release/pr.js

@@ -235,7 +235,10 @@ function formatReleaseCommitTitle(releaseTargets) {
         return "chore(release): v0.0.0";
     }
     const tags = releaseTargets.map((target) => target.tag);
-    return `chore(release): ${tags.join(", ")}`;
+    if (tags.length === 1) {
+        return `chore(release): ${tags[0]}`;
+    }
+    return `chore(release): ${tags[0]} (+${tags.length - 1} more)`;
 }
 function prepareSimpleReleasePr(cwd = process.cwd(), options = {}) {
     const plan = (0, plan_js_1.createSimplePlan)(cwd);
@@ -374,14 +377,14 @@ function renderSimpleReviewRequestBody(version, previousVersion, commits, plan =
 }
 async function openOrUpdateSimpleReviewRequest(cwd, branch, title, version, previousVersion, commits, plan = null, options = {}) {
     const loaded = (0, load_config_js_1.loadConfig)(cwd);
-    const releaseFlow = loaded.config["review-mode"] ?? "direct";
-    if (releaseFlow !== "review") {
+    const releaseFlow = loaded.config["review-mode"] ?? "pr";
+    if (releaseFlow === "direct") {
         return "Release flow mode is direct; skipping review request creation.";
     }
     const plugins = (0, runtime_js_1.loadRuntimePlugins)();
     const scmPlugins = (0, capabilities_js_1.findPluginsByCapability)(plugins, "scm.reviewRequest");
     if (scmPlugins.length === 0) {
-        throw new Error("review-mode is review but no scm.reviewRequest plugin is available.");
+        throw new Error("review-mode is pr but no scm.reviewRequest plugin is available.");
     }
     const plugin = scmPlugins[0];
     if (!plugin?.createOrUpdateReviewRequest) {
@@ -410,5 +413,5 @@ function isReleaseCommitMessage(commitMessage) {
         return true;
     }
     const subject = commitMessage.split("\n")[0]?.trim() ?? "";
-    return /^chore\(release\):\s+(?:v\d+\.\d+\.\d+|\S+-v\d+\.\d+\.\d+)(?:,\s+(?:v\d+\.\d+\.\d+|\S+-v\d+\.\d+\.\d+))*(?:\s+\(#\d+\))?$/u.test(subject);
+    return /^chore\(release\):\s+(?:(?:v\d+\.\d+\.\d+|\S+-v\d+\.\d+\.\d+)(?:,\s+(?:v\d+\.\d+\.\d+|\S+-v\d+\.\d+\.\d+))*|(?:v\d+\.\d+\.\d+|\S+-v\d+\.\d+\.\d+)\s+\(\+\d+\s+more\))(?:\s+\(#\d+\))?$/u.test(subject);
 }

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

@@ -1,8 +1,17 @@
+import type { VersionaryConfig } from "../../types/config.js";
 import type { VersionaryPluginContext } from "../../types/plugins.js";
+export declare function resolveTargetChangelogFile(config: VersionaryConfig, rootChangelogFile: string, targetPath: string): string;
 export declare function runSimpleRelease(cwd?: string): Promise<string>;
 export type SimpleRunReleaseResult = {
     action: "release-skipped";
     reason: string;
+} | {
+    action: "release-dry-run";
+    message: string;
+    targets: {
+        tag: string;
+        version: string;
+    }[];
 } | {
     action: "release-published";
     message: string;
@@ -15,5 +24,6 @@ export type SimpleRunReleaseResult = {
 };
 export interface RunSimpleReleaseOptions {
     logger?: VersionaryPluginContext["logger"];
+    "dry-run"?: boolean;
 }
 export declare function runSimpleReleaseDetailed(cwd?: string, options?: RunSimpleReleaseOptions): Promise<SimpleRunReleaseResult>;

package/dist/app/release/release.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTargetChangelogFile = resolveTargetChangelogFile;
 exports.runSimpleRelease = runSimpleRelease;
 exports.runSimpleReleaseDetailed = runSimpleReleaseDetailed;
 const node_child_process_1 = require("node:child_process");
@@ -46,6 +47,16 @@ function readReleaseNotes(cwd, version, changelogFile) {
         .trim();
     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;
+    }
+    return node_path_1.default.posix.join(targetPath, packageChangelogFile);
+}
 async function runSimpleRelease(cwd = process.cwd()) {
     const result = await runSimpleReleaseDetailed(cwd, { logger: console });
     if (result.action === "release-skipped") {
@@ -66,16 +77,6 @@ async function runSimpleReleaseDetailed(cwd = process.cwd(), options = {}) {
     const changelogFile = loaded.config["changelog-file"] ?? "CHANGELOG.md";
     const version = strategy.readVersion(cwd, loaded.config);
     const defaultTag = `v${version}`;
-    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 releaseTargets = (0, state_js_1.readReleaseTargets)(cwd);
     const targets = releaseTargets.length > 0
         ? releaseTargets
@@ -86,12 +87,34 @@ async function runSimpleReleaseDetailed(cwd = process.cwd(), options = {}) {
                 tag: defaultTag,
             },
         ];
+    if (options["dry-run"]) {
+        const targetList = targets.map((target) => `${target.tag} (${target.version})`);
+        return {
+            action: "release-dry-run",
+            targets: targets.map((target) => ({
+                tag: target.tag,
+                version: target.version,
+            })),
+            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 releases = [];
     for (const target of targets) {
+        const targetChangelogFile = resolveTargetChangelogFile(loaded.config, changelogFile, target.path);
         const outcome = await (0, recovery_js_1.executeIdempotentReleaseTarget)(cwd, {
             tag: target.tag,
             version: target.version,
-            notes: readReleaseNotes(cwd, target.version, changelogFile),
+            notes: readReleaseNotes(cwd, target.version, targetChangelogFile),
         }, {
             createReleaseMetadata: (input) => createReleaseMetadata(input, {
                 cwd,

package/dist/app/release/state.js

@@ -79,7 +79,7 @@ function readReleaseTargets(cwd = process.cwd()) {
     const parsed = parseStateFile(node_fs_1.default.readFileSync(filePath, "utf8"), filePath);
     return parsed[RELEASE_TARGETS_KEY] ?? [];
 }
-function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets = []) {
+function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets) {
     const baselineShaValue = sha ??
         (0, node_child_process_1.execFileSync)("git", ["rev-parse", "HEAD"], {
             cwd,
@@ -87,10 +87,22 @@ function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets = []) {
             stdio: ["ignore", "pipe", "ignore"],
         }).trim();
     const filePath = getBaselineStatePath(cwd);
+    const existing = node_fs_1.default.existsSync(filePath)
+        ? parseStateFile(node_fs_1.default.readFileSync(filePath, "utf8"), filePath)
+        : {};
+    const existingTargets = existing[RELEASE_TARGETS_KEY] ?? [];
+    const nextTargets = releaseTargets === undefined
+        ? existingTargets
+        : [
+            ...new Map([...existingTargets, ...releaseTargets].map((target) => [
+                target.path,
+                target,
+            ])).values(),
+        ].sort((a, b) => a.path.localeCompare(b.path));
     const next = {
         [MANIFEST_VERSION_KEY]: 1,
         [BASELINE_SHA_KEY]: baselineShaValue,
-        [RELEASE_TARGETS_KEY]: releaseTargets,
+        [RELEASE_TARGETS_KEY]: nextTargets,
     };
     node_fs_1.default.writeFileSync(filePath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
 }

package/dist/cli/index.js

@@ -14,15 +14,33 @@ const changelog_js_1 = require("../domain/release/changelog.js");
 const plan_js_1 = require("../domain/release/plan.js");
 function printVerifyResult() {
     const result = (0, verify_js_1.verifyProject)();
-    for (const check of result.checks) {
-        const status = check.ok ? "OK" : "FAIL";
-        console.log(`[${status}] ${check.name} - ${check.details}`);
+    const categories = [
+        { key: "config", title: "Config" },
+        { key: "paths", title: "Paths" },
+        { key: "version-files", title: "Version files" },
+    ];
+    for (const category of categories) {
+        const checks = result.checks.filter((check) => check.category === category.key);
+        if (checks.length === 0) {
+            continue;
+        }
+        console.log(`${category.title}:`);
+        for (const check of checks) {
+            const status = check.ok ? "OK" : "FAIL";
+            console.log(`  [${status}] ${check.name} - ${check.details}`);
+            if (!check.ok && check.remediation) {
+                console.log(`         Fix: ${check.remediation}`);
+            }
+        }
+        console.log("");
     }
+    console.log(result.ok ? "Summary: all checks passed." : "Summary: checks failed.");
     return result.ok ? 0 : 1;
 }
 function parseFlags(args) {
     return {
         json: args.includes("--json"),
+        "dry-run": args.includes("--dry-run"),
     };
 }
 function emitJson(payload) {
@@ -38,9 +56,20 @@ async function main() {
             stdio: ["ignore", "pipe", "ignore"],
         }).trim();
         if ((0, pr_js_1.isReleaseCommitMessage)(commitMessage)) {
+            if (flags["dry-run"] && !flags.json) {
+                const release = await (0, release_js_1.runSimpleReleaseDetailed)(process.cwd(), {
+                    logger,
+                    "dry-run": true,
+                });
+                if (release.action === "release-dry-run") {
+                    console.log(release.message);
+                    return 0;
+                }
+            }
             if (flags.json) {
                 const release = await (0, release_js_1.runSimpleReleaseDetailed)(process.cwd(), {
                     logger,
+                    "dry-run": flags["dry-run"],
                 });
                 if (release.action === "release-skipped") {
                     emitJson({
@@ -51,6 +80,16 @@ async function main() {
                     });
                     return 0;
                 }
+                if (release.action === "release-dry-run") {
+                    emitJson({
+                        action: "release-dry-run",
+                        message: release.message,
+                        releaseCreated: false,
+                        tagNames: release.targets.map((target) => target.tag),
+                        targets: release.targets,
+                    });
+                    return 0;
+                }
                 emitJson({
                     action: "release-published",
                     message: release.message,
@@ -78,6 +117,34 @@ async function main() {
             console.log(message);
             return 0;
         }
+        if (flags["dry-run"]) {
+            const dryRunMessage = `Dry run: would prepare release PR branch ${plan.releaseBranchPrefix} for ${plan.nextVersion}`;
+            if (flags.json) {
+                emitJson({
+                    action: "pr-dry-run",
+                    message: dryRunMessage,
+                    releaseCreated: false,
+                    tagNames: [],
+                    branch: plan.releaseBranchPrefix,
+                    targets: plan.packages
+                        ?.filter((pkg) => pkg.nextVersion)
+                        .map((pkg) => ({
+                        tag: pkg.path === "."
+                            ? `v${pkg.nextVersion ?? ""}`
+                            : `${pkg.path}-v${pkg.nextVersion ?? ""}`,
+                        version: pkg.nextVersion ?? "",
+                    })) ?? [
+                        {
+                            tag: `v${plan.nextVersion}`,
+                            version: plan.nextVersion,
+                        },
+                    ],
+                });
+                return 0;
+            }
+            console.log(dryRunMessage);
+            return 0;
+        }
         const pr = (0, pr_js_1.prepareSimpleReleasePr)(process.cwd(), { logger });
         (0, pr_js_1.pushReleaseBranch)(process.cwd(), pr.branch);
         const reviewResult = await (0, pr_js_1.openOrUpdateSimpleReviewRequest)(process.cwd(), pr.branch, pr.title, pr.version, pr.previousVersion, pr.commits, pr.plan, { logger });
@@ -130,6 +197,15 @@ async function main() {
         return 0;
     }
     if (command === "pr") {
+        if (flags["dry-run"]) {
+            const plan = (0, plan_js_1.createSimplePlan)();
+            if (!plan.nextVersion) {
+                console.log("No releasable commits found. Nothing to do.");
+                return 0;
+            }
+            console.log(`Dry run: would prepare release PR branch ${plan.releaseBranchPrefix} for ${plan.nextVersion}`);
+            return 0;
+        }
         const pr = (0, pr_js_1.prepareSimpleReleasePr)(process.cwd(), { logger: console });
         (0, pr_js_1.pushReleaseBranch)(process.cwd(), pr.branch);
         const reviewResult = await (0, pr_js_1.openOrUpdateSimpleReviewRequest)(process.cwd(), pr.branch, pr.title, pr.version, pr.previousVersion, pr.commits, pr.plan);
@@ -139,18 +215,34 @@ async function main() {
         return 0;
     }
     if (command === "release") {
+        if (flags["dry-run"]) {
+            const result = await (0, release_js_1.runSimpleReleaseDetailed)(process.cwd(), {
+                logger,
+                "dry-run": true,
+            });
+            if (result.action === "release-dry-run") {
+                console.log(result.message);
+            }
+            else if (result.action === "release-skipped") {
+                console.log(result.reason);
+            }
+            else {
+                console.log(result.message);
+            }
+            return 0;
+        }
         const message = await (0, release_js_1.runSimpleRelease)(process.cwd());
         console.log(message);
         return 0;
     }
     console.log("Usage: versionary <command>");
     console.log("Commands:");
-    console.log("  run [--json]  Auto-dispatch release PR/update or release publish by context");
+    console.log("  run [--json] [--dry-run]  Auto-dispatch release PR/update or release publish by context");
     console.log("  verify  Validate config and basic repository shape");
     console.log("  plan    Print release plan (simple mode)");
     console.log("  changelog [--write]  Print or write changelog section");
-    console.log("  pr      Prepare release PR commit and branch");
-    console.log("  release Publish release metadata for release commit context");
+    console.log("  pr [--dry-run]      Prepare release PR commit and branch");
+    console.log("  release [--dry-run] Publish release metadata for release commit context");
     return 1;
 }
 main()

package/dist/config/load-config.js

@@ -41,6 +41,9 @@ function loadConfig(cwd = process.cwd()) {
     if (!isRecord(parsed)) {
         throw new Error("Invalid config: expected an object at the root.");
     }
+    if (Object.hasOwn(parsed, "plugins")) {
+        throw new Error('The "plugins" config key is no longer supported. Versionary uses built-in integrations only.');
+    }
     const validated = schema_js_1.configSchema.parse(parsed);
     return {
         path: found.path,

package/dist/config/schema.d.ts

@@ -4,6 +4,7 @@ export declare const configSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     "review-mode": z.ZodOptional<z.ZodEnum<{
         direct: "direct";
+        pr: "pr";
         review: "review";
     }>>;
     "version-file": z.ZodOptional<z.ZodString>;
@@ -37,6 +38,5 @@ export declare const configSchema: z.ZodObject<{
             pattern: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
     }, z.core.$strict>>>;
-    plugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 export type ConfigSchema = z.infer<typeof configSchema>;

package/dist/config/schema.js

@@ -62,7 +62,7 @@ exports.configSchema = zod_1.z
     .object({
     $schema: zod_1.z.string().optional(),
     version: zod_1.z.literal(1),
-    "review-mode": zod_1.z.enum(["direct", "review"]).optional(),
+    "review-mode": zod_1.z.enum(["direct", "pr", "review"]).optional(),
     "version-file": zod_1.z.string().optional(),
     "changelog-file": zod_1.z.string().optional(),
     "release-branch": zod_1.z.string().optional(),
@@ -74,6 +74,5 @@ exports.configSchema = zod_1.z
     "include-commit-authors": zod_1.z.boolean().optional(),
     "release-type": zod_1.z.string().optional(),
     packages: zod_1.z.record(zod_1.z.string().min(1), packageSchema).optional(),
-    plugins: zod_1.z.array(zod_1.z.string().min(1)).optional(),
 })
     .strict();

package/dist/domain/release/changelog.js

@@ -48,6 +48,7 @@ function groupCommitLines(commits, repoUrl) {
     const breaking = [];
     const features = [];
     const fixes = [];
+    const reverts = [];
     for (const commit of commits) {
         const type = (0, commits_js_1.inferReleaseTypeFromParsedCommit)(commit);
         if (!type) {
@@ -63,6 +64,10 @@ function groupCommitLines(commits, repoUrl) {
         const line = `- ${label}${message} (${hashLabel})${referencesSuffix}`;
         const commitType = (commit.type ?? "").toLowerCase();
         const isBreaking = type === "major";
+        if (commit.isRevert) {
+            reverts.push(line);
+            continue;
+        }
         if (isBreaking) {
             breaking.push(line);
         }
@@ -76,7 +81,7 @@ function groupCommitLines(commits, repoUrl) {
             fixes.push(line);
         }
     }
-    return { breaking, features, fixes };
+    return { breaking, features, fixes, reverts };
 }
 function renderSimpleReleaseNotes(input, options = {}) {
     const repoUrl = (0, repo_url_js_1.resolveRepositoryWebBaseUrl)(input.cwd ?? process.cwd());
@@ -94,6 +99,9 @@ function renderSimpleReleaseNotes(input, options = {}) {
     if (grouped.fixes.length > 0) {
         sections.push("### Bug Fixes", ...grouped.fixes, "");
     }
+    if (grouped.reverts.length > 0) {
+        sections.push("### Reverts", ...grouped.reverts, "");
+    }
     const lines = [header, "", ...sections];
     if (options.includeFooter) {
         lines.push("\n---\n\nThis PR was generated by [Versionary](https://github.com/jolars/versionary).");
@@ -127,6 +135,9 @@ function renderPackageChangelogSection(input) {
     if (grouped.fixes.length > 0) {
         sections.push("### Bug Fixes", ...grouped.fixes, "");
     }
+    if (grouped.reverts.length > 0) {
+        sections.push("### Reverts", ...grouped.reverts, "");
+    }
     return [header, "", ...sections].join("\n");
 }
 function prependChangelog(cwd, changelogFile, section) {

package/dist/infra/git/commits.js

@@ -351,12 +351,12 @@ function getParsedCommitsForPath(cwd = process.cwd(), baselineSha, packagePath =
     return readGitLogFull(cwd, range, [normalizedPackagePath, ...excludes]);
 }
 function inferReleaseTypeFromParsedCommit(commit) {
-    if (commit.isRevert) {
-        return null;
-    }
     if (commit.isBreaking) {
         return "major";
     }
+    if (commit.isRevert) {
+        return "patch";
+    }
     const type = commit.type?.toLowerCase() ?? "";
     if (type === "feat") {
         return "minor";

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

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

package/dist/infra/scm/runtime.js

@@ -1,24 +1,7 @@
 "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;
+function loadRuntimePlugins() {
+    return [(0, plugin_js_1.createGitHubPlugin)()];
 }

package/dist/types/config.d.ts

@@ -15,7 +15,7 @@ export interface VersionaryPackage {
 }
 export interface VersionaryConfig {
     version: 1;
-    "review-mode"?: "direct" | "review";
+    "review-mode"?: "direct" | "pr" | "review";
     "version-file"?: string;
     "changelog-file"?: string;
     "release-branch"?: string;
@@ -27,7 +27,6 @@ export interface VersionaryConfig {
     "include-commit-authors"?: boolean;
     "release-type"?: string;
     packages?: Record<string, VersionaryPackage>;
-    plugins?: string[];
 }
 export interface LoadedConfig {
     path: string;

package/dist/verify/verify-project.d.ts

@@ -4,6 +4,8 @@ export interface VerifyResult {
         name: string;
         ok: boolean;
         details: string;
+        category: "config" | "paths" | "version-files";
+        remediation?: string;
     }>;
 }
 export declare function verifyProject(cwd?: string): VerifyResult;

package/dist/verify/verify-project.js

@@ -16,6 +16,7 @@ function verifyProject(cwd = process.cwd()) {
         name: "config-load",
         ok: true,
         details: `Loaded ${node_path_1.default.basename(config.path)} (${config.format})`,
+        category: "config",
     });
     const strategy = (0, resolve_js_1.resolveVersionStrategy)(config.config);
     const versionFile = strategy.getVersionFile(config.config);
@@ -24,6 +25,10 @@ function verifyProject(cwd = process.cwd()) {
         name: `version-file:${versionFile}`,
         ok: exists,
         details: exists ? "Version file exists" : `Missing ${versionFile}`,
+        category: "version-files",
+        remediation: exists
+            ? undefined
+            : `Create ${versionFile} or set "version-file" to the correct path for your release strategy.`,
     });
     if (config.config.packages) {
         for (const [pkgPathRaw, packageConfig] of Object.entries(config.config.packages)) {
@@ -33,6 +38,10 @@ function verifyProject(cwd = process.cwd()) {
                 name: `package-path:${pkgPathRaw}`,
                 ok: exists,
                 details: exists ? "Path exists" : `Missing path: ${pkgPathRaw}`,
+                category: "paths",
+                remediation: exists
+                    ? undefined
+                    : `Create ${pkgPathRaw} or remove/rename this entry under "packages" in versionary config.`,
             });
             if (exists) {
                 const packageContext = (0, package_context_js_1.resolvePackageStrategyContext)(config.config, pkgPathRaw, packageConfig);
@@ -44,6 +53,10 @@ function verifyProject(cwd = process.cwd()) {
                     details: packageVersionExists
                         ? "Version file exists"
                         : `Missing ${packageVersionFile}`,
+                    category: "version-files",
+                    remediation: packageVersionExists
+                        ? undefined
+                        : `Create ${packageVersionFile} or adjust package release settings ("release-type"/"version-file") for ${pkgPathRaw}.`,
                 });
             }
         }

package/package.json

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