changelog-machine 1.1.0 → 2.1.0

package/lib/contributors/resolve.js

@@ -0,0 +1,86 @@
+import { groupAuthorCommits } from './authors.js';
+import { readBitbucketProfile, readGitHubProfile } from './profile.js';
+import { getCommitEndpoint, getRepositoryToken, parseRepository, } from './repository.js';
+const REQUEST_TIMEOUT_MS = 5_000;
+const MAX_CONCURRENT_REQUESTS = 3;
+const MAX_ATTEMPTS_PER_AUTHOR = 2;
+function readProfile(data, repository) {
+    return repository.host === 'github.com'
+        ? readGitHubProfile(data)
+        : readBitbucketProfile(data);
+}
+async function requestProfile(repository, hash, token) {
+    try {
+        const headers = new Headers({ accept: 'application/json' });
+        if (token)
+            headers.set('authorization', `Bearer ${token}`);
+        const response = await fetch(getCommitEndpoint(repository, hash), {
+            headers,
+            redirect: 'error',
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        });
+        if ([401, 403, 429].includes(response.status))
+            return { stop: true };
+        if (!response.ok)
+            return { stop: false };
+        return {
+            profile: readProfile(await response.json(), repository),
+            stop: false,
+        };
+    }
+    catch {
+        return { stop: false };
+    }
+}
+export async function resolveContributors(commits, repositoryUrl, onProgress) {
+    const repository = parseRepository(repositoryUrl);
+    if (!repository)
+        return {};
+    const supportedRepository = repository;
+    const authors = groupAuthorCommits(commits);
+    const profiles = {};
+    const token = getRepositoryToken(repository);
+    let next = 0;
+    let stopped = false;
+    const progress = {
+        completed: 0,
+        total: authors.length,
+        resolved: 0,
+        requests: 0,
+    };
+    const report = () => onProgress?.({ ...progress });
+    report();
+    async function resolveAuthor(hashes) {
+        for (const hash of hashes.slice(0, MAX_ATTEMPTS_PER_AUTHOR)) {
+            if (stopped)
+                return;
+            progress.requests++;
+            report();
+            const result = await requestProfile(supportedRepository, hash, token);
+            if (result.stop) {
+                if (!stopped)
+                    console.error('Contributor lookup stopped: authentication failed or API rate limit reached. Using Git author names for unresolved contributors.');
+                stopped = true;
+                return;
+            }
+            if (result.profile) {
+                progress.resolved++;
+                for (const authorHash of hashes)
+                    profiles[authorHash] = result.profile;
+                return;
+            }
+        }
+    }
+    async function worker() {
+        while (!stopped) {
+            const hashes = authors[next++];
+            if (!hashes)
+                return;
+            await resolveAuthor(hashes);
+            progress.completed++;
+            report();
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(MAX_CONCURRENT_REQUESTS, authors.length) }, worker));
+    return profiles;
+}

package/lib/git/command.d.ts

@@ -0,0 +1,5 @@
+export declare class GitError extends Error {
+    readonly exitCode: number | null;
+    constructor(message: string, exitCode?: number | null);
+}
+export declare function git(args: string[], cwd?: string): Promise<string>;

package/lib/git/command.js

@@ -0,0 +1,39 @@
+import { spawn } from 'node:child_process';
+export class GitError extends Error {
+    exitCode;
+    constructor(message, exitCode = null) {
+        super(message);
+        this.name = 'GitError';
+        this.exitCode = exitCode;
+    }
+}
+export async function git(args, cwd) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('git', args, {
+            cwd,
+            shell: false,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: Object.assign({}, process.env, { ['GIT_TERMINAL_PROMPT']: '0' }),
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.setEncoding('utf8');
+        child.stderr.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk;
+        });
+        const context = `git ${args.map((arg) => JSON.stringify(arg)).join(' ')} in ${cwd ?? process.cwd()}`;
+        child.on('error', (error) => {
+            reject(new GitError(`Could not run ${context}: ${error.message}. Check that Git is installed and the working directory exists.`));
+        });
+        child.on('close', (code, signal) => {
+            if (code === 0)
+                resolve(stdout);
+            else
+                reject(new GitError(`${context} failed (${signal ? `signal ${signal}` : `exit ${code}`}): ${stderr.trim() || 'no diagnostic output'}`, code));
+        });
+    });
+}

package/lib/git/commits.d.ts

@@ -0,0 +1,2 @@
+import type { Commit } from '../types.js';
+export declare function readCommits(range: string, cwd?: string): Promise<Commit[]>;

package/lib/git/commits.js

@@ -0,0 +1,27 @@
+import { git } from './command.js';
+export async function readCommits(range, cwd) {
+    const format = '%H%x00%aN%x00%aE%x00%s%x00%b';
+    const fieldsPerCommit = 5;
+    const output = await git([
+        'log',
+        '--reverse',
+        '--topo-order',
+        '--no-merges',
+        '-z',
+        `--format=${format}`,
+        range,
+        '--',
+    ], cwd);
+    if (!output)
+        return [];
+    const fields = output.split('\0');
+    if (fields.pop() !== '' || fields.length % fieldsPerCommit !== 0) {
+        throw new Error('Git returned an invalid NUL-delimited commit log.');
+    }
+    const commits = [];
+    for (let index = 0; index < fields.length; index += fieldsPerCommit) {
+        const [hash, name, email, subject, body] = fields.slice(index, index + fieldsPerCommit);
+        commits.push({ hash, name, email, subject, body });
+    }
+    return commits;
+}

package/lib/git/history.d.ts

@@ -0,0 +1,3 @@
+import type { Release } from '../types.js';
+export declare function getLatestReleaseTag(cwd?: string): Promise<string | undefined>;
+export declare function getReleases(cwd?: string, afterTag?: string): Promise<Release[]>;

package/lib/git/history.js

@@ -0,0 +1,41 @@
+import { readCommits } from './commits.js';
+import { readGitMetadata, readTagsInHistory, resolveBoundary, validateTagChain, } from './refs.js';
+async function readReleaseRanges(tags, cwd, boundary) {
+    const releases = [];
+    for (let index = 0; index < tags.length; index++) {
+        const current = tags[index];
+        const previous = tags[index + 1] ?? (index === tags.length - 1 ? boundary : undefined);
+        releases.push({
+            tag: current.tag,
+            ...(previous ? { previousTag: previous.tag } : {}),
+            commits: await readCommits(previous ? `${previous.hash}..${current.hash}` : current.hash, cwd),
+        });
+    }
+    return releases;
+}
+export async function getLatestReleaseTag(cwd) {
+    const metadata = await readGitMetadata(cwd);
+    const tags = await readTagsInHistory(metadata, cwd, undefined, true);
+    await validateTagChain(tags, cwd);
+    return tags[0]?.tag;
+}
+export async function getReleases(cwd, afterTag) {
+    const metadata = await readGitMetadata(cwd);
+    const boundary = afterTag === undefined
+        ? undefined
+        : await resolveBoundary(afterTag, metadata, cwd);
+    const tags = await readTagsInHistory(metadata, cwd, boundary);
+    await validateTagChain(tags, cwd, boundary);
+    const base = tags[0] ?? boundary;
+    const hasUnreleasedRange = base ? metadata.head !== base.hash : true;
+    const releases = hasUnreleasedRange || afterTag !== undefined
+        ? [
+            {
+                tag: 'Unreleased',
+                ...(base ? { previousTag: base.tag } : {}),
+                commits: await readCommits(base ? `${base.hash}..${metadata.head}` : metadata.head, cwd),
+            },
+        ]
+        : [];
+    return [...releases, ...(await readReleaseRanges(tags, cwd, boundary))];
+}

package/lib/git/refs.d.ts

@@ -0,0 +1,12 @@
+export type VersionTag = {
+    tag: string;
+    hash: string;
+};
+export type GitMetadata = {
+    head: string;
+    tagsByHash: Map<string, string[]>;
+};
+export declare function readGitMetadata(cwd?: string): Promise<GitMetadata>;
+export declare function resolveBoundary(afterTag: string, metadata: GitMetadata, cwd?: string): Promise<VersionTag>;
+export declare function readTagsInHistory(metadata: GitMetadata, cwd?: string, boundary?: VersionTag, decoratedOnly?: boolean): Promise<VersionTag[]>;
+export declare function validateTagChain(tags: VersionTag[], cwd?: string, boundary?: VersionTag): Promise<void>;

package/lib/git/refs.js

@@ -0,0 +1,101 @@
+import { GitError, git } from './command.js';
+import { isVersionTag } from './tags.js';
+async function requireFullHistory(cwd) {
+    if ((await git(['rev-parse', '--is-shallow-repository'], cwd)).trim() === 'true') {
+        throw new Error('Cannot generate releases from a shallow repository. Fetch the full history with git fetch --unshallow (including tags), then retry.');
+    }
+}
+async function readTagRefs(cwd) {
+    const output = await git([
+        'for-each-ref',
+        '--format=%(refname:strip=2)%00%(objecttype)%00%(objectname)%00%(*objectname)%00',
+        'refs/tags/',
+    ], cwd);
+    const tagsByHash = new Map();
+    const fields = output.split('\0');
+    if (fields.at(-1) === '')
+        fields.pop();
+    for (let index = 0; index + 3 < fields.length; index += 4) {
+        const [rawTag, rawType, rawObjectHash, rawPeeledHash] = fields.slice(index, index + 4);
+        const tag = rawTag.trim();
+        const type = rawType.trim();
+        const hash = type === 'tag' ? rawPeeledHash.trim() : rawObjectHash.trim();
+        if (!tag || !hash || !isVersionTag(tag))
+            continue;
+        const names = tagsByHash.get(hash) ?? [];
+        names.push(tag);
+        tagsByHash.set(hash, names);
+    }
+    return tagsByHash;
+}
+export async function readGitMetadata(cwd) {
+    await requireFullHistory(cwd);
+    const [head, tagsByHash] = await Promise.all([
+        git(['rev-parse', '--verify', 'HEAD^{commit}'], cwd).then((value) => value.trim()),
+        readTagRefs(cwd),
+    ]);
+    return { head, tagsByHash };
+}
+async function isAncestor(older, newer, cwd) {
+    try {
+        await git(['merge-base', '--is-ancestor', older, newer], cwd);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof GitError && error.exitCode === 1)
+            return false;
+        throw error;
+    }
+}
+export async function resolveBoundary(afterTag, metadata, cwd) {
+    if (!isVersionTag(afterTag))
+        throw new Error(`Invalid version tag: ${afterTag}`);
+    const found = [...metadata.tagsByHash].find(([, names]) => names.includes(afterTag));
+    if (!found)
+        throw new Error(`Release boundary tag not found: ${afterTag}`);
+    const boundary = { tag: afterTag, hash: found[0] };
+    if (!(await isAncestor(boundary.hash, metadata.head, cwd))) {
+        throw new Error(`Release boundary tag is not reachable from HEAD: ${afterTag}`);
+    }
+    return boundary;
+}
+export async function readTagsInHistory(metadata, cwd, boundary, decoratedOnly = false) {
+    const args = ['rev-list', '--topo-order'];
+    if (decoratedOnly)
+        args.push('--simplify-by-decoration');
+    args.push(metadata.head);
+    if (boundary)
+        args.push(`^${boundary.hash}`);
+    const output = await git(args, cwd);
+    const tags = [];
+    const encountered = new Set();
+    const hashes = output.trim().split('\n');
+    if (boundary)
+        hashes.push(boundary.hash);
+    for (const hash of hashes) {
+        if (!hash || encountered.has(hash))
+            continue;
+        encountered.add(hash);
+        const names = metadata.tagsByHash.get(hash);
+        if (!names?.length)
+            continue;
+        if (names.length > 1) {
+            throw new Error(`Ambiguous release tags point to the same commit: ${names.join(', ')}.`);
+        }
+        if (hash !== boundary?.hash)
+            tags.push({ tag: names[0], hash });
+    }
+    return tags;
+}
+export async function validateTagChain(tags, cwd, boundary) {
+    for (let index = 1; index < tags.length; index++) {
+        if (!(await isAncestor(tags[index].hash, tags[index - 1].hash, cwd))) {
+            throw new Error(`Ambiguous release tags: ${tags[index - 1].tag} and ${tags[index].tag} are not ancestors of one another. Release tags must form a single ancestry chain.`);
+        }
+    }
+    if (boundary &&
+        tags.length &&
+        !(await isAncestor(boundary.hash, tags.at(-1).hash, cwd))) {
+        throw new Error(`Ambiguous release tags: ${boundary.tag} and ${tags.at(-1).tag} are not ancestors of one another. Release tags must form a single ancestry chain.`);
+    }
+}

package/lib/git/remote.d.ts

@@ -0,0 +1 @@
+export declare function getRepositoryUrl(cwd?: string): Promise<string | undefined>;

package/lib/git/remote.js

@@ -0,0 +1,59 @@
+import { GitError, git } from './command.js';
+const remoteWhitespace = /\s/;
+const supportedRemoteUrlScheme = /^(https|ssh):\/\//i;
+const scpStyleRemote = /^(?:[^@/:]+@)?([^/:]+):(.+)$/;
+const surroundingPathSlashes = /^\/+|\/+$/g;
+const gitPathSuffix = /\.git$/;
+const repositoryPathWithAtLeastTwoSegments = /^[^/]+(?:\/[^/]+)+$/;
+const queryOrFragmentMarker = /[?#]/;
+const supportedRepositoryHosts = ['github.com', 'gitlab.com', 'bitbucket.org'];
+async function readOriginRemote(cwd) {
+    try {
+        return (await git(['config', '--get', 'remote.origin.url'], cwd)).trim();
+    }
+    catch (error) {
+        if (error instanceof GitError && error.exitCode === 1)
+            return undefined;
+        throw error;
+    }
+}
+function parseRemoteHostAndPath(remote) {
+    if (supportedRemoteUrlScheme.test(remote)) {
+        try {
+            const url = new URL(remote);
+            if (url.search || url.hash)
+                return undefined;
+            return { host: url.hostname.toLowerCase(), path: url.pathname };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    const match = scpStyleRemote.exec(remote);
+    if (!match)
+        return undefined;
+    const [, host, path] = match;
+    return { host: host.toLowerCase(), path };
+}
+function isValidRepositoryPath(path) {
+    const hasTraversalSegment = path
+        .split('/')
+        .some((segment) => segment === '.' || segment === '..');
+    return (repositoryPathWithAtLeastTwoSegments.test(path) &&
+        !queryOrFragmentMarker.test(path) &&
+        !hasTraversalSegment);
+}
+export async function getRepositoryUrl(cwd) {
+    const remote = await readOriginRemote(cwd);
+    if (!remote || remoteWhitespace.test(remote))
+        return undefined;
+    const repository = parseRemoteHostAndPath(remote);
+    if (!repository || !supportedRepositoryHosts.includes(repository.host))
+        return undefined;
+    const path = repository.path
+        .replace(surroundingPathSlashes, '')
+        .replace(gitPathSuffix, '');
+    if (!isValidRepositoryPath(path))
+        return undefined;
+    return `https://${repository.host}/${path}`;
+}

package/lib/git/tags.d.ts

@@ -0,0 +1 @@
+export declare function isVersionTag(tag: string): boolean;

package/lib/git/tags.js

@@ -0,0 +1,27 @@
+const numericIdentifier = /^(0|[1-9]\d*)$/;
+const allowedIdentifierCharacters = /^[A-Za-z0-9-]+$/;
+const onlyDigits = /^\d+$/;
+function validPrerelease(value) {
+    return value
+        .split('.')
+        .every((identifier) => allowedIdentifierCharacters.test(identifier) &&
+        (!onlyDigits.test(identifier) || numericIdentifier.test(identifier)));
+}
+function validBuild(value) {
+    return value
+        .split('.')
+        .every((identifier) => allowedIdentifierCharacters.test(identifier));
+}
+export function isVersionTag(tag) {
+    const version = tag.startsWith('v') ? tag.slice(1) : tag;
+    const [release, build, extraBuild] = version.split('+');
+    if (extraBuild !== undefined || (build !== undefined && !validBuild(build)))
+        return false;
+    const prereleaseStart = release.indexOf('-');
+    const core = prereleaseStart < 0 ? release : release.slice(0, prereleaseStart);
+    const parts = core.split('.');
+    if (parts.length !== 3 ||
+        !parts.every((part) => numericIdentifier.test(part)))
+        return false;
+    return (prereleaseStart < 0 || validPrerelease(release.slice(prereleaseStart + 1)));
+}

package/lib/index.d.ts

@@ -1 +1,8 @@
-export * from './core/markdown';
+export { renderMarkdown } from './changelog/render.js';
+export { parseCommit, recommendedBump } from './commits/parse.js';
+export { resolveContributors } from './contributors/resolve.js';
+export { getLatestReleaseTag, getReleases } from './git/history.js';
+export { getRepositoryUrl } from './git/remote.js';
+export type { Commit, ContributorProfile, Options, ParsedCommit, Release, } from './types.js';
+export type { VersionPlan } from './version/plan.js';
+export { planVersion } from './version/plan.js';

package/lib/index.js

@@ -1,13 +1,6 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./core/markdown"), exports);
+export { renderMarkdown } from './changelog/render.js';
+export { parseCommit, recommendedBump } from './commits/parse.js';
+export { resolveContributors } from './contributors/resolve.js';
+export { getLatestReleaseTag, getReleases } from './git/history.js';
+export { getRepositoryUrl } from './git/remote.js';
+export { planVersion } from './version/plan.js';

package/lib/types.d.ts

@@ -0,0 +1,31 @@
+export interface Commit {
+    hash: string;
+    name: string;
+    email: string;
+    subject: string;
+    body: string;
+}
+export interface ParsedCommit extends Commit {
+    type: string;
+    scope?: string;
+    description: string;
+    breaking: boolean;
+    breakingNotes: string[];
+    pr?: string;
+}
+export interface Release {
+    tag: string;
+    previousTag?: string;
+    commits: Commit[];
+}
+export interface ContributorProfile {
+    username: string;
+    url: string;
+}
+export interface Options {
+    cwd?: string;
+    repositoryUrl?: string;
+    includeNonConventional?: boolean;
+    contributors?: Readonly<Record<string, ContributorProfile>>;
+    output?: string;
+}

package/lib/types.js

@@ -0,0 +1 @@
+export {};

package/lib/version/command.d.ts

@@ -0,0 +1,5 @@
+export declare const defaultBumpCommand = "npm version {version} --no-git-tag-version --ignore-scripts";
+export declare function validateBumpCommand(command: string): void;
+export declare function formatBumpCommand(command: string, version: string): string;
+/** Custom commands are explicitly trusted shell input, never read from Git. */
+export declare function runBumpCommand(version: string, cwd: string, command?: string): Promise<void>;

package/lib/version/command.js

@@ -0,0 +1,52 @@
+import { spawn } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { parseObject } from './json.js';
+export const defaultBumpCommand = 'npm version {version} --no-git-tag-version --ignore-scripts';
+export function validateBumpCommand(command) {
+    if (!command.trim() || !command.includes('{version}')) {
+        throw new Error('--bump-command must contain the {version} placeholder');
+    }
+}
+export function formatBumpCommand(command, version) {
+    validateBumpCommand(command);
+    if (!/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(version)) {
+        throw new Error('Bump command requires a stable semver version');
+    }
+    return command.replaceAll('{version}', version);
+}
+/** Custom commands are explicitly trusted shell input, never read from Git. */
+export async function runBumpCommand(version, cwd, command) {
+    const formatted = formatBumpCommand(command ?? defaultBumpCommand, version);
+    console.error(`Running bump command: ${formatted}`);
+    await new Promise((resolveCommand, reject) => {
+        // Avoid shell interpretation for the built-in command.
+        const child = command === undefined
+            ? spawn('npm', ['version', version, '--no-git-tag-version', '--ignore-scripts'], {
+                cwd,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                shell: process.platform === 'win32',
+            })
+            : spawn(formatted, {
+                cwd,
+                shell: true,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+        // Keep stdout reserved for changelog previews.
+        child.stdout?.pipe(process.stderr, { end: false });
+        child.stderr?.pipe(process.stderr, { end: false });
+        child.on('error', (error) => {
+            reject(new Error(`Could not start bump command: ${error.message}. Check repository files before retrying.`, { cause: error }));
+        });
+        child.on('close', (code, signal) => {
+            if (code === 0)
+                resolveCommand();
+            else
+                reject(new Error(`Bump command failed (${signal ?? `exit ${code}`}). Repository files may have changed; inspect them before retrying.`));
+        });
+    });
+    const manifest = parseObject(await readFile(resolve(cwd, 'package.json'), 'utf8'), resolve(cwd, 'package.json'));
+    if (manifest.version !== version) {
+        throw new Error(`Bump command did not set package.json version to ${version} (found ${String(manifest.version)}). Repository files may have changed; inspect them before retrying.`);
+    }
+}

package/lib/version/json.d.ts

@@ -0,0 +1,5 @@
+export type JsonObject = Record<string, unknown>;
+export declare function isObject(value: unknown): value is JsonObject;
+export declare function parseObject(text: string, path: string): JsonObject;
+export declare function formatJson(value: JsonObject, original: string): string;
+export declare function readOptionalFile(path: string): Promise<string | undefined>;

package/lib/version/json.js

@@ -0,0 +1,35 @@
+import { readFile } from 'node:fs/promises';
+const jsonIndentPattern = /(?:\r?\n)([\t ]+)"/;
+const newlinePattern = /\n/g;
+export function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function parseObject(text, path) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        throw new Error(`Invalid JSON in ${path}. Fix the file before planning a version bump.`);
+    }
+    if (!isObject(value)) {
+        throw new Error(`Expected a JSON object in ${path}. Fix the file before planning a version bump.`);
+    }
+    return value;
+}
+export function formatJson(value, original) {
+    const newline = original.includes('\r\n') ? '\r\n' : '\n';
+    const indent = original.match(jsonIndentPattern)?.[1];
+    const content = JSON.stringify(value, null, indent).replace(newlinePattern, newline);
+    return content + (original.endsWith('\n') ? newline : '');
+}
+export async function readOptionalFile(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    }
+}

package/lib/version/plan.d.ts

@@ -0,0 +1,11 @@
+import type { Commit } from '../types.js';
+export interface VersionPlan {
+    current: string;
+    next?: string;
+    bump?: 'major' | 'minor' | 'patch';
+    files: {
+        path: string;
+        content: string;
+    }[];
+}
+export declare function planVersion(commits: Commit[], latestTag: string | undefined, cwd?: string): Promise<VersionPlan>;

package/lib/version/plan.js

@@ -0,0 +1,41 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { recommendedBump } from '../commits/parse.js';
+import { parseObject } from './json.js';
+const stableVersionPattern = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+const tagPrefixPattern = /^v/;
+function readCurrentVersion(manifest) {
+    const current = manifest.version;
+    if (typeof current !== 'string' || !stableVersionPattern.test(current)) {
+        throw new Error('package.json version must be stable semver (for example 1.2.3); prerelease and build versions are unsupported.');
+    }
+    return current;
+}
+function validateLatestTag(latestTag, current) {
+    if (latestTag !== undefined &&
+        latestTag.replace(tagPrefixPattern, '') !== current) {
+        throw new Error(`Latest tag ${JSON.stringify(latestTag)} does not match package.json version ${current}. ` +
+            'Tag the current release or restore package.json and its lockfile to the latest tagged version before retrying; refusing a repeated inferred bump.');
+    }
+}
+function bumpVersion(current, bump) {
+    const parts = current.split('.').map((part) => BigInt(part));
+    const bumpIndex = { major: 0, minor: 1, patch: 2 }[bump];
+    parts[bumpIndex] += BigInt(1);
+    for (let index = bumpIndex + 1; index < parts.length; index++)
+        parts[index] = BigInt(0);
+    return parts.join('.');
+}
+export async function planVersion(commits, latestTag, cwd = process.cwd()) {
+    const packagePath = resolve(cwd, 'package.json');
+    const packageText = await readFile(packagePath, 'utf8');
+    const manifest = parseObject(packageText, packagePath);
+    const current = readCurrentVersion(manifest);
+    validateLatestTag(latestTag, current);
+    const bump = recommendedBump(commits);
+    if (!bump)
+        return { current, files: [] };
+    const next = bumpVersion(current, bump);
+    // Metadata and lockfiles are owned by the configured package-manager command.
+    return { current, next, bump, files: [] };
+}