versionary 0.1.0 → 0.2.0

package/README.md

@@ -1,23 +1,55 @@
 # versionary
 
-Versionary is a software-agnostic automated release tool focused on SemVer, conventional commits, release PR workflows, and extensibility.
+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)
+Schema URL for editor support:
+
+- `https://raw.githubusercontent.com/jolars/versionary/main/schemas/versionary-schema.json`
+
+## Config (manifest style)
 
 For a quick trial, use:
 
-- `versionary.jsonc` with `"mode": "simple"`
-- `version.txt` as the version source
-- `CHANGELOG.md` as release notes output
+- `version-file` (default `version.txt`) as version source
+- `changelog-file` (default `CHANGELOG.md`) as release notes output
+- stable release branch (`release-branch`, default:
+  `versionary/release`) so release PRs are updated in-place
+- `baseline-file` (default `.versionary-manifest.json`) tracks baseline SHA for deterministic commit
+  ranges independent of tags
+- review mode (`review-mode`): `review` (PR/MR style) or `direct` (no
+  review request)
+- optional monorepo planning with `monorepo-mode` and `packages`:
+  - `independent` computes package bumps per path
+  - `fixed` computes one shared bump across configured package paths
 
 Commands:
 
 - `pnpm verify`
+- `pnpm run` (default orchestration: no-op, create/update release PR, or publish
+  release based on context)
 - `pnpm plan`
 - `pnpm changelog -- --write`
 - `pnpm pr`
+- `pnpm release`
+
+`pnpm pr` prepares release commit + branch and opens/updates the review request
+via SCM plugin capability. `pnpm run` is the recommended CI entrypoint and
+auto-dispatches between PR/update and release publish.
+
+For first-run bootstrapping, set `bootstrap-sha` (similar to release-please). Subsequent runs use
+the baseline state file.
+
+## Built-in plugins
+
+Versionary ships with built-in SCM plugin support:
+
+- `github` (default): review request + release metadata
+
+Package publication is intentionally out of scope in the current release flow.
+Use separate CI workflows for publishing after Versionary has prepared/tagged the release.
 
 ## Install from GitHub
 
@@ -31,4 +63,5 @@ You can install directly from a git ref:
 }
 ```
 
-The package runs a `prepare` build during git installation so the `versionary` CLI binary is available after `pnpm install`.
+The package runs a `prepare` build during git installation so the `versionary`
+CLI binary is available after `pnpm install`.

package/dist/cli/index.js

@@ -6,9 +6,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 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("../simple/plan.js");
 const changelog_js_1 = require("../simple/changelog.js");
 const pr_js_1 = require("../simple/pr.js");
+const release_js_1 = require("../simple/release.js");
 const verify_project_js_1 = require("../verify/verify-project.js");
 function printVerifyResult() {
     const result = (0, verify_project_js_1.verifyProject)();
@@ -18,8 +20,31 @@ function printVerifyResult() {
     }
     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.commits);
+        console.log(`Prepared release PR branch ${pr.branch}`);
+        console.log(`Title: ${pr.title}`);
+        console.log(reviewResult);
+        return 0;
+    }
     if (command === "verify") {
         return printVerifyResult();
     }
@@ -50,16 +75,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.commits);
         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

@@ -29,6 +29,9 @@ function parseConfig(raw, format) {
     }
     throw new Error("JavaScript config loading is not implemented yet. Use JSONC/JSON/TOML for now.");
 }
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
 function findConfigFile(cwd) {
     for (const candidate of SUPPORTED_FILES) {
         const candidatePath = node_path_1.default.join(cwd, candidate.file);
@@ -45,6 +48,9 @@ function loadConfig(cwd = process.cwd()) {
     }
     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,38 @@
 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>;
+    "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,29 @@ 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(),
+    "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/index.d.ts

@@ -1,3 +1,6 @@
-export type { VersionaryConfig, VersionaryPackage, VersionaryPluginRef, VersionaryArtifactRule, } from "./types/config.js";
+export type { VersionaryConfig, VersionaryPackage, VersionaryArtifactRule, } from "./types/config.js";
+export type { VersionaryPluginCapability, VersionaryPluginContext, VersionaryPluginRuntime, VersionaryScmReviewRequestInput, VersionaryScmReviewRequestResult, VersionaryScmReleaseMetadataInput, VersionaryScmReleaseMetadataResult, } from "./types/plugins.js";
 export { loadConfig } from "./config/load-config.js";
+export { findPluginsByCapability, pluginHasCapability } from "./plugins/capabilities.js";
+export { loadRuntimePlugins } from "./plugins/runtime.js";
 export { verifyProject } from "./verify/verify-project.js";

package/dist/index.js

@@ -1,7 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifyProject = exports.loadConfig = void 0;
+exports.verifyProject = exports.loadRuntimePlugins = exports.pluginHasCapability = exports.findPluginsByCapability = 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 capabilities_js_1 = require("./plugins/capabilities.js");
+Object.defineProperty(exports, "findPluginsByCapability", { enumerable: true, get: function () { return capabilities_js_1.findPluginsByCapability; } });
+Object.defineProperty(exports, "pluginHasCapability", { enumerable: true, get: function () { return capabilities_js_1.pluginHasCapability; } });
+var runtime_js_1 = require("./plugins/runtime.js");
+Object.defineProperty(exports, "loadRuntimePlugins", { enumerable: true, get: function () { return runtime_js_1.loadRuntimePlugins; } });
 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/plugins/capabilities.d.ts

@@ -0,0 +1,3 @@
+import type { VersionaryPluginCapability, VersionaryPluginRuntime } from "../types/plugins.js";
+export declare function pluginHasCapability(plugin: VersionaryPluginRuntime, capability: VersionaryPluginCapability): boolean;
+export declare function findPluginsByCapability(plugins: VersionaryPluginRuntime[], capability: VersionaryPluginCapability): VersionaryPluginRuntime[];

package/dist/plugins/capabilities.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluginHasCapability = pluginHasCapability;
+exports.findPluginsByCapability = findPluginsByCapability;
+function pluginHasCapability(plugin, capability) {
+    return plugin.capabilities.includes(capability);
+}
+function findPluginsByCapability(plugins, capability) {
+    return plugins.filter((plugin) => pluginHasCapability(plugin, capability));
+}

package/dist/plugins/runtime.d.ts

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

package/dist/plugins/runtime.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRuntimePlugins = loadRuntimePlugins;
+const load_config_js_1 = require("../config/load-config.js");
+const github_plugin_js_1 = require("../scm/github-plugin.js");
+const BUILTIN_PLUGIN_FACTORIES = {
+    github: 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, github_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;
+}

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

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

package/dist/scm/github-plugin.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGitHubPlugin = createGitHubPlugin;
+const rest_1 = require("@octokit/rest");
+function parseRepoSlug(input) {
+    const [owner, repo] = input.split("/");
+    if (!owner || !repo) {
+        throw new Error(`Invalid repo slug "${input}". Expected "owner/repo".`);
+    }
+    return { owner, repo };
+}
+function getRepoFromEnv() {
+    const slug = process.env.GITHUB_REPOSITORY;
+    if (!slug) {
+        throw new Error("Missing GITHUB_REPOSITORY environment variable.");
+    }
+    return parseRepoSlug(slug);
+}
+function getGitHubToken() {
+    const token = process.env.VERSIONARY_PR_TOKEN ?? process.env.GH_TOKEN ?? process.env.GITHUB_TOKEN;
+    if (!token) {
+        throw new Error("Missing GitHub token. Set VERSIONARY_PR_TOKEN, GH_TOKEN, or GITHUB_TOKEN.");
+    }
+    return token;
+}
+async function ensureLabels(octokit, repo, pullNumber, labels) {
+    if (labels.length === 0) {
+        return;
+    }
+    try {
+        await octokit.issues.addLabels({
+            owner: repo.owner,
+            repo: repo.repo,
+            issue_number: pullNumber,
+            labels,
+        });
+    }
+    catch {
+        // Best effort: label may not exist or permissions may be restricted.
+    }
+}
+function createGitHubPlugin() {
+    return {
+        name: "github",
+        capabilities: ["scm.reviewRequest", "scm.releaseMetadata"],
+        async createOrUpdateReviewRequest(input, _context) {
+            const repo = getRepoFromEnv();
+            const octokit = new rest_1.Octokit({ auth: getGitHubToken() });
+            const { data: existing } = await octokit.pulls.list({
+                owner: repo.owner,
+                repo: repo.repo,
+                state: "open",
+                head: `${repo.owner}:${input.headBranch}`,
+                base: input.baseBranch,
+                per_page: 1,
+            });
+            if (existing.length > 0) {
+                const pr = existing[0];
+                const { data: updated } = await octokit.pulls.update({
+                    owner: repo.owner,
+                    repo: repo.repo,
+                    pull_number: pr.number,
+                    title: input.title,
+                    body: input.body,
+                });
+                await ensureLabels(octokit, repo, updated.number, input.labels ?? []);
+                return {
+                    id: String(updated.id),
+                    number: updated.number,
+                    url: updated.html_url,
+                    state: updated.state === "open" ? "open" : "closed",
+                };
+            }
+            const { data: created } = await octokit.pulls.create({
+                owner: repo.owner,
+                repo: repo.repo,
+                title: input.title,
+                head: input.headBranch,
+                base: input.baseBranch,
+                body: input.body,
+            });
+            await ensureLabels(octokit, repo, created.number, input.labels ?? []);
+            return {
+                id: String(created.id),
+                number: created.number,
+                url: created.html_url,
+                state: created.state === "open" ? "open" : "closed",
+            };
+        },
+        async createReleaseMetadata(input, _context) {
+            const repo = getRepoFromEnv();
+            const octokit = new rest_1.Octokit({ auth: getGitHubToken() });
+            try {
+                const existing = await octokit.repos.getReleaseByTag({
+                    owner: repo.owner,
+                    repo: repo.repo,
+                    tag: input.tag,
+                });
+                return { url: existing.data.html_url };
+            }
+            catch {
+                // Continue with create flow when release does not exist.
+            }
+            const { data } = await octokit.repos.createRelease({
+                owner: repo.owner,
+                repo: repo.repo,
+                tag_name: input.tag,
+                name: input.tag,
+                body: input.notes,
+            });
+            return { url: data.html_url };
+        },
+    };
+}

package/dist/simple/changelog.js

@@ -7,6 +7,8 @@ exports.renderSimpleChangelog = renderSimpleChangelog;
 exports.prependChangelog = prependChangelog;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
+const git_js_1 = require("./git.js");
+const repo_url_js_1 = require("./repo-url.js");
 function formatDate() {
     return new Date().toISOString().slice(0, 10);
 }
@@ -14,10 +16,22 @@ function renderSimpleChangelog(plan) {
     if (!plan.nextVersion) {
         return "";
     }
+    const repoUrl = (0, repo_url_js_1.resolveRepositoryWebBaseUrl)(process.cwd());
+    const versionHeading = repoUrl
+        ? `## [${plan.nextVersion}](${repoUrl}/compare/v${plan.currentVersion}...v${plan.nextVersion}) (${formatDate()})`
+        : `## ${plan.nextVersion} - ${formatDate()}`;
     const lines = [
-        `## ${plan.nextVersion} - ${formatDate()}`,
+        versionHeading,
         "",
-        ...plan.commits.map((commit) => `- ${commit.subject} (${commit.hash.slice(0, 7)})`),
+        ...plan.commits
+            .filter((commit) => (0, git_js_1.isReleasableCommit)(commit.subject))
+            .map((commit) => {
+            const short = commit.hash.slice(0, 7);
+            if (!repoUrl) {
+                return `- ${commit.subject} (\`${short}\`)`;
+            }
+            return `- ${commit.subject} ([\`${short}\`](${repoUrl}/commit/${commit.hash}))`;
+        }),
         "",
     ];
     return lines.join("\n");

package/dist/simple/git.d.ts

@@ -3,5 +3,8 @@ export interface CommitInfo {
     hash: string;
     subject: string;
 }
-export declare function getCommitsSinceLastTag(cwd?: string): CommitInfo[];
+export declare function getCommitsSinceLastTag(cwd?: string, baselineSha?: string | null): CommitInfo[];
+export declare function getCommitsForPath(cwd?: string, baselineSha?: string | null, packagePath?: string, excludePaths?: string[]): CommitInfo[];
+export declare function inferReleaseTypeFromSubject(subject: string): ReleaseType;
+export declare function isReleasableCommit(subject: string): boolean;
 export declare function analyzeCommits(commits: CommitInfo[]): ReleaseType;