versionary 0.2.0 → 0.3.0

package/dist/plugins/runtime.d.ts

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

package/dist/plugins/runtime.js

@@ -1,24 +1,5 @@
 "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;
-}
+exports.loadRuntimePlugins = void 0;
+var runtime_js_1 = require("../infra/scm/runtime.js");
+Object.defineProperty(exports, "loadRuntimePlugins", { enumerable: true, get: function () { return runtime_js_1.loadRuntimePlugins; } });

package/dist/scm/github-plugin.js

@@ -17,13 +17,56 @@ function getRepoFromEnv() {
     return parseRepoSlug(slug);
 }
 function getGitHubToken() {
-    const token = process.env.VERSIONARY_PR_TOKEN ?? process.env.GH_TOKEN ?? process.env.GITHUB_TOKEN;
+    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) {
+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;
     }
@@ -35,8 +78,12 @@ async function ensureLabels(octokit, repo, pullNumber, labels) {
             labels,
         });
     }
-    catch {
-        // Best effort: label may not exist or permissions may be restricted.
+    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() {
@@ -46,45 +93,80 @@ function createGitHubPlugin() {
         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({
+            const listHead = resolveHeadForList(repo, input.headBranch);
+            let existing;
+            try {
+                const response = await octokit.pulls.list({
                     owner: repo.owner,
                     repo: repo.repo,
-                    pull_number: pr.number,
-                    title: input.title,
-                    body: input.body,
+                    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,
                 });
-                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",
+                    state: toReviewRequestState(updated, `pull request #${updated.number} in ${repoRef(repo)}`),
                 };
             }
-            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,
+            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,
             });
-            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",
+                state: toReviewRequestState(created, `pull request #${created.number} in ${repoRef(repo)}`),
             };
         },
         async createReleaseMetadata(input, _context) {
@@ -96,19 +178,30 @@ function createGitHubPlugin() {
                     repo: repo.repo,
                     tag: input.tag,
                 });
-                return { url: existing.data.html_url };
+                return { url: existing.data.html_url, status: "exists" };
             }
-            catch {
-                // Continue with create flow when release does not exist.
+            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}`);
+                }
             }
-            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 };
+            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

@@ -21,6 +21,7 @@ export interface VersionaryConfig {
     "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>;

package/dist/types/plugins.d.ts

@@ -19,6 +19,7 @@ export interface VersionaryScmReleaseMetadataInput {
 }
 export interface VersionaryScmReleaseMetadataResult {
     url: string;
+    status?: "created" | "exists";
 }
 export interface VersionaryPluginContext {
     cwd: string;

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,7 +16,8 @@ function verifyProject(cwd = process.cwd()) {
         ok: true,
         details: `Loaded ${node_path_1.default.basename(config.path)} (${config.format})`,
     });
-    const versionFile = config.config["version-file"] ?? "version.txt";
+    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}`,

package/package.json

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

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,46 +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"));
-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);
-}
-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 = [
-        versionHeading,
-        "",
-        ...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");
-}
-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,10 +0,0 @@
-import type { ReleaseType } from "./semver.js";
-export interface CommitInfo {
-    hash: string;
-    subject: string;
-}
-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;

package/dist/simple/git.js

@@ -1,114 +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.getCommitsSinceLastTag = getCommitsSinceLastTag;
-exports.getCommitsForPath = getCommitsForPath;
-exports.inferReleaseTypeFromSubject = inferReleaseTypeFromSubject;
-exports.isReleasableCommit = isReleasableCommit;
-exports.analyzeCommits = analyzeCommits;
-const node_path_1 = __importDefault(require("node:path"));
-const node_child_process_1 = require("node:child_process");
-function getReleaseBranchExcludeArgs(cwd) {
-    const releaseBranchesRaw = (0, node_child_process_1.execFileSync)("git", ["branch", "--list", "--format", "%(refname:short)"], {
-        cwd,
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-    });
-    const releaseBranches = releaseBranchesRaw
-        .split("\n")
-        .map((line) => line.trim())
-        .filter((line) => line.startsWith("versionary/release"));
-    return releaseBranches.flatMap((branch) => ["--exclude", branch]);
-}
-function resolveBaseRef(cwd, baselineSha) {
-    const excludeArgs = getReleaseBranchExcludeArgs(cwd);
-    let baseRef = baselineSha ?? "";
-    if (!baseRef) {
-        try {
-            const cmd = ["describe", "--tags", "--abbrev=0", "--match", "v[0-9]*", ...excludeArgs];
-            baseRef = (0, node_child_process_1.execFileSync)("git", cmd, {
-                cwd,
-                encoding: "utf8",
-                stdio: ["ignore", "pipe", "ignore"],
-            }).trim();
-        }
-        catch {
-            baseRef = "";
-        }
-    }
-    return baseRef;
-}
-function readGitLog(cwd, range, pathspecs = []) {
-    const output = (0, node_child_process_1.execFileSync)("git", ["log", range, "--pretty=format:%H%x09%s", "--", ...pathspecs], {
-        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 getCommitsSinceLastTag(cwd = process.cwd(), baselineSha) {
-    const baseRef = resolveBaseRef(cwd, baselineSha);
-    const range = baseRef ? `${baseRef}..HEAD` : "HEAD";
-    return readGitLog(cwd, range);
-}
-function getCommitsForPath(cwd = process.cwd(), baselineSha, packagePath = ".", excludePaths = []) {
-    const baseRef = resolveBaseRef(cwd, baselineSha);
-    const range = baseRef ? `${baseRef}..HEAD` : "HEAD";
-    const normalizedPackagePath = packagePath === "." ? "." : packagePath;
-    const excludes = excludePaths.map((excludePath) => {
-        const combined = normalizedPackagePath === "."
-            ? excludePath
-            : node_path_1.default.posix.join(normalizedPackagePath, excludePath);
-        return `:(exclude)${combined}`;
-    });
-    return readGitLog(cwd, range, [normalizedPackagePath, ...excludes]);
-}
-function inferReleaseTypeFromSubject(subject) {
-    if (/^revert:\s/i.test(subject)) {
-        return null;
-    }
-    if (/^chore(\(.+\))?:\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)(\(.+\))?:\s/i.test(subject)) {
-        return "patch";
-    }
-    return null;
-}
-function isReleasableCommit(subject) {
-    return inferReleaseTypeFromSubject(subject) !== 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/semver.d.ts

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

@@ -1,25 +0,0 @@
-"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/simple/state.d.ts

@@ -1,3 +0,0 @@
-export declare function getBaselineStatePath(cwd: string): string;
-export declare function readBaselineSha(cwd?: string): string | null;
-export declare function writeBaselineSha(cwd?: string, sha?: string): void;