versionary 0.1.0 → 0.3.0

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

@@ -0,0 +1,10 @@
+export interface ReleaseTargetState {
+    path: string;
+    version: string;
+    tag: string;
+    notes?: string;
+}
+export declare function getBaselineStatePath(cwd: string): string;
+export declare function readBaselineSha(cwd?: string): string | null;
+export declare function readReleaseTargets(cwd?: string): ReleaseTargetState[];
+export declare function writeBaselineSha(cwd?: string, sha?: string, releaseTargets?: ReleaseTargetState[]): void;

package/dist/app/release/state.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBaselineStatePath = getBaselineStatePath;
+exports.readBaselineSha = readBaselineSha;
+exports.readReleaseTargets = readReleaseTargets;
+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");
+function getBaselineStatePath(cwd) {
+    const loaded = (0, load_config_js_1.loadConfig)(cwd);
+    const configured = loaded.config["baseline-file"];
+    if (configured) {
+        return node_path_1.default.join(cwd, configured);
+    }
+    const preferred = node_path_1.default.join(cwd, ".versionary-manifest.json");
+    if (node_fs_1.default.existsSync(preferred)) {
+        return preferred;
+    }
+    const legacy = node_path_1.default.join(cwd, "versionary.versions.json");
+    if (node_fs_1.default.existsSync(legacy)) {
+        return legacy;
+    }
+    return preferred;
+}
+function readBaselineSha(cwd = process.cwd()) {
+    const filePath = getBaselineStatePath(cwd);
+    if (!node_fs_1.default.existsSync(filePath)) {
+        return null;
+    }
+    const parsed = JSON.parse(node_fs_1.default.readFileSync(filePath, "utf8"));
+    return parsed.baselineSha ?? null;
+}
+function readReleaseTargets(cwd = process.cwd()) {
+    const filePath = getBaselineStatePath(cwd);
+    if (!node_fs_1.default.existsSync(filePath)) {
+        return [];
+    }
+    const parsed = JSON.parse(node_fs_1.default.readFileSync(filePath, "utf8"));
+    return parsed.releaseTargets ?? [];
+}
+function writeBaselineSha(cwd = process.cwd(), sha, releaseTargets = []) {
+    const baselineSha = sha ??
+        (0, node_child_process_1.execFileSync)("git", ["rev-parse", "HEAD"], {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    const filePath = getBaselineStatePath(cwd);
+    const next = {
+        baselineSha,
+        releaseTargets,
+    };
+    node_fs_1.default.writeFileSync(filePath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+}

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

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

package/dist/app/release/verify.js

@@ -0,0 +1,5 @@
+"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/cli/index.js

@@ -4,22 +4,47 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+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 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");
+const pr_js_1 = require("../app/release/pr.js");
+const release_js_1 = require("../app/release/release.js");
+const verify_js_1 = require("../app/release/verify.js");
+const changelog_js_1 = require("../domain/release/changelog.js");
+const plan_js_1 = require("../domain/release/plan.js");
 function printVerifyResult() {
-    const result = (0, verify_project_js_1.verifyProject)();
+    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}`);
     }
     return result.ok ? 0 : 1;
 }
-function main() {
+async function main() {
     const [, , command, ...args] = process.argv;
+    if (!command || command === "run") {
+        const subject = (0, node_child_process_1.execFileSync)("git", ["log", "-1", "--pretty=%s"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        if ((0, pr_js_1.isReleaseCommitMessage)(subject)) {
+            const message = await (0, release_js_1.runSimpleRelease)(process.cwd());
+            console.log(message);
+            return 0;
+        }
+        const plan = (0, plan_js_1.createSimplePlan)();
+        if (!plan.nextVersion) {
+            console.log("No releasable commits found. Nothing to do.");
+            return 0;
+        }
+        const pr = (0, pr_js_1.prepareSimpleReleasePr)();
+        (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);
+        console.log(`Prepared release PR branch ${pr.branch}`);
+        console.log(`Title: ${pr.title}`);
+        console.log(reviewResult);
+        return 0;
+    }
     if (command === "verify") {
         return printVerifyResult();
     }
@@ -41,7 +66,9 @@ function main() {
             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 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");
@@ -50,16 +77,32 @@ function main() {
     }
     if (command === "pr") {
         const pr = (0, pr_js_1.prepareSimpleReleasePr)();
+        (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);
         console.log(`Prepared release PR branch ${pr.branch}`);
         console.log(`Title: ${pr.title}`);
+        console.log(reviewResult);
+        return 0;
+    }
+    if (command === "release") {
+        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     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");
     return 1;
 }
-process.exit(main());
+main()
+    .then((code) => process.exit(code))
+    .catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process.exit(1);
+});

package/dist/config/load-config.js

@@ -7,27 +7,20 @@ 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.");
+    throw new Error("Unsupported config format. Use versionary.jsonc or versionary.json.");
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function findConfigFile(cwd) {
     for (const candidate of SUPPORTED_FILES) {
@@ -41,10 +34,13 @@ function findConfigFile(cwd) {
 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.");
+        throw new Error("No Versionary config found. Create versionary.jsonc (preferred) or versionary.json.");
     }
     const raw = node_fs_1.default.readFileSync(found.path, "utf8");
     const parsed = parseConfig(raw, found.format);
+    if (!isRecord(parsed)) {
+        throw new Error("Invalid config: expected an object at the root.");
+    }
     const validated = schema_js_1.configSchema.parse(parsed);
     return {
         path: found.path,

package/dist/config/schema.d.ts

@@ -1,99 +1,39 @@
 import { z } from "zod";
 export declare const configSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
-    mode: z.ZodOptional<z.ZodEnum<{
-        simple: "simple";
-        standard: "standard";
+    "review-mode": z.ZodOptional<z.ZodEnum<{
+        direct: "direct";
+        review: "review";
     }>>;
-    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<{
+    "version-file": z.ZodOptional<z.ZodString>;
+    "changelog-file": z.ZodOptional<z.ZodString>;
+    "release-branch": z.ZodOptional<z.ZodString>;
+    "baseline-file": z.ZodOptional<z.ZodString>;
+    "bootstrap-sha": z.ZodOptional<z.ZodString>;
+    "monorepo-mode": z.ZodOptional<z.ZodEnum<{
+        independent: "independent";
+        fixed: "fixed";
+    }>>;
+    "bump-minor-pre-major": z.ZodOptional<z.ZodBoolean>;
+    "allow-stable-major": z.ZodOptional<z.ZodBoolean>;
+    "include-commit-authors": z.ZodOptional<z.ZodBoolean>;
+    "release-type": z.ZodOptional<z.ZodString>;
+    packages: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        "release-type": z.ZodOptional<z.ZodString>;
+        "package-name": z.ZodOptional<z.ZodString>;
+        "exclude-paths": z.ZodOptional<z.ZodArray<z.ZodString>>;
+        "extra-files": z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
                 json: "json";
                 toml: "toml";
                 yaml: "yaml";
                 regex: "regex";
             }>;
-            path: z.ZodOptional<z.ZodString>;
+            path: z.ZodString;
+            jsonpath: 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>>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type ConfigSchema = z.infer<typeof configSchema>;

package/dist/config/schema.js

@@ -3,91 +3,30 @@ 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(),
+    type: zod_1.z.enum(["json", "toml", "yaml", "regex"]),
+    path: zod_1.z.string().min(1),
+    jsonpath: 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(),
+    "release-type": zod_1.z.string().optional(),
+    "package-name": zod_1.z.string().optional(),
+    "exclude-paths": zod_1.z.array(zod_1.z.string()).optional(),
+    "extra-files": zod_1.z.array(artifactRuleSchema).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(),
+    "review-mode": zod_1.z.enum(["direct", "review"]).optional(),
+    "version-file": zod_1.z.string().optional(),
+    "changelog-file": zod_1.z.string().optional(),
+    "release-branch": zod_1.z.string().optional(),
+    "baseline-file": zod_1.z.string().optional(),
+    "bootstrap-sha": zod_1.z.string().optional(),
+    "monorepo-mode": zod_1.z.enum(["independent", "fixed"]).optional(),
+    "bump-minor-pre-major": zod_1.z.boolean().optional(),
+    "allow-stable-major": zod_1.z.boolean().optional(),
+    "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(),
 });

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

@@ -0,0 +1,12 @@
+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 prependChangelog(cwd: string, changelogFile: string, section: string): void;

package/dist/domain/release/changelog.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderSimpleReleaseNotes = renderSimpleReleaseNotes;
+exports.renderSimpleChangelog = renderSimpleChangelog;
+exports.prependChangelog = prependChangelog;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const commits_js_1 = require("../../infra/git/commits.js");
+const repo_url_js_1 = require("../../infra/git/repo-url.js");
+function formatDate() {
+    return new Date().toISOString().slice(0, 10);
+}
+function formatCommitMessage(subject) {
+    const conventional = subject.match(/^[a-z]+(?:\(([^)]+)\))?!?:\s+(.+)$/iu);
+    if (!conventional) {
+        return { label: "", message: subject };
+    }
+    const scope = conventional[1]?.trim();
+    const message = conventional[2]?.trim() ?? subject;
+    const label = scope ? `**${scope}:** ` : "";
+    return { label, message };
+}
+function formatCommitReferences(commit, repoBaseUrl) {
+    const references = commit.references ?? [];
+    if (references.length === 0) {
+        return "";
+    }
+    return references
+        .map((reference) => {
+        const issue = reference.issue;
+        if (!issue) {
+            return "";
+        }
+        const action = (reference.action?.trim() || "refs").toLowerCase();
+        if (!repoBaseUrl) {
+            return `${action} #${issue}`;
+        }
+        return `${action} [#${issue}](${repoBaseUrl}/issues/${issue})`;
+    })
+        .filter((entry) => entry.length > 0)
+        .join(", ");
+}
+function groupCommitLines(commits, repoUrl) {
+    const breaking = [];
+    const features = [];
+    const fixes = [];
+    for (const commit of commits) {
+        const type = (0, commits_js_1.inferReleaseTypeFromParsedCommit)(commit);
+        if (!type) {
+            continue;
+        }
+        const { label, message } = formatCommitMessage(commit.subject);
+        const short = commit.hash.slice(0, 7);
+        const hashLabel = repoUrl
+            ? `[\`${short}\`](${repoUrl}/commit/${commit.hash})`
+            : `\`${short}\``;
+        const references = formatCommitReferences(commit, repoUrl);
+        const referencesSuffix = references ? `, ${references}` : "";
+        const line = `- ${label}${message} (${hashLabel})${referencesSuffix}`;
+        const commitType = (commit.type ?? "").toLowerCase();
+        const isBreaking = type === "major";
+        if (isBreaking) {
+            breaking.push(line);
+        }
+        if (commitType === "feat" || (!isBreaking && type === "minor")) {
+            features.push(line);
+            continue;
+        }
+        if (commitType === "fix" ||
+            commitType === "perf" ||
+            (!isBreaking && type === "patch")) {
+            fixes.push(line);
+        }
+    }
+    return { breaking, features, fixes };
+}
+function renderSimpleReleaseNotes(input, options = {}) {
+    const repoUrl = (0, repo_url_js_1.resolveRepositoryWebBaseUrl)(input.cwd ?? process.cwd());
+    const header = repoUrl
+        ? `## [${input.nextVersion}](${repoUrl}/compare/v${input.currentVersion}...v${input.nextVersion}) (${formatDate()})`
+        : `## ${input.nextVersion} (${formatDate()})`;
+    const grouped = groupCommitLines(input.commits, repoUrl);
+    const sections = [];
+    if (grouped.breaking.length > 0) {
+        sections.push("### Breaking changes", ...grouped.breaking, "");
+    }
+    if (grouped.features.length > 0) {
+        sections.push("### Features", ...grouped.features, "");
+    }
+    if (grouped.fixes.length > 0) {
+        sections.push("### Bug Fixes", ...grouped.fixes, "");
+    }
+    const lines = [header, "", ...sections];
+    if (options.includeFooter) {
+        lines.push("This PR was generated by Versionary.");
+    }
+    return lines.join("\n");
+}
+function renderSimpleChangelog(plan) {
+    if (!plan.nextVersion) {
+        return "";
+    }
+    return renderSimpleReleaseNotes({
+        currentVersion: plan.currentVersion,
+        nextVersion: plan.nextVersion,
+        commits: plan.commits,
+        cwd: process.cwd(),
+    });
+}
+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/domain/release/plan.d.ts

@@ -0,0 +1,21 @@
+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;