@versatiles/release-tool 2.6.0 → 2.7.1

package/dist/commands/release-npm.js

@@ -1,10 +1,16 @@
 #!/usr/bin/env npx tsx
 import { readFileSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
 import select from '@inquirer/select';
+import { updateChangelog } from '../lib/changelog.js';
+import { releaseError, validationError } from '../lib/errors.js';
+import { COMMIT_TYPES, getGit, getSuggestedBump, groupCommitsByType, parseConventionalCommit, } from '../lib/git.js';
 import { check, info, panic, warn } from '../lib/log.js';
+import { withRetry } from '../lib/retry.js';
 import { Shell } from '../lib/shell.js';
-import { getGit } from '../lib/git.js';
-import { resolve } from 'path';
+/**
+ * Type guard to validate package.json structure.
+ */
 function isValidPackageJson(pkg) {
     if (typeof pkg !== 'object' || pkg === null)
         return false;
@@ -14,6 +20,38 @@ function isValidPackageJson(pkg) {
         return false;
     return true;
 }
+/**
+ * Executes the npm release process.
+ *
+ * This function performs a complete release workflow:
+ * 1. Validates git state (correct branch, no uncommitted changes)
+ * 2. Pulls latest changes from remote
+ * 3. Verifies npm authentication
+ * 4. Prompts for new version (with suggestion based on conventional commits)
+ * 5. Runs project checks
+ * 6. Updates package.json version
+ * 7. Updates CHANGELOG.md
+ * 8. Publishes to npm (if not private)
+ * 9. Creates git commit and tag
+ * 10. Pushes to remote and creates GitHub release
+ *
+ * @param directory - The project directory containing package.json
+ * @param branch - The git branch to release from (default: 'main')
+ * @param dryRun - If true, simulate the release without making changes
+ * @throws {VrtError} If any step in the release process fails
+ *
+ * @example
+ * ```ts
+ * // Standard release from main branch
+ * await release('/path/to/project');
+ *
+ * // Dry run to preview release
+ * await release('/path/to/project', 'main', true);
+ *
+ * // Release from a different branch
+ * await release('/path/to/project', 'release');
+ * ```
+ */
 export async function release(directory, branch = 'main', dryRun = false) {
     const shell = new Shell(directory);
     const { getCommitsBetween, getCurrentGitHubCommit, getLastGitHubTag } = getGit(directory);
@@ -24,8 +62,10 @@ export async function release(directory, branch = 'main', dryRun = false) {
         panic(`current branch is "${currentBranch}" but should be "${branch}"`);
     // git: check if no changes
     await check('are all changes committed?', checkThatNoUncommittedChanges());
-    // git: pull
-    await check('git pull', shell.run('git pull -t'));
+    // git: pull (with retry for transient network failures)
+    await check('git pull', withRetry(() => shell.run('git pull -t'), {
+        onRetry: (attempt, error) => warn(`git pull failed (attempt ${attempt}): ${error.message}, retrying...`),
+    }));
     // check package.json
     const pkgRaw = JSON.parse(readFileSync(resolve(directory, 'package.json'), 'utf8'));
     if (!isValidPackageJson(pkgRaw))
@@ -35,6 +75,11 @@ export async function release(directory, branch = 'main', dryRun = false) {
     if (!('prepack' in pkgRaw.scripts))
         panic('missing npm script "prepack" in package.json');
     const pkg = pkgRaw;
+    const isPrivatePackage = pkg.private === true;
+    // npm: verify authentication (skip for private packages)
+    if (!isPrivatePackage) {
+        await check('verify npm authentication', verifyNpmAuth());
+    }
     // get last version
     const tag = await check('get last github tag', getLastGitHubTag());
     const shaLast = tag?.sha;
@@ -44,10 +89,14 @@ export async function release(directory, branch = 'main', dryRun = false) {
         warn(`versions differ in package.json (${versionLastPackage}) and last GitHub tag (${versionLastGithub})`);
     // get current sha
     const { sha: shaCurrent } = await check('get current github commit', getCurrentGitHubCommit());
-    // handle version
-    const nextVersion = await getNewVersion(versionLastPackage);
-    // prepare release notes
-    const releaseNotes = await check('prepare release notes', getReleaseNotes(nextVersion, shaLast, shaCurrent));
+    // get and parse commits for conventional commit support
+    const commits = await check('get commits since last release', getCommitsBetween(shaLast, shaCurrent));
+    const parsedCommits = commits.map(parseConventionalCommit);
+    // handle version (with suggested bump based on conventional commits)
+    const nextVersion = await getNewVersion(versionLastPackage, parsedCommits);
+    // prepare release notes (grouped by conventional commit type)
+    const releaseNotes = getReleaseNotes(nextVersion, parsedCommits);
+    info('prepared release notes');
     if (dryRun) {
         info('Dry-run mode - the following actions would be performed:');
         info(`  Version: ${versionLastPackage} -> ${nextVersion}`);
@@ -56,13 +105,14 @@ export async function release(directory, branch = 'main', dryRun = false) {
         info('  Commands that would be executed:');
         info('    npm run check');
         info('    npm i --package-lock-only');
-        if (!('private' in pkg) || !pkg.private) {
+        info('    Update CHANGELOG.md');
+        if (!isPrivatePackage) {
             info('    npm publish --access public');
         }
         info('    git add .');
         info(`    git commit -m "v${nextVersion}"`);
         info(`    git tag -f -a "v${nextVersion}" -m "new release: v${nextVersion}"`);
-        info('    git push --no-verify --follow-tags');
+        info('    git push --atomic --no-verify --follow-tags');
         info(`    gh release create/edit "v${nextVersion}"`);
         info('Dry-run complete - no changes were made');
         return;
@@ -71,29 +121,58 @@ export async function release(directory, branch = 'main', dryRun = false) {
     await check('run checks', shell.run('npm run check'));
     // update version
     await check('update version', setNextVersion(nextVersion));
-    if (!('private' in pkg) || !pkg.private) {
-        // npm publish
-        await check('npm publish', shell.runInteractive('npm publish --access public'));
+    // update changelog
+    const changelogResult = updateChangelog(directory, nextVersion, parsedCommits);
+    if (changelogResult.created) {
+        info('created CHANGELOG.md');
+    }
+    else {
+        info('updated CHANGELOG.md');
+    }
+    if (!isPrivatePackage) {
+        // npm publish (with retry for transient network failures)
+        await check('npm publish', withRetry(() => shell.runInteractive('npm publish --access public'), {
+            onRetry: (attempt, error) => warn(`npm publish failed (attempt ${attempt}): ${error.message}, retrying...`),
+        }));
     }
     // git push
     await check('git add', shell.run('git add .'));
-    await check('git commit', shell.run(`git commit -m "v${nextVersion}"`, false));
+    await check('git commit', shell.run(`git commit -m "v${nextVersion}"`));
     await check('git tag', shell.run(`git tag -f -a "v${nextVersion}" -m "new release: v${nextVersion}"`));
-    await check('git push', shell.run('git push --no-verify --follow-tags'));
-    // github release
+    await check('git push', withRetry(() => shell.run('git push --atomic --no-verify --follow-tags'), {
+        onRetry: (attempt, error) => warn(`git push failed (attempt ${attempt}): ${error.message}, retrying...`),
+    }));
+    // github release (with retry for transient network failures)
     const releaseTag = `v${nextVersion}`;
     if (await check('check github release', shell.ok(`gh release view ${releaseTag}`))) {
-        await check('edit release', shell.exec('gh', ['release', 'edit', releaseTag, '--notes', releaseNotes]));
+        await check('edit release', withRetry(() => shell.exec('gh', ['release', 'edit', releaseTag, '--notes', releaseNotes]), {
+            onRetry: (attempt, error) => warn(`gh release edit failed (attempt ${attempt}): ${error.message}, retrying...`),
+        }));
     }
     else {
-        await check('create release', shell.exec('gh', ['release', 'create', releaseTag, '--notes', releaseNotes]));
+        await check('create release', withRetry(() => shell.exec('gh', ['release', 'create', releaseTag, '--notes', releaseNotes]), {
+            onRetry: (attempt, error) => warn(`gh release create failed (attempt ${attempt}): ${error.message}, retrying...`),
+        }));
     }
     info('Finished');
     return;
+    async function verifyNpmAuth() {
+        try {
+            const username = await shell.stdout('npm whoami');
+            if (!username || username.trim().length === 0) {
+                throw releaseError('npm authentication failed: no username returned');
+            }
+            info(`authenticated as npm user: ${username.trim()}`);
+        }
+        catch {
+            throw releaseError('npm authentication required. Please run "npm login" first.\n' +
+                'If you are using a CI environment, ensure NPM_TOKEN is set.');
+        }
+    }
     async function checkThatNoUncommittedChanges() {
         if ((await shell.stdout('git status --porcelain')).length < 3)
             return;
-        throw Error('please commit all changes before releasing');
+        throw releaseError('please commit all changes before releasing');
     }
     async function setNextVersion(version) {
         // set new version in package.json
@@ -103,30 +182,76 @@ export async function release(directory, branch = 'main', dryRun = false) {
         // rebuild package.json
         await shell.run('npm i --package-lock-only');
     }
-    async function getReleaseNotes(version, hashLast, hashCurrent) {
-        const commits = await getCommitsBetween(hashLast, hashCurrent);
-        let notes = commits
-            .reverse()
-            .map((commit) => '- ' + commit.message.replace(/\s+/g, ' '))
-            .join('\n');
-        notes = `# Release v${version}\n\nchanges:\n${notes}\n\n`;
+    function getReleaseNotes(version, commits) {
+        const reversed = [...commits].reverse();
+        const grouped = groupCommitsByType(reversed);
+        let notes = `# Release v${version}\n\n`;
+        // Order: breaking changes first, then features, fixes, and others
+        const typeOrder = [
+            'feat',
+            'fix',
+            'perf',
+            'refactor',
+            'docs',
+            'test',
+            'build',
+            'ci',
+            'chore',
+            'style',
+            'revert',
+            'other',
+        ];
+        // Add breaking changes section if any
+        const breakingCommits = reversed.filter((c) => c.breaking);
+        if (breakingCommits.length > 0) {
+            notes += '## Breaking Changes\n\n';
+            for (const commit of breakingCommits) {
+                notes += `- ${commit.description.replace(/\s+/g, ' ')}\n`;
+            }
+            notes += '\n';
+        }
+        // Add grouped commits
+        for (const type of typeOrder) {
+            const typeCommits = grouped.get(type);
+            if (!typeCommits || typeCommits.length === 0)
+                continue;
+            // Skip commits already shown in breaking changes
+            const nonBreaking = typeCommits.filter((c) => !c.breaking);
+            if (nonBreaking.length === 0)
+                continue;
+            const label = type === 'other' ? 'Other Changes' : COMMIT_TYPES[type];
+            notes += `## ${label}\n\n`;
+            for (const commit of nonBreaking) {
+                const scope = commit.scope ? `**${commit.scope}:** ` : '';
+                notes += `- ${scope}${commit.description.replace(/\s+/g, ' ')}\n`;
+            }
+            notes += '\n';
+        }
         return notes;
     }
-    async function getNewVersion(versionPackage) {
-        // ask for new version
+    async function getNewVersion(versionPackage, commits) {
+        // Determine suggested bump based on conventional commits
+        const suggestedBump = getSuggestedBump(commits);
+        // choices: [current, patch, minor, major] -> indices [0, 1, 2, 3]
+        const suggestedIndex = suggestedBump === 'major' ? 3 : suggestedBump === 'minor' ? 2 : 1;
         const choices = [{ value: versionPackage }, { ...bump(2) }, { ...bump(1) }, { ...bump(0) }];
+        // Add recommendation label to suggested version
+        const suggestedChoice = choices[suggestedIndex];
+        if (suggestedChoice && 'name' in suggestedChoice) {
+            suggestedChoice.name += ' (recommended)';
+        }
         const versionNew = await select({
             message: 'What should be the new version?',
             choices,
-            default: choices[1].value,
+            default: suggestedChoice?.value ?? choices[1].value,
         });
         if (!versionNew)
-            throw Error();
+            throw releaseError('no version selected');
         return versionNew;
         function bump(index) {
             const p = versionPackage.split('.').map((v) => parseInt(v, 10));
             if (p.length !== 3)
-                throw Error();
+                throw validationError('invalid version format, expected x.y.z');
             switch (index) {
                 case 0:
                     p[0]++;

package/dist/lib/benchmark.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Performance benchmarking utilities for CLI operations.
+ *
+ * Provides timing measurement and optional logging for tracking
+ * execution duration of key operations.
+ */
+/**
+ * Result of a benchmarked operation
+ */
+export interface BenchmarkResult<T> {
+    /** The result returned by the benchmarked function */
+    result: T;
+    /** Execution duration in milliseconds */
+    durationMs: number;
+    /** Human-readable duration string */
+    durationFormatted: string;
+}
+/**
+ * Options for benchmark execution
+ */
+export interface BenchmarkOptions {
+    /** Label for the operation being benchmarked */
+    label?: string;
+    /** Whether to log timing to console */
+    log?: boolean;
+    /** Custom logger function (defaults to console.log) */
+    logger?: (message: string) => void;
+}
+/**
+ * Formats a duration in milliseconds to a human-readable string.
+ *
+ * @param ms - Duration in milliseconds
+ * @returns Formatted duration string (e.g., "1.23s", "456ms")
+ */
+export declare function formatDuration(ms: number): string;
+/**
+ * Measures the execution time of a synchronous function.
+ *
+ * @param fn - The function to benchmark
+ * @param options - Optional benchmark configuration
+ * @returns The function result along with timing information
+ *
+ * @example
+ * ```ts
+ * const { result, durationMs } = benchmarkSync(() => {
+ *   return heavyComputation();
+ * }, { label: 'Heavy computation', log: true });
+ * ```
+ */
+export declare function benchmarkSync<T>(fn: () => T, options?: BenchmarkOptions): BenchmarkResult<T>;
+/**
+ * Measures the execution time of an asynchronous function.
+ *
+ * @param fn - The async function to benchmark
+ * @param options - Optional benchmark configuration
+ * @returns Promise resolving to the function result along with timing information
+ *
+ * @example
+ * ```ts
+ * const { result, durationMs } = await benchmark(async () => {
+ *   return await fetchData();
+ * }, { label: 'API fetch', log: true });
+ * ```
+ */
+export declare function benchmark<T>(fn: () => Promise<T>, options?: BenchmarkOptions): Promise<BenchmarkResult<T>>;
+/**
+ * Creates a timer for manual timing control.
+ *
+ * @returns Timer object with start, stop, and elapsed methods
+ *
+ * @example
+ * ```ts
+ * const timer = createTimer();
+ * timer.start();
+ * // ... do work ...
+ * const elapsed = timer.stop();
+ * console.log(`Operation took ${elapsed.durationFormatted}`);
+ * ```
+ */
+export declare function createTimer(): {
+    start: () => void;
+    stop: () => {
+        durationMs: number;
+        durationFormatted: string;
+    };
+    elapsed: () => number;
+    isRunning: () => boolean;
+};
+/**
+ * Aggregates multiple benchmark results for statistical analysis.
+ */
+export interface BenchmarkStats {
+    /** Number of samples */
+    count: number;
+    /** Total duration in milliseconds */
+    totalMs: number;
+    /** Average duration in milliseconds */
+    avgMs: number;
+    /** Minimum duration in milliseconds */
+    minMs: number;
+    /** Maximum duration in milliseconds */
+    maxMs: number;
+    /** Formatted average duration */
+    avgFormatted: string;
+}
+/**
+ * Calculates statistics from an array of benchmark durations.
+ *
+ * @param durations - Array of duration values in milliseconds
+ * @returns Statistical summary of the benchmarks
+ *
+ * @example
+ * ```ts
+ * const durations = [100, 150, 120, 130, 110];
+ * const stats = calculateStats(durations);
+ * console.log(`Average: ${stats.avgFormatted}`);
+ * ```
+ */
+export declare function calculateStats(durations: number[]): BenchmarkStats;

package/dist/lib/benchmark.js

@@ -0,0 +1,148 @@
+/**
+ * Performance benchmarking utilities for CLI operations.
+ *
+ * Provides timing measurement and optional logging for tracking
+ * execution duration of key operations.
+ */
+/**
+ * Formats a duration in milliseconds to a human-readable string.
+ *
+ * @param ms - Duration in milliseconds
+ * @returns Formatted duration string (e.g., "1.23s", "456ms")
+ */
+export function formatDuration(ms) {
+    if (ms >= 1000) {
+        return `${(ms / 1000).toFixed(2)}s`;
+    }
+    return `${Math.round(ms)}ms`;
+}
+/**
+ * Measures the execution time of a synchronous function.
+ *
+ * @param fn - The function to benchmark
+ * @param options - Optional benchmark configuration
+ * @returns The function result along with timing information
+ *
+ * @example
+ * ```ts
+ * const { result, durationMs } = benchmarkSync(() => {
+ *   return heavyComputation();
+ * }, { label: 'Heavy computation', log: true });
+ * ```
+ */
+export function benchmarkSync(fn, options = {}) {
+    const { label, log = false, logger = console.log } = options;
+    const start = performance.now();
+    const result = fn();
+    const end = performance.now();
+    const durationMs = end - start;
+    const durationFormatted = formatDuration(durationMs);
+    if (log && label) {
+        logger(`[benchmark] ${label}: ${durationFormatted}`);
+    }
+    return { result, durationMs, durationFormatted };
+}
+/**
+ * Measures the execution time of an asynchronous function.
+ *
+ * @param fn - The async function to benchmark
+ * @param options - Optional benchmark configuration
+ * @returns Promise resolving to the function result along with timing information
+ *
+ * @example
+ * ```ts
+ * const { result, durationMs } = await benchmark(async () => {
+ *   return await fetchData();
+ * }, { label: 'API fetch', log: true });
+ * ```
+ */
+export async function benchmark(fn, options = {}) {
+    const { label, log = false, logger = console.log } = options;
+    const start = performance.now();
+    const result = await fn();
+    const end = performance.now();
+    const durationMs = end - start;
+    const durationFormatted = formatDuration(durationMs);
+    if (log && label) {
+        logger(`[benchmark] ${label}: ${durationFormatted}`);
+    }
+    return { result, durationMs, durationFormatted };
+}
+/**
+ * Creates a timer for manual timing control.
+ *
+ * @returns Timer object with start, stop, and elapsed methods
+ *
+ * @example
+ * ```ts
+ * const timer = createTimer();
+ * timer.start();
+ * // ... do work ...
+ * const elapsed = timer.stop();
+ * console.log(`Operation took ${elapsed.durationFormatted}`);
+ * ```
+ */
+export function createTimer() {
+    let startTime = null;
+    let endTime = null;
+    return {
+        start() {
+            startTime = performance.now();
+            endTime = null;
+        },
+        stop() {
+            if (startTime === null) {
+                throw new Error('Timer was not started');
+            }
+            endTime = performance.now();
+            const durationMs = endTime - startTime;
+            return { durationMs, durationFormatted: formatDuration(durationMs) };
+        },
+        elapsed() {
+            if (startTime === null) {
+                return 0;
+            }
+            const end = endTime ?? performance.now();
+            return end - startTime;
+        },
+        isRunning() {
+            return startTime !== null && endTime === null;
+        },
+    };
+}
+/**
+ * Calculates statistics from an array of benchmark durations.
+ *
+ * @param durations - Array of duration values in milliseconds
+ * @returns Statistical summary of the benchmarks
+ *
+ * @example
+ * ```ts
+ * const durations = [100, 150, 120, 130, 110];
+ * const stats = calculateStats(durations);
+ * console.log(`Average: ${stats.avgFormatted}`);
+ * ```
+ */
+export function calculateStats(durations) {
+    if (durations.length === 0) {
+        return {
+            count: 0,
+            totalMs: 0,
+            avgMs: 0,
+            minMs: 0,
+            maxMs: 0,
+            avgFormatted: '0ms',
+        };
+    }
+    const totalMs = durations.reduce((sum, d) => sum + d, 0);
+    const avgMs = totalMs / durations.length;
+    return {
+        count: durations.length,
+        totalMs,
+        avgMs,
+        minMs: Math.min(...durations),
+        maxMs: Math.max(...durations),
+        avgFormatted: formatDuration(avgMs),
+    };
+}
+//# sourceMappingURL=benchmark.js.map

package/dist/lib/changelog.d.ts

@@ -0,0 +1,23 @@
+import { type ParsedCommit } from './git.js';
+/**
+ * Generates a changelog entry for a release from parsed commits.
+ *
+ * @param version - The version being released
+ * @param commits - Array of parsed conventional commits
+ * @param date - The release date (defaults to today)
+ * @returns Formatted changelog entry string
+ */
+export declare function generateChangelogEntry(version: string, commits: ParsedCommit[], date?: Date): string;
+/**
+ * Updates or creates a CHANGELOG.md file with a new release entry.
+ *
+ * @param directory - The project directory containing CHANGELOG.md
+ * @param version - The version being released
+ * @param commits - Array of parsed conventional commits
+ * @param date - The release date (defaults to today)
+ * @returns Object indicating whether the file was created or updated
+ */
+export declare function updateChangelog(directory: string, version: string, commits: ParsedCommit[], date?: Date): {
+    created: boolean;
+    path: string;
+};

package/dist/lib/changelog.js

@@ -0,0 +1,117 @@
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+import { COMMIT_TYPES, groupCommitsByType } from './git.js';
+/**
+ * Generates a changelog entry for a release from parsed commits.
+ *
+ * @param version - The version being released
+ * @param commits - Array of parsed conventional commits
+ * @param date - The release date (defaults to today)
+ * @returns Formatted changelog entry string
+ */
+export function generateChangelogEntry(version, commits, date = new Date()) {
+    const dateStr = date.toISOString().split('T')[0];
+    const reversed = [...commits].reverse();
+    const grouped = groupCommitsByType(reversed);
+    let entry = `## [${version}] - ${dateStr}\n\n`;
+    // Order: breaking changes first, then features, fixes, and others
+    const typeOrder = [
+        'feat',
+        'fix',
+        'perf',
+        'refactor',
+        'docs',
+        'test',
+        'build',
+        'ci',
+        'chore',
+        'style',
+        'revert',
+        'other',
+    ];
+    // Add breaking changes section if any
+    const breakingCommits = reversed.filter((c) => c.breaking);
+    if (breakingCommits.length > 0) {
+        entry += '### Breaking Changes\n\n';
+        for (const commit of breakingCommits) {
+            entry += `- ${commit.description.replace(/\s+/g, ' ')}\n`;
+        }
+        entry += '\n';
+    }
+    // Add grouped commits
+    for (const type of typeOrder) {
+        const typeCommits = grouped.get(type);
+        if (!typeCommits || typeCommits.length === 0)
+            continue;
+        // Skip commits already shown in breaking changes
+        const nonBreaking = typeCommits.filter((c) => !c.breaking);
+        if (nonBreaking.length === 0)
+            continue;
+        const label = type === 'other' ? 'Other Changes' : COMMIT_TYPES[type];
+        entry += `### ${label}\n\n`;
+        for (const commit of nonBreaking) {
+            const scope = commit.scope ? `**${commit.scope}:** ` : '';
+            entry += `- ${scope}${commit.description.replace(/\s+/g, ' ')}\n`;
+        }
+        entry += '\n';
+    }
+    return entry;
+}
+/**
+ * Default changelog header for new CHANGELOG.md files
+ */
+const DEFAULT_CHANGELOG_HEADER = `# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+`;
+/**
+ * Updates or creates a CHANGELOG.md file with a new release entry.
+ *
+ * @param directory - The project directory containing CHANGELOG.md
+ * @param version - The version being released
+ * @param commits - Array of parsed conventional commits
+ * @param date - The release date (defaults to today)
+ * @returns Object indicating whether the file was created or updated
+ */
+export function updateChangelog(directory, version, commits, date = new Date()) {
+    const changelogPath = resolve(directory, 'CHANGELOG.md');
+    const entry = generateChangelogEntry(version, commits, date);
+    let content;
+    let created = false;
+    if (existsSync(changelogPath)) {
+        const existing = readFileSync(changelogPath, 'utf8');
+        // Insert new entry after the header (after the first double newline or at the start if no header)
+        const headerEndIndex = findHeaderEnd(existing);
+        content = existing.slice(0, headerEndIndex) + entry + existing.slice(headerEndIndex);
+    }
+    else {
+        content = DEFAULT_CHANGELOG_HEADER + entry;
+        created = true;
+    }
+    writeFileSync(changelogPath, content);
+    return { created, path: changelogPath };
+}
+/**
+ * Finds the end of the changelog header section.
+ * Looks for patterns like "# Changelog" followed by description text,
+ * ending before the first "## " section header.
+ */
+function findHeaderEnd(content) {
+    // Look for the first version section (## [x.y.z] or ## x.y.z)
+    const versionSectionMatch = content.match(/^## \[?\d+\.\d+\.\d+\]?/m);
+    if (versionSectionMatch?.index !== undefined) {
+        return versionSectionMatch.index;
+    }
+    // If no version section found, look for any ## heading
+    const anySectionMatch = content.match(/^## /m);
+    if (anySectionMatch?.index !== undefined) {
+        return anySectionMatch.index;
+    }
+    // No sections found, append at end (after ensuring trailing newline)
+    return content.endsWith('\n') ? content.length : content.length;
+}
+//# sourceMappingURL=changelog.js.map