versionary 0.1.0 → 0.3.0

package/dist/scm/github-plugin.js

@@ -0,0 +1,207 @@
+"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;
+}
+function parseGitHubError(error) {
+    const status = typeof error === "object" && error !== null && "status" in error
+        ? Number(error.status)
+        : undefined;
+    const message = error instanceof Error ? error.message : "Unknown GitHub API error";
+    return { status, message };
+}
+function repoRef(repo) {
+    return `${repo.owner}/${repo.repo}`;
+}
+function resolveHeadForList(repo, headBranch) {
+    const separator = headBranch.indexOf(":");
+    if (separator === -1) {
+        return `${repo.owner}:${headBranch}`;
+    }
+    const owner = headBranch.slice(0, separator);
+    const branch = headBranch.slice(separator + 1);
+    if (!owner || !branch || branch.includes(":")) {
+        throw new Error(`Invalid head branch "${headBranch}". Expected "branch" or "owner:branch".`);
+    }
+    return `${owner}:${branch}`;
+}
+function toReviewRequestState(pull, context) {
+    if (pull.state === "open") {
+        return "open";
+    }
+    if (pull.merged_at) {
+        return "merged";
+    }
+    if (pull.state === "closed") {
+        return "closed";
+    }
+    throw new Error(`Unexpected pull request state "${String(pull.state)}" for ${context}.`);
+}
+/**
+ * GitHub hardening contract (see tests/github-plugin-hardening-matrix.test.ts):
+ * - GITHUB_REPOSITORY must exist and use owner/repo format.
+ * - Token precedence: VERSIONARY_PR_TOKEN -> GH_TOKEN -> GITHUB_TOKEN.
+ * - Label application is best-effort for 404/422, but fails for other statuses.
+ * - Release metadata lookup treats 404 as "missing, create release"; non-404 fails.
+ */
+async function ensureLabels(octokit, repo, pullNumber, labels, branchContext) {
+    if (labels.length === 0) {
+        return;
+    }
+    try {
+        await octokit.issues.addLabels({
+            owner: repo.owner,
+            repo: repo.repo,
+            issue_number: pullNumber,
+            labels,
+        });
+    }
+    catch (error) {
+        const { status, message } = parseGitHubError(error);
+        if (status === 404 || status === 422) {
+            return;
+        }
+        throw new Error(`Failed applying labels to pull request #${pullNumber}: [${repoRef(repo)} base=${branchContext.baseBranch} head=${branchContext.headBranch}] ${message}`);
+    }
+}
+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 listHead = resolveHeadForList(repo, input.headBranch);
+            let existing;
+            try {
+                const response = await octokit.pulls.list({
+                    owner: repo.owner,
+                    repo: repo.repo,
+                    state: "open",
+                    head: listHead,
+                    base: input.baseBranch,
+                    per_page: 100,
+                });
+                existing = response.data;
+            }
+            catch (error) {
+                const { message } = parseGitHubError(error);
+                throw new Error(`Failed listing open pull requests for branch "${input.headBranch}" into "${input.baseBranch}": [${repoRef(repo)}] ${message}`);
+            }
+            if (existing.length > 1) {
+                const matches = existing.map((item) => `#${item.number}`).join(", ");
+                throw new Error(`Ambiguous open pull request matches for "${input.headBranch}" into "${input.baseBranch}": [${repoRef(repo)}] ${matches}`);
+            }
+            if (existing.length > 0) {
+                const pr = existing[0];
+                let updated;
+                try {
+                    const response = await octokit.pulls.update({
+                        owner: repo.owner,
+                        repo: repo.repo,
+                        pull_number: pr.number,
+                        title: input.title,
+                        body: input.body,
+                    });
+                    updated = response.data;
+                }
+                catch (error) {
+                    const { message } = parseGitHubError(error);
+                    throw new Error(`Failed updating pull request #${pr.number}: [${repoRef(repo)} base=${input.baseBranch} head=${input.headBranch}] ${message}`);
+                }
+                await ensureLabels(octokit, repo, updated.number, input.labels ?? [], {
+                    baseBranch: input.baseBranch,
+                    headBranch: input.headBranch,
+                });
+                return {
+                    id: String(updated.id),
+                    number: updated.number,
+                    url: updated.html_url,
+                    state: toReviewRequestState(updated, `pull request #${updated.number} in ${repoRef(repo)}`),
+                };
+            }
+            let created;
+            try {
+                const response = await octokit.pulls.create({
+                    owner: repo.owner,
+                    repo: repo.repo,
+                    title: input.title,
+                    head: input.headBranch,
+                    base: input.baseBranch,
+                    body: input.body,
+                });
+                created = response.data;
+            }
+            catch (error) {
+                const { message } = parseGitHubError(error);
+                throw new Error(`Failed creating pull request from "${input.headBranch}" into "${input.baseBranch}": [${repoRef(repo)}] ${message}`);
+            }
+            await ensureLabels(octokit, repo, created.number, input.labels ?? [], {
+                baseBranch: input.baseBranch,
+                headBranch: input.headBranch,
+            });
+            return {
+                id: String(created.id),
+                number: created.number,
+                url: created.html_url,
+                state: toReviewRequestState(created, `pull request #${created.number} in ${repoRef(repo)}`),
+            };
+        },
+        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, status: "exists" };
+            }
+            catch (error) {
+                const { status, message } = parseGitHubError(error);
+                if (status !== 404) {
+                    throw new Error(`Failed checking existing GitHub release for tag "${input.tag}": [${repoRef(repo)}] ${message}`);
+                }
+            }
+            let data;
+            try {
+                const response = await octokit.repos.createRelease({
+                    owner: repo.owner,
+                    repo: repo.repo,
+                    tag_name: input.tag,
+                    name: input.tag,
+                    body: input.notes,
+                });
+                data = response.data;
+            }
+            catch (error) {
+                const { message } = parseGitHubError(error);
+                throw new Error(`Failed creating GitHub release for tag "${input.tag}": [${repoRef(repo)}] ${message}`);
+            }
+            return { url: data.html_url, status: "created" };
+        },
+    };
+}

package/dist/strategies/node.d.ts

@@ -0,0 +1 @@
+export { nodeVersionStrategy } from "../domain/strategy/node.js";

package/dist/strategies/node.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeVersionStrategy = void 0;
+var node_js_1 = require("../domain/strategy/node.js");
+Object.defineProperty(exports, "nodeVersionStrategy", { enumerable: true, get: function () { return node_js_1.nodeVersionStrategy; } });

package/dist/strategies/resolve.d.ts

@@ -0,0 +1 @@
+export { resolveVersionStrategy } from "../domain/strategy/resolve.js";

package/dist/strategies/resolve.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveVersionStrategy = void 0;
+var resolve_js_1 = require("../domain/strategy/resolve.js");
+Object.defineProperty(exports, "resolveVersionStrategy", { enumerable: true, get: function () { return resolve_js_1.resolveVersionStrategy; } });

package/dist/strategies/simple.d.ts

@@ -0,0 +1 @@
+export { simpleVersionStrategy } from "../domain/strategy/simple.js";

package/dist/strategies/simple.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simpleVersionStrategy = void 0;
+var simple_js_1 = require("../domain/strategy/simple.js");
+Object.defineProperty(exports, "simpleVersionStrategy", { enumerable: true, get: function () { return simple_js_1.simpleVersionStrategy; } });

package/dist/strategies/types.d.ts

@@ -0,0 +1 @@
+export type { VersionStrategy } from "../domain/strategy/types.js";

package/dist/strategies/types.js

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

package/dist/types/config.d.ts

@@ -1,77 +1,31 @@
 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;
+    type: "json" | "toml" | "yaml" | "regex";
+    path: string;
+    jsonpath?: 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[];
+    "release-type"?: string;
+    "package-name"?: string;
+    "exclude-paths"?: string[];
+    "extra-files"?: VersionaryArtifactRule[];
 }
 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;
-    };
+    "review-mode"?: "direct" | "review";
+    "version-file"?: string;
+    "changelog-file"?: string;
+    "release-branch"?: string;
+    "baseline-file"?: string;
+    "bootstrap-sha"?: string;
+    "monorepo-mode"?: "independent" | "fixed";
+    "bump-minor-pre-major"?: boolean;
+    "allow-stable-major"?: boolean;
+    "include-commit-authors"?: boolean;
+    "release-type"?: string;
+    packages?: Record<string, VersionaryPackage>;
+    plugins?: string[];
 }
 export interface LoadedConfig {
     path: string;

package/dist/types/plugins.d.ts

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

package/dist/types/plugins.js

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

package/dist/verify/verify-project.js

@@ -7,6 +7,7 @@ exports.verifyProject = verifyProject;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const load_config_js_1 = require("../config/load-config.js");
+const resolve_js_1 = require("../domain/strategy/resolve.js");
 function verifyProject(cwd = process.cwd()) {
     const checks = [];
     const config = (0, load_config_js_1.loadConfig)(cwd);
@@ -15,23 +16,22 @@ function verifyProject(cwd = process.cwd()) {
         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`,
-        });
-    }
+    const strategy = (0, resolve_js_1.resolveVersionStrategy)(config.config);
+    const versionFile = strategy.getVersionFile(config.config);
+    const exists = node_fs_1.default.existsSync(node_path_1.default.join(cwd, versionFile));
+    checks.push({
+        name: `version-file:${versionFile}`,
+        ok: exists,
+        details: exists ? "Version file exists" : `Missing ${versionFile}`,
+    });
     if (config.config.packages) {
-        for (const pkg of config.config.packages) {
-            const pkgPath = node_path_1.default.join(cwd, pkg.path);
+        for (const pkgPathRaw of Object.keys(config.config.packages)) {
+            const pkgPath = node_path_1.default.join(cwd, pkgPathRaw);
             const exists = node_fs_1.default.existsSync(pkgPath);
             checks.push({
-                name: `package-path:${pkg.path}`,
+                name: `package-path:${pkgPathRaw}`,
                 ok: exists,
-                details: exists ? "Path exists" : `Missing path: ${pkg.path}`,
+                details: exists ? "Path exists" : `Missing path: ${pkgPathRaw}`,
             });
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "versionary",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Automatic release framework based on conventional commits and semantic versioning",
   "keywords": [
     "releasing",
@@ -18,7 +18,6 @@
   "license": "MIT",
   "author": "Johan Larsson",
   "type": "commonjs",
-  "packageManager": "pnpm@10.33.0",
   "bin": {
     "versionary": "dist/cli/index.js"
   },
@@ -27,17 +26,8 @@
   ],
   "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": {
+    "@octokit/rest": "^22.0.0",
     "@iarna/toml": "^2.2.5",
     "jsonc-parser": "^3.3.1",
     "zod": "^4.1.12"
@@ -46,6 +36,17 @@
     "@types/node": "^24.7.2",
     "tsx": "^4.20.6",
     "typescript": "^5.9.3",
-    "vitest": "^3.2.4"
+    "vitest": "^4.1.4"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "verify": "tsx src/cli/index.ts verify",
+    "run": "tsx src/cli/index.ts run",
+    "plan": "tsx src/cli/index.ts plan",
+    "changelog": "tsx src/cli/index.ts changelog",
+    "pr": "tsx src/cli/index.ts pr",
+    "release": "tsx src/cli/index.ts release"
   }
-}
+}

package/dist/simple/changelog.d.ts

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

@@ -1,32 +0,0 @@
-"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

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

@@ -1,61 +0,0 @@
-"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

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

@@ -1,37 +0,0 @@
-"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

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