versionary 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Johan Larsson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,34 @@
+# versionary
+
+Versionary is a software-agnostic automated release tool focused on SemVer, conventional commits, release PR workflows, and extensibility.
+
+Configuration is loaded from `versionary.jsonc` by default.
+
+## Simple mode (MVP)
+
+For a quick trial, use:
+
+- `versionary.jsonc` with `"mode": "simple"`
+- `version.txt` as the version source
+- `CHANGELOG.md` as release notes output
+
+Commands:
+
+- `pnpm verify`
+- `pnpm plan`
+- `pnpm changelog -- --write`
+- `pnpm pr`
+
+## Install from GitHub
+
+You can install directly from a git ref:
+
+```json
+{
+  "devDependencies": {
+    "versionary": "github:jolars/versionary#<commit-or-tag>"
+  }
+}
+```
+
+The package runs a `prepare` build during git installation so the `versionary` CLI binary is available after `pnpm install`.

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const plan_js_1 = require("../simple/plan.js");
+const changelog_js_1 = require("../simple/changelog.js");
+const pr_js_1 = require("../simple/pr.js");
+const verify_project_js_1 = require("../verify/verify-project.js");
+function printVerifyResult() {
+    const result = (0, verify_project_js_1.verifyProject)();
+    for (const check of result.checks) {
+        const status = check.ok ? "OK" : "FAIL";
+        console.log(`[${status}] ${check.name} - ${check.details}`);
+    }
+    return result.ok ? 0 : 1;
+}
+function main() {
+    const [, , command, ...args] = process.argv;
+    if (command === "verify") {
+        return printVerifyResult();
+    }
+    if (command === "plan") {
+        const plan = (0, plan_js_1.createSimplePlan)();
+        console.log(JSON.stringify(plan, null, 2));
+        return 0;
+    }
+    if (command === "changelog") {
+        const write = args.includes("--write");
+        const plan = (0, plan_js_1.createSimplePlan)();
+        if (!plan.nextVersion) {
+            console.log("No releasable commits found.");
+            return 0;
+        }
+        const section = (0, changelog_js_1.renderSimpleChangelog)(plan);
+        if (!write) {
+            console.log(section);
+            return 0;
+        }
+        const changelogPath = node_path_1.default.join(process.cwd(), plan.changelogFile);
+        const existing = node_fs_1.default.existsSync(changelogPath) ? node_fs_1.default.readFileSync(changelogPath, "utf8") : "";
+        const heading = "# Changelog\n\n";
+        const body = existing.replace(/^# Changelog\s*/u, "");
+        node_fs_1.default.writeFileSync(changelogPath, `${heading}${section}\n${body}`.trimEnd() + "\n", "utf8");
+        console.log(`Updated ${plan.changelogFile}`);
+        return 0;
+    }
+    if (command === "pr") {
+        const pr = (0, pr_js_1.prepareSimpleReleasePr)();
+        console.log(`Prepared release PR branch ${pr.branch}`);
+        console.log(`Title: ${pr.title}`);
+        return 0;
+    }
+    console.log("Usage: versionary <command>");
+    console.log("Commands:");
+    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");
+    return 1;
+}
+process.exit(main());

package/dist/config/load-config.d.ts

@@ -0,0 +1,6 @@
+import type { ConfigFileFormat, LoadedConfig } from "../types/config.js";
+export declare function findConfigFile(cwd: string): {
+    path: string;
+    format: ConfigFileFormat;
+} | null;
+export declare function loadConfig(cwd?: string): LoadedConfig;

package/dist/config/load-config.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findConfigFile = findConfigFile;
+exports.loadConfig = loadConfig;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const toml_1 = require("@iarna/toml");
+const jsonc_parser_1 = require("jsonc-parser");
+const schema_js_1 = require("./schema.js");
+const SUPPORTED_FILES = [
+    { file: "versionary.jsonc", format: "jsonc" },
+    { file: "versionary.json", format: "json" },
+    { file: "versionary.toml", format: "toml" },
+    { file: "versionary.js", format: "js" },
+    { file: "versionary.config.jsonc", format: "jsonc" },
+    { file: "versionary.config.json", format: "json" },
+    { file: "versionary.config.toml", format: "toml" },
+    { file: "versionary.config.js", format: "js" },
+];
+function parseConfig(raw, format) {
+    if (format === "json" || format === "jsonc") {
+        return (0, jsonc_parser_1.parse)(raw);
+    }
+    if (format === "toml") {
+        return (0, toml_1.parse)(raw);
+    }
+    throw new Error("JavaScript config loading is not implemented yet. Use JSONC/JSON/TOML for now.");
+}
+function findConfigFile(cwd) {
+    for (const candidate of SUPPORTED_FILES) {
+        const candidatePath = node_path_1.default.join(cwd, candidate.file);
+        if (node_fs_1.default.existsSync(candidatePath)) {
+            return { path: candidatePath, format: candidate.format };
+        }
+    }
+    return null;
+}
+function loadConfig(cwd = process.cwd()) {
+    const found = findConfigFile(cwd);
+    if (!found) {
+        throw new Error("No Versionary config found. Create versionary.jsonc (preferred), .json, or .toml.");
+    }
+    const raw = node_fs_1.default.readFileSync(found.path, "utf8");
+    const parsed = parseConfig(raw, found.format);
+    const validated = schema_js_1.configSchema.parse(parsed);
+    return {
+        path: found.path,
+        format: found.format,
+        config: validated,
+    };
+}

package/dist/config/schema.d.ts

@@ -0,0 +1,99 @@
+import { z } from "zod";
+export declare const configSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        simple: "simple";
+        standard: "standard";
+    }>>;
+    history: z.ZodOptional<z.ZodObject<{
+        bootstrap: z.ZodOptional<z.ZodObject<{
+            sha: z.ZodOptional<z.ZodString>;
+            tag: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    monorepo: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            independent: "independent";
+            fixed: "fixed";
+        }>>;
+    }, z.core.$strip>>;
+    defaults: z.ZodOptional<z.ZodObject<{
+        strategy: z.ZodOptional<z.ZodString>;
+        versioning: z.ZodOptional<z.ZodObject<{
+            bumpMinorPreMajor: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        changelog: z.ZodOptional<z.ZodObject<{
+            includeAuthors: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        commitConventions: z.ZodOptional<z.ZodObject<{
+            preset: z.ZodDefault<z.ZodEnum<{
+                conventional: "conventional";
+                angular: "angular";
+                custom: "custom";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    packages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        strategy: z.ZodOptional<z.ZodString>;
+        packageName: z.ZodOptional<z.ZodString>;
+        excludePaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            format: z.ZodEnum<{
+                json: "json";
+                toml: "toml";
+                yaml: "yaml";
+                regex: "regex";
+            }>;
+            path: z.ZodOptional<z.ZodString>;
+            pattern: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    pluginConfig: z.ZodOptional<z.ZodObject<{
+        extends: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>>>;
+        globalOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        execution: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            step: z.ZodEnum<{
+                verifyConditions: "verifyConditions";
+                analyzeCommits: "analyzeCommits";
+                resolveReverts: "resolveReverts";
+                verifyRelease: "verifyRelease";
+                generateNotes: "generateNotes";
+                updateArtifacts: "updateArtifacts";
+                preparePr: "preparePr";
+                publish: "publish";
+                postRelease: "postRelease";
+                success: "success";
+                fail: "fail";
+            }>;
+            lifecycle: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                plan: "plan";
+                pr: "pr";
+                release: "release";
+            }>>>;
+            merge: z.ZodOptional<z.ZodEnum<{
+                highest: "highest";
+                concat: "concat";
+                override: "override";
+                reduce: "reduce";
+            }>>;
+        }, z.core.$strip>>>;
+        plugins: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    simple: z.ZodOptional<z.ZodObject<{
+        versionFile: z.ZodOptional<z.ZodString>;
+        changelogFile: z.ZodOptional<z.ZodString>;
+        releaseBranchPrefix: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ConfigSchema = z.infer<typeof configSchema>;

package/dist/config/schema.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configSchema = void 0;
+const zod_1 = require("zod");
+const artifactRuleSchema = zod_1.z.object({
+    file: zod_1.z.string().min(1),
+    format: zod_1.z.enum(["json", "toml", "yaml", "regex"]),
+    path: zod_1.z.string().optional(),
+    pattern: zod_1.z.string().optional(),
+});
+const packageSchema = zod_1.z.object({
+    path: zod_1.z.string().min(1),
+    strategy: zod_1.z.string().optional(),
+    packageName: zod_1.z.string().optional(),
+    excludePaths: zod_1.z.array(zod_1.z.string()).optional(),
+    artifacts: zod_1.z.array(artifactRuleSchema).optional(),
+});
+const pluginSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1),
+    options: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+});
+const pluginExecutionSchema = zod_1.z.object({
+    step: zod_1.z.enum([
+        "verifyConditions",
+        "analyzeCommits",
+        "resolveReverts",
+        "verifyRelease",
+        "generateNotes",
+        "updateArtifacts",
+        "preparePr",
+        "publish",
+        "postRelease",
+        "success",
+        "fail",
+    ]),
+    lifecycle: zod_1.z.array(zod_1.z.enum(["plan", "pr", "release"])).optional(),
+    merge: zod_1.z.enum(["highest", "concat", "override", "reduce"]).optional(),
+});
+const pluginConfigSchema = zod_1.z.object({
+    extends: zod_1.z.array(zod_1.z.object({ name: zod_1.z.string().min(1) })).optional(),
+    globalOptions: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+    execution: zod_1.z.array(pluginExecutionSchema).optional(),
+    plugins: zod_1.z.array(pluginSchema).optional(),
+});
+exports.configSchema = zod_1.z.object({
+    version: zod_1.z.literal(1),
+    mode: zod_1.z.enum(["simple", "standard"]).optional(),
+    history: zod_1.z
+        .object({
+        bootstrap: zod_1.z
+            .object({
+            sha: zod_1.z.string().optional(),
+            tag: zod_1.z.string().optional(),
+        })
+            .optional(),
+    })
+        .optional(),
+    monorepo: zod_1.z
+        .object({
+        mode: zod_1.z.enum(["independent", "fixed"]).default("independent"),
+    })
+        .optional(),
+    defaults: zod_1.z
+        .object({
+        strategy: zod_1.z.string().optional(),
+        versioning: zod_1.z
+            .object({
+            bumpMinorPreMajor: zod_1.z.boolean().optional(),
+        })
+            .optional(),
+        changelog: zod_1.z
+            .object({
+            includeAuthors: zod_1.z.boolean().optional(),
+        })
+            .optional(),
+        commitConventions: zod_1.z
+            .object({
+            preset: zod_1.z.enum(["conventional", "angular", "custom"]).default("conventional"),
+        })
+            .optional(),
+    })
+        .optional(),
+    packages: zod_1.z.array(packageSchema).optional(),
+    pluginConfig: pluginConfigSchema.optional(),
+    plugins: zod_1.z.array(pluginSchema).optional(),
+    simple: zod_1.z
+        .object({
+        versionFile: zod_1.z.string().optional(),
+        changelogFile: zod_1.z.string().optional(),
+        releaseBranchPrefix: zod_1.z.string().optional(),
+    })
+        .optional(),
+});

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export type { VersionaryConfig, VersionaryPackage, VersionaryPluginRef, VersionaryArtifactRule, } from "./types/config.js";
+export { loadConfig } from "./config/load-config.js";
+export { verifyProject } from "./verify/verify-project.js";

package/dist/index.js

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

@@ -0,0 +1,3 @@
+import type { SimplePlan } from "./plan.js";
+export declare function renderSimpleChangelog(plan: SimplePlan): string;
+export declare function prependChangelog(cwd: string, changelogFile: string, section: string): void;

package/dist/simple/changelog.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderSimpleChangelog = renderSimpleChangelog;
+exports.prependChangelog = prependChangelog;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function formatDate() {
+    return new Date().toISOString().slice(0, 10);
+}
+function renderSimpleChangelog(plan) {
+    if (!plan.nextVersion) {
+        return "";
+    }
+    const lines = [
+        `## ${plan.nextVersion} - ${formatDate()}`,
+        "",
+        ...plan.commits.map((commit) => `- ${commit.subject} (${commit.hash.slice(0, 7)})`),
+        "",
+    ];
+    return lines.join("\n");
+}
+function prependChangelog(cwd, changelogFile, section) {
+    const changelogPath = node_path_1.default.join(cwd, changelogFile);
+    const existing = node_fs_1.default.existsSync(changelogPath) ? node_fs_1.default.readFileSync(changelogPath, "utf8") : "";
+    const heading = existing.startsWith("# Changelog") ? "" : "# Changelog\n\n";
+    const separator = existing.length > 0 ? "\n" : "";
+    const next = `${heading}${section}${separator}${existing.replace(/^# Changelog\s*/u, "")}`.trimEnd() + "\n";
+    node_fs_1.default.writeFileSync(changelogPath, next, "utf8");
+}

package/dist/simple/git.d.ts

@@ -0,0 +1,7 @@
+import type { ReleaseType } from "./semver.js";
+export interface CommitInfo {
+    hash: string;
+    subject: string;
+}
+export declare function getCommitsSinceLastTag(cwd?: string): CommitInfo[];
+export declare function analyzeCommits(commits: CommitInfo[]): ReleaseType;

package/dist/simple/git.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCommitsSinceLastTag = getCommitsSinceLastTag;
+exports.analyzeCommits = analyzeCommits;
+const node_child_process_1 = require("node:child_process");
+function getCommitsSinceLastTag(cwd = process.cwd()) {
+    const tagsOutput = (0, node_child_process_1.execFileSync)("git", ["tag", "--sort=-v:refname"], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+    const baseRef = tagsOutput.trim().split("\n")[0] ?? "";
+    const range = baseRef ? `${baseRef}..HEAD` : "HEAD";
+    const output = (0, node_child_process_1.execFileSync)("git", ["log", range, "--pretty=format:%H%x09%s"], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+    if (!output.trim()) {
+        return [];
+    }
+    return output
+        .trim()
+        .split("\n")
+        .map((line) => {
+        const [hash, subject] = line.split("\t");
+        return { hash, subject };
+    });
+}
+function inferReleaseTypeFromSubject(subject) {
+    if (/^revert:\s/i.test(subject)) {
+        return null;
+    }
+    if (/!:/u.test(subject) || /BREAKING CHANGE/u.test(subject)) {
+        return "major";
+    }
+    if (/^feat(\(.+\))?:\s/i.test(subject)) {
+        return "minor";
+    }
+    if (/^(fix|perf|refactor)(\(.+\))?:\s/i.test(subject)) {
+        return "patch";
+    }
+    return null;
+}
+function analyzeCommits(commits) {
+    let result = null;
+    for (const commit of commits) {
+        const type = inferReleaseTypeFromSubject(commit.subject);
+        if (type === "major") {
+            return "major";
+        }
+        if (type === "minor") {
+            result = "minor";
+            continue;
+        }
+        if (type === "patch" && result === null) {
+            result = "patch";
+        }
+    }
+    return result;
+}

package/dist/simple/plan.d.ts

@@ -0,0 +1,12 @@
+import { type CommitInfo } from "./git.js";
+import { type ReleaseType } from "./semver.js";
+export interface SimplePlan {
+    mode: "simple";
+    releaseType: ReleaseType;
+    currentVersion: string;
+    nextVersion: string | null;
+    versionFile: string;
+    changelogFile: string;
+    commits: CommitInfo[];
+}
+export declare function createSimplePlan(cwd?: string): SimplePlan;

package/dist/simple/plan.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.createSimplePlan = createSimplePlan;
+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 git_js_1 = require("./git.js");
+const semver_js_1 = require("./semver.js");
+function createSimplePlan(cwd = process.cwd()) {
+    const loaded = (0, load_config_js_1.loadConfig)(cwd);
+    const mode = loaded.config.mode ?? "simple";
+    if (mode !== "simple") {
+        throw new Error("Simple plan requires mode: simple in config.");
+    }
+    const versionFile = loaded.config.simple?.versionFile ?? "version.txt";
+    const changelogFile = loaded.config.simple?.changelogFile ?? "CHANGELOG.md";
+    const versionPath = node_path_1.default.join(cwd, versionFile);
+    if (!node_fs_1.default.existsSync(versionPath)) {
+        throw new Error(`Simple mode requires ${versionFile} to exist.`);
+    }
+    const currentVersion = node_fs_1.default.readFileSync(versionPath, "utf8").trim();
+    const commits = (0, git_js_1.getCommitsSinceLastTag)(cwd);
+    const releaseType = (0, git_js_1.analyzeCommits)(commits);
+    const nextVersion = releaseType ? (0, semver_js_1.bumpVersion)(currentVersion, releaseType) : null;
+    return {
+        mode: "simple",
+        releaseType,
+        currentVersion,
+        nextVersion,
+        versionFile,
+        changelogFile,
+        commits,
+    };
+}

package/dist/simple/pr.d.ts

@@ -0,0 +1,5 @@
+export declare function prepareSimpleReleasePr(cwd?: string): {
+    branch: string;
+    title: string;
+    version: string;
+};

package/dist/simple/pr.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareSimpleReleasePr = prepareSimpleReleasePr;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const plan_js_1 = require("./plan.js");
+const changelog_js_1 = require("./changelog.js");
+function ensureCleanWorktree(cwd) {
+    const status = (0, node_child_process_1.execFileSync)("git", ["status", "--porcelain"], {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+    if (status.length > 0) {
+        throw new Error("Working tree is not clean. Commit or stash changes before `versionary pr`.");
+    }
+}
+function prepareSimpleReleasePr(cwd = process.cwd()) {
+    const plan = (0, plan_js_1.createSimplePlan)(cwd);
+    if (!plan.nextVersion) {
+        throw new Error("No releasable commits found. Nothing to open a release PR for.");
+    }
+    ensureCleanWorktree(cwd);
+    const versionPath = node_path_1.default.join(cwd, plan.versionFile);
+    node_fs_1.default.writeFileSync(versionPath, `${plan.nextVersion}\n`, "utf8");
+    const section = (0, changelog_js_1.renderSimpleChangelog)(plan);
+    (0, changelog_js_1.prependChangelog)(cwd, plan.changelogFile, section);
+    const branch = `versionary/release-v${plan.nextVersion}`;
+    const title = `chore(release): v${plan.nextVersion}`;
+    (0, node_child_process_1.execFileSync)("git", ["checkout", "-B", branch], { cwd, stdio: ["ignore", "pipe", "ignore"] });
+    (0, node_child_process_1.execFileSync)("git", ["add", plan.versionFile, plan.changelogFile], {
+        cwd,
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+    (0, node_child_process_1.execFileSync)("git", ["commit", "-m", title], { cwd, stdio: ["ignore", "pipe", "ignore"] });
+    return {
+        branch,
+        title,
+        version: plan.nextVersion,
+    };
+}

package/dist/simple/semver.d.ts

@@ -0,0 +1,8 @@
+export type ReleaseType = "major" | "minor" | "patch" | null;
+export interface ParsedVersion {
+    major: number;
+    minor: number;
+    patch: number;
+}
+export declare function parseVersion(version: string): ParsedVersion;
+export declare function bumpVersion(current: string, releaseType: Exclude<ReleaseType, null>): string;

package/dist/simple/semver.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVersion = parseVersion;
+exports.bumpVersion = bumpVersion;
+function parseVersion(version) {
+    const match = version.trim().match(/^(\d+)\.(\d+)\.(\d+)$/);
+    if (!match) {
+        throw new Error(`Invalid version in version file: "${version}". Expected x.y.z`);
+    }
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+    };
+}
+function bumpVersion(current, releaseType) {
+    const parsed = parseVersion(current);
+    if (releaseType === "major") {
+        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/types/config.d.ts

@@ -0,0 +1,80 @@
+export type ConfigFileFormat = "jsonc" | "json" | "toml" | "js";
+export interface VersionaryBootstrap {
+    sha?: string;
+    tag?: string;
+}
+export interface VersionaryHistory {
+    bootstrap?: VersionaryBootstrap;
+}
+export interface VersionaryMonorepo {
+    mode: "independent" | "fixed";
+}
+export interface VersionaryVersioningDefaults {
+    bumpMinorPreMajor?: boolean;
+}
+export interface VersionaryChangelogDefaults {
+    includeAuthors?: boolean;
+}
+export interface VersionaryCommitConventions {
+    preset: "conventional" | "angular" | "custom";
+}
+export interface VersionaryDefaults {
+    strategy?: string;
+    versioning?: VersionaryVersioningDefaults;
+    changelog?: VersionaryChangelogDefaults;
+    commitConventions?: VersionaryCommitConventions;
+}
+export interface VersionaryArtifactRule {
+    file: string;
+    format: "json" | "toml" | "yaml" | "regex";
+    path?: string;
+    pattern?: string;
+}
+export interface VersionaryPackage {
+    path: string;
+    strategy?: string;
+    packageName?: string;
+    excludePaths?: string[];
+    artifacts?: VersionaryArtifactRule[];
+}
+export interface VersionaryPluginRef {
+    name: string;
+    options?: Record<string, unknown>;
+}
+export type VersionaryLifecycle = "plan" | "pr" | "release";
+export type VersionaryPluginStep = "verifyConditions" | "analyzeCommits" | "resolveReverts" | "verifyRelease" | "generateNotes" | "updateArtifacts" | "preparePr" | "publish" | "postRelease" | "success" | "fail";
+export type VersionaryPluginMergeStrategy = "highest" | "concat" | "override" | "reduce";
+export interface VersionaryPluginExecution {
+    step: VersionaryPluginStep;
+    lifecycle?: VersionaryLifecycle[];
+    merge?: VersionaryPluginMergeStrategy;
+}
+export interface VersionaryPluginPresetRef {
+    name: string;
+}
+export interface VersionaryPluginConfig {
+    extends?: VersionaryPluginPresetRef[];
+    globalOptions?: Record<string, unknown>;
+    execution?: VersionaryPluginExecution[];
+    plugins?: VersionaryPluginRef[];
+}
+export interface VersionaryConfig {
+    version: 1;
+    mode?: "simple" | "standard";
+    history?: VersionaryHistory;
+    monorepo?: VersionaryMonorepo;
+    defaults?: VersionaryDefaults;
+    packages?: VersionaryPackage[];
+    pluginConfig?: VersionaryPluginConfig;
+    plugins?: VersionaryPluginRef[];
+    simple?: {
+        versionFile?: string;
+        changelogFile?: string;
+        releaseBranchPrefix?: string;
+    };
+}
+export interface LoadedConfig {
+    path: string;
+    format: ConfigFileFormat;
+    config: VersionaryConfig;
+}

package/dist/types/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,9 @@
+export interface VerifyResult {
+    ok: boolean;
+    checks: Array<{
+        name: string;
+        ok: boolean;
+        details: string;
+    }>;
+}
+export declare function verifyProject(cwd?: string): VerifyResult;

package/dist/verify/verify-project.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+function verifyProject(cwd = process.cwd()) {
+    const checks = [];
+    const config = (0, load_config_js_1.loadConfig)(cwd);
+    checks.push({
+        name: "config-load",
+        ok: true,
+        details: `Loaded ${node_path_1.default.basename(config.path)} (${config.format})`,
+    });
+    if ((config.config.mode ?? "simple") === "simple") {
+        const versionFile = config.config.simple?.versionFile ?? "version.txt";
+        const exists = node_fs_1.default.existsSync(node_path_1.default.join(cwd, versionFile));
+        checks.push({
+            name: `simple-version-file:${versionFile}`,
+            ok: exists,
+            details: exists ? "Version file exists" : `Missing ${versionFile} for simple mode`,
+        });
+    }
+    if (config.config.packages) {
+        for (const pkg of config.config.packages) {
+            const pkgPath = node_path_1.default.join(cwd, pkg.path);
+            const exists = node_fs_1.default.existsSync(pkgPath);
+            checks.push({
+                name: `package-path:${pkg.path}`,
+                ok: exists,
+                details: exists ? "Path exists" : `Missing path: ${pkg.path}`,
+            });
+        }
+    }
+    const ok = checks.every((c) => c.ok);
+    return { ok, checks };
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "versionary",
+  "version": "0.1.0",
+  "description": "Automatic release framework based on conventional commits and semantic versioning",
+  "keywords": [
+    "releasing",
+    "semantic versioning",
+    "conventional commits"
+  ],
+  "homepage": "https://github.com/jolars/versionary",
+  "bugs": {
+    "url": "https://github.com/jolars/versionary/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jolars/versionary.git"
+  },
+  "license": "MIT",
+  "author": "Johan Larsson",
+  "type": "commonjs",
+  "packageManager": "pnpm@10.33.0",
+  "bin": {
+    "versionary": "dist/cli/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "prepare": "pnpm run build",
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "verify": "tsx src/cli/index.ts verify",
+    "plan": "tsx src/cli/index.ts plan",
+    "changelog": "tsx src/cli/index.ts changelog",
+    "pr": "tsx src/cli/index.ts pr"
+  },
+  "dependencies": {
+    "@iarna/toml": "^2.2.5",
+    "jsonc-parser": "^3.3.1",
+    "zod": "^4.1.12"
+  },
+  "devDependencies": {
+    "@types/node": "^24.7.2",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
+  }
+}