@oorabona/release-it-preset 0.3.0

package/dist/scripts/republish-changelog.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env tsx
+/**
+ * Republish changelog script
+ *
+ * This script handles republishing an existing version without bumping.
+ * Used when a git tag exists but the package was never published to npm.
+ *
+ * Unlike normal changelog update, this script:
+ * - Uses the existing tag version from package.json
+ * - Moves [Unreleased] content to the correct version entry
+ * - Handles the case where the version entry might already exist
+ *
+ * Usage:
+ *   tsx republish-changelog.ts
+ *
+ * Environment variables:
+ *   CHANGELOG_FILE - Path to changelog file (default: CHANGELOG.md)
+ *   GITHUB_REPOSITORY - GitHub repo (owner/repo) for commit links
+ *   GIT_REMOTE - Git remote name (default: origin)
+ */
+import { readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { execSync } from 'node:child_process';
+import { getGitHubRepoUrl } from './lib/git-utils.js';
+import { escapeRegExp } from './lib/string-utils.js';
+import { validateAndNormalizeSemver } from './lib/semver-utils.js';
+export function updateReferenceLinks(changelog, versionLabels, linkTarget, unreleasedLine) {
+    const lines = changelog.split(/\r?\n/);
+    const updatedLines = [];
+    let foundUnreleasedLink = false;
+    const foundLabels = new Set();
+    const uniqueLabels = [...new Set(versionLabels)];
+    const labelRegexes = uniqueLabels.map((label) => ({
+        label,
+        regex: new RegExp(`^\\[${escapeRegExp(label)}]:`, 'i'),
+    }));
+    for (const ln of lines) {
+        if (/^\[Unreleased\]:/i.test(ln)) {
+            updatedLines.push(unreleasedLine);
+            foundUnreleasedLink = true;
+            continue;
+        }
+        const matching = labelRegexes.find(({ regex }) => regex.test(ln));
+        if (matching) {
+            updatedLines.push(`[${matching.label}]: ${linkTarget}`);
+            foundLabels.add(matching.label);
+            continue;
+        }
+        updatedLines.push(ln);
+    }
+    if (!foundUnreleasedLink) {
+        updatedLines.push(unreleasedLine);
+    }
+    const addedVersionLinks = [];
+    for (const label of uniqueLabels) {
+        if (!foundLabels.has(label)) {
+            updatedLines.push(`[${label}]: ${linkTarget}`);
+            addedVersionLinks.push(label);
+        }
+    }
+    return {
+        changelog: updatedLines.join('\n'),
+        addedUnreleasedLink: !foundUnreleasedLink,
+        addedVersionLinks,
+    };
+}
+function findExistingVersionHeading(changelog, normalizedVersion) {
+    const escapedVersion = escapeRegExp(normalizedVersion);
+    const existingHeading = new RegExp(`^##\\s*\\[(v?${escapedVersion})\\]`, 'im').exec(changelog);
+    return existingHeading?.[1] ?? null;
+}
+function getFirstVersionHeading(changelog) {
+    const headingRegex = /^##\s*\[(.*?)\]/gim;
+    for (const match of changelog.matchAll(headingRegex)) {
+        const label = match[1]?.trim();
+        if (label && !/^unreleased$/i.test(label)) {
+            return label;
+        }
+    }
+    return null;
+}
+function inferVersionHeadingLabel(versionInput, normalizedVersion, changelog) {
+    const firstHeading = getFirstVersionHeading(changelog);
+    if (firstHeading) {
+        return /^v/i.test(firstHeading) ? `v${normalizedVersion}` : normalizedVersion;
+    }
+    return versionInput.trim().toLowerCase().startsWith('v') ? `v${normalizedVersion}` : normalizedVersion;
+}
+export function republishChangelog(version, deps) {
+    const changelogPath = join(deps.getCwd(), deps.getEnv('CHANGELOG_FILE') || 'CHANGELOG.md');
+    deps.log(`ℹ️  Republishing version: ${version}`);
+    // Validate semver format
+    const normalizedVersion = validateAndNormalizeSemver(version);
+    const date = deps.getDate();
+    const tag = version.startsWith('v') ? version : `v${normalizedVersion}`;
+    const versionLabels = [`v${normalizedVersion}`, normalizedVersion];
+    const repoUrl = getGitHubRepoUrl({
+        execSync: deps.execSync,
+        getEnv: deps.getEnv,
+        warn: deps.warn,
+    });
+    let changelog = deps.readFileSync(changelogPath, 'utf8');
+    const unreleasedBlock = /^(?<prefix>[^\n]*?##\s*\[?Unreleased\]?[^\n]*\n)(?<content>[\s\S]*?)(?=^##\s|^\s*---\s*$|$(?![\s\S]))/im;
+    const match = changelog.match(unreleasedBlock);
+    if (!match || !match.groups) {
+        throw new Error('No [Unreleased] section found in CHANGELOG.md');
+    }
+    const unreleasedContent = match.groups.content.trim();
+    const escapedVersion = escapeRegExp(normalizedVersion);
+    const existingHeadingLabel = findExistingVersionHeading(changelog, normalizedVersion);
+    const versionExists = Boolean(existingHeadingLabel);
+    const versionHeadingLabel = existingHeadingLabel ?? inferVersionHeadingLabel(version, normalizedVersion, changelog);
+    if (versionExists && !unreleasedContent) {
+        deps.log(`ℹ️  Version ${tag} already exists in changelog and [Unreleased] is empty. Nothing to do.`);
+        return;
+    }
+    if (versionExists && unreleasedContent) {
+        deps.warn(`⚠️  Version ${tag} already exists in changelog but [Unreleased] has content.`);
+        deps.log(`ℹ️  Updating existing ${tag} entry with unreleased content...`);
+        const versionEntryRegex = new RegExp(`(^##\\s*\\[?(?:v?${escapedVersion})\\]?[^\\n]*\\n)((?:[\\s\\S]*?)(?=^##\\s|^\\s*---\\s*$|$(?![\\s\\S])))`, 'im');
+        const versionMatch = changelog.match(versionEntryRegex);
+        if (versionMatch) {
+            const newVersionContent = `${versionMatch[1]}\n${unreleasedContent}\n\n`;
+            changelog = changelog.replace(versionEntryRegex, newVersionContent);
+            changelog = changelog.replace(unreleasedBlock, `${match.groups.prefix}\n`);
+        }
+    }
+    else {
+        if (!unreleasedContent) {
+            throw new Error('[Unreleased] section is empty. Use populate-unreleased-changelog.ts first or add content manually.');
+        }
+        deps.log(`📝 Moving [Unreleased] content to ${tag} entry`);
+        const newEntryLines = [];
+        newEntryLines.push(`## [${versionHeadingLabel}] - ${date}`);
+        newEntryLines.push('');
+        newEntryLines.push(unreleasedContent);
+        newEntryLines.push('');
+        changelog = changelog.replace(unreleasedBlock, `${match.groups.prefix}\n${newEntryLines.join('\n')}\n`);
+    }
+    let linkTarget;
+    let unreleasedLine;
+    if (repoUrl.includes('github.com')) {
+        linkTarget = `${repoUrl}/releases/tag/${tag}`;
+        unreleasedLine = `[Unreleased]: ${repoUrl}/compare/${tag}...HEAD`;
+    }
+    else if (repoUrl.includes('gitlab')) {
+        linkTarget = `${repoUrl}/-/tags/${tag}`;
+        unreleasedLine = `[Unreleased]: ${repoUrl}/-/compare/${tag}...HEAD`;
+    }
+    else {
+        linkTarget = repoUrl;
+        unreleasedLine = `[Unreleased]: ${repoUrl}`;
+    }
+    const versionLinkLabels = [...new Set([tag, versionHeadingLabel])];
+    const updateResult = updateReferenceLinks(changelog, versionLinkLabels, linkTarget, unreleasedLine);
+    changelog = updateResult.changelog;
+    deps.writeFileSync(changelogPath, changelog, 'utf8');
+    deps.log(`✅ CHANGELOG.md updated for republish of ${tag}${repoUrl ? ` (${repoUrl})` : ''}`);
+}
+/**
+ * CLI entry point - only runs when script is executed directly
+ */
+/* c8 ignore start */
+if (import.meta.url === `file://${process.argv[1]}`) {
+    async function main() {
+        try {
+            const pkg = await import(join(process.cwd(), 'package.json'), { with: { type: 'json' } });
+            const version = pkg.default.version;
+            republishChangelog(version, {
+                execSync,
+                readFileSync,
+                writeFileSync,
+                getEnv: (key) => process.env[key],
+                getCwd: () => process.cwd(),
+                getDate: () => new Date().toISOString().split('T')[0],
+                log: console.log,
+                warn: console.warn,
+            });
+        }
+        catch (error) {
+            console.error(`❌ ${error instanceof Error ? error.message : error}`);
+            process.exit(1);
+        }
+    }
+    main();
+}
+/* c8 ignore end */

package/dist/scripts/retry-publish.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env tsx
+/**
+ * Retry publish script
+ *
+ * This script retries publishing an existing version to npm and GitHub Releases.
+ * Used when the initial publish failed but the Git tag was already created.
+ *
+ * Safety features:
+ * - Checks out the exact commit of the latest tag
+ * - Doesn't modify any Git history
+ * - Restores the original branch after publishing
+ * - Verifies the tag exists before proceeding
+ *
+ * Usage:
+ *   tsx retry-publish.ts
+ *   # Then run: release-it --config retry-publish.js
+ */
+import { execSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+export function retryPublish(deps) {
+    deps.log('🔄 Starting retry publish process...');
+    const currentBranch = deps.execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf8' }).trim();
+    deps.log(`ℹ️  Current branch: ${currentBranch}`);
+    let latestTag;
+    try {
+        latestTag = deps.execSync('git describe --tags --abbrev=0', { encoding: 'utf8' }).trim();
+        deps.log(`ℹ️  Latest tag found: ${latestTag}`);
+    }
+    catch {
+        throw new Error('No tags found in repository');
+    }
+    let tagCommit;
+    try {
+        tagCommit = deps.execSync(`git rev-parse ${latestTag}`, { encoding: 'utf8' }).trim();
+        deps.log(`ℹ️  Tag ${latestTag} points to commit: ${tagCommit.substring(0, 8)}`);
+    }
+    catch {
+        throw new Error(`Tag ${latestTag} not found`);
+    }
+    let hasUncommittedChanges = false;
+    try {
+        deps.execSync('git diff --quiet', { stdio: 'pipe' });
+        deps.execSync('git diff --cached --quiet', { stdio: 'pipe' });
+    }
+    catch {
+        hasUncommittedChanges = true;
+        deps.warn('⚠️  You have uncommitted changes. They will be preserved.');
+    }
+    let packageVersion;
+    try {
+        const packageJson = JSON.parse(deps.readFileSync('package.json', 'utf8'));
+        if (typeof packageJson.version === 'string' && packageJson.version.trim()) {
+            packageVersion = packageJson.version.trim();
+            const normalizedTag = latestTag.replace(/^v/, '');
+            if (packageVersion !== normalizedTag) {
+                deps.warn(`⚠️  package.json version (${packageVersion}) does not match latest tag (${normalizedTag}).`);
+            }
+            else {
+                deps.log(`ℹ️  package.json version (${packageVersion}) matches the latest tag.`);
+            }
+        }
+    }
+    catch (error) {
+        deps.warn(
+        /* c8 ignore next */
+        `⚠️  Unable to inspect package.json version: ${error instanceof Error ? error.message : error}`);
+    }
+    deps.log('✅ Pre-flight checks passed. Ready to retry publish.');
+    deps.log(`📦 This will republish from tag ${latestTag} to npm and GitHub Releases`);
+    deps.log('🔒 No Git history will be modified');
+    deps.log('💡 Next command: release-it --config node_modules/@oorabona/release-it-preset/config/retry-publish.js');
+    return {
+        currentBranch,
+        latestTag,
+        tagCommit,
+        hasUncommittedChanges,
+        packageVersion,
+    };
+}
+/**
+ * CLI entry point - only runs when script is executed directly
+ */
+/* c8 ignore start */
+if (import.meta.url === `file://${process.argv[1]}`) {
+    try {
+        retryPublish({
+            execSync,
+            readFileSync,
+            log: console.log,
+            warn: console.warn,
+        });
+    }
+    catch (error) {
+        console.error(`❌ Pre-flight checks failed: ${error instanceof Error ? error.message : error}`);
+        process.exit(1);
+    }
+}
+/* c8 ignore end */

package/dist/scripts/validate-release.js

@@ -0,0 +1,288 @@
+#!/usr/bin/env tsx
+/**
+ * Validate project is ready for release
+ *
+ * This script checks:
+ * - CHANGELOG.md exists and is well-formatted
+ * - [Unreleased] section has content
+ * - Working directory is clean (unless --allow-dirty)
+ * - npm authentication works (npm whoami)
+ * - Current branch is allowed (if GIT_REQUIRE_BRANCH is set)
+ *
+ * Usage:
+ *   tsx validate-release.ts [--allow-dirty]
+ *
+ * Exit codes:
+ *   0 - All validations passed
+ *   1 - Validation failed
+ */
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+export function parseArgs(argv) {
+    return {
+        allowDirty: argv.includes('--allow-dirty'),
+    };
+}
+export function validateChangelogExists(deps) {
+    const path = deps.getEnv('CHANGELOG_FILE') || 'CHANGELOG.md';
+    if (!deps.existsSync(path)) {
+        return {
+            name: 'CHANGELOG.md exists',
+            passed: false,
+            message: `File not found: ${path}`,
+        };
+    }
+    return {
+        name: 'CHANGELOG.md exists',
+        passed: true,
+    };
+}
+export function validateChangelogFormat(deps) {
+    const path = deps.getEnv('CHANGELOG_FILE') || 'CHANGELOG.md';
+    if (!deps.existsSync(path)) {
+        return {
+            name: 'CHANGELOG.md format',
+            passed: false,
+            message: 'File not found',
+        };
+    }
+    const content = deps.readFileSync(path, 'utf8');
+    // Check for Keep a Changelog format markers
+    const hasTitle = /^# /.test(content);
+    const hasUnreleased = /## \[Unreleased\]/.test(content);
+    const hasKeepAChangelogLink = /keepachangelog\.com/i.test(content);
+    if (!hasTitle) {
+        return {
+            name: 'CHANGELOG.md format',
+            passed: false,
+            message: 'Missing title (# Changelog)',
+        };
+    }
+    if (!hasUnreleased) {
+        return {
+            name: 'CHANGELOG.md format',
+            passed: false,
+            message: 'Missing [Unreleased] section',
+        };
+    }
+    if (!hasKeepAChangelogLink) {
+        return {
+            name: 'CHANGELOG.md format',
+            passed: false,
+            message: 'Not using Keep a Changelog format (missing keepachangelog.com reference)',
+        };
+    }
+    return {
+        name: 'CHANGELOG.md format',
+        passed: true,
+    };
+}
+export function validateUnreleasedHasContent(deps) {
+    const path = deps.getEnv('CHANGELOG_FILE') || 'CHANGELOG.md';
+    if (!deps.existsSync(path)) {
+        return {
+            name: '[Unreleased] has content',
+            passed: false,
+            message: 'CHANGELOG.md not found',
+        };
+    }
+    const content = deps.readFileSync(path, 'utf8');
+    const unreleasedMatch = content.match(/## \[Unreleased\]([\s\S]*?)(?=## \[|$)/);
+    if (!unreleasedMatch) {
+        return {
+            name: '[Unreleased] has content',
+            passed: false,
+            message: '[Unreleased] section not found',
+        };
+    }
+    const unreleasedContent = unreleasedMatch[1].trim();
+    if (!unreleasedContent || unreleasedContent === 'No changes yet.') {
+        return {
+            name: '[Unreleased] has content',
+            passed: false,
+            message: '[Unreleased] section is empty',
+        };
+    }
+    // Check if there's at least one change entry (starts with -)
+    const hasChanges = /^-/m.test(unreleasedContent);
+    if (!hasChanges) {
+        return {
+            name: '[Unreleased] has content',
+            passed: false,
+            message: '[Unreleased] section has no change entries',
+        };
+    }
+    return {
+        name: '[Unreleased] has content',
+        passed: true,
+    };
+}
+export function validateWorkingDirectoryClean(deps, options) {
+    if (options.allowDirty) {
+        return {
+            name: 'Working directory clean',
+            passed: true,
+            message: 'Skipped (--allow-dirty)',
+        };
+    }
+    try {
+        const status = deps.execSync('git status --porcelain', { encoding: 'utf8' }).trim();
+        if (status) {
+            return {
+                name: 'Working directory clean',
+                passed: false,
+                message: 'Uncommitted changes detected. Use --allow-dirty to skip this check.',
+            };
+        }
+        return {
+            name: 'Working directory clean',
+            passed: true,
+        };
+    }
+    catch (error) {
+        return {
+            name: 'Working directory clean',
+            passed: false,
+            message: `Failed to check git status: ${error}`,
+        };
+    }
+}
+export function validateNpmAuth(deps) {
+    try {
+        const username = deps.execSync('npm whoami', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+        return {
+            name: 'npm authentication',
+            passed: true,
+            message: `Logged in as: ${username}`,
+        };
+    }
+    catch (error) {
+        const tokenEnvVars = ['NPM_TOKEN', 'NODE_AUTH_TOKEN', 'NPM_CONFIG__AUTH', 'NPM_CONFIG_TOKEN'];
+        const hasAutomationToken = tokenEnvVars.some((name) => {
+            const value = deps.getEnv(name);
+            return typeof value === 'string' && value.trim().length > 0;
+        });
+        if (hasAutomationToken) {
+            return {
+                name: 'npm authentication',
+                passed: true,
+                message: 'Token-based authentication detected (skipped npm whoami).',
+            };
+        }
+        const ciEnv = deps.getEnv('CI');
+        if (ciEnv && ciEnv.toLowerCase() === 'true') {
+            return {
+                name: 'npm authentication',
+                passed: false,
+                message: 'npm whoami failed in CI and no auth token detected. Ensure NPM_TOKEN is configured.',
+            };
+        }
+        return {
+            name: 'npm authentication',
+            passed: false,
+            message: 'Not authenticated. Run: npm login',
+        };
+    }
+}
+export function validateBranch(deps) {
+    const requiredBranch = deps.getEnv('GIT_REQUIRE_BRANCH');
+    if (!requiredBranch) {
+        return {
+            name: 'Branch check',
+            passed: true,
+            message: 'Skipped (GIT_REQUIRE_BRANCH not set)',
+        };
+    }
+    try {
+        const currentBranch = deps.execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf8' }).trim();
+        if (currentBranch !== requiredBranch) {
+            return {
+                name: 'Branch check',
+                passed: false,
+                message: `Current branch is "${currentBranch}", but "${requiredBranch}" is required`,
+            };
+        }
+        return {
+            name: 'Branch check',
+            passed: true,
+            message: `On required branch: ${currentBranch}`,
+        };
+    }
+    catch (error) {
+        return {
+            name: 'Branch check',
+            passed: false,
+            message: `Failed to get current branch: ${error}`,
+        };
+    }
+}
+export function validateGitRepo(deps) {
+    try {
+        deps.execSync('git rev-parse --git-dir', { stdio: 'pipe' });
+        return {
+            name: 'Git repository',
+            passed: true,
+        };
+    }
+    catch {
+        return {
+            name: 'Git repository',
+            passed: false,
+            message: 'Not a git repository',
+        };
+    }
+}
+export function validateRelease(deps, options) {
+    return [
+        validateGitRepo(deps),
+        validateChangelogExists(deps),
+        validateChangelogFormat(deps),
+        validateUnreleasedHasContent(deps),
+        validateWorkingDirectoryClean(deps, options),
+        validateBranch(deps),
+        validateNpmAuth(deps),
+    ];
+}
+/**
+ * CLI entry point - only runs when script is executed directly
+ */
+/* c8 ignore start */
+if (import.meta.url === `file://${process.argv[1]}`) {
+    async function main() {
+        const options = parseArgs(process.argv.slice(2));
+        console.log('🔍 Validating release readiness...\n');
+        const deps = {
+            execSync,
+            existsSync,
+            readFileSync,
+            getEnv: (key) => process.env[key],
+        };
+        const results = validateRelease(deps, options);
+        let allPassed = true;
+        for (const result of results) {
+            const icon = result.passed ? '✅' : '❌';
+            const status = result.passed ? 'PASS' : 'FAIL';
+            console.log(`${icon} ${result.name}: ${status}`);
+            if (result.message) {
+                console.log(`   ${result.message}`);
+            }
+            if (!result.passed) {
+                allPassed = false;
+            }
+        }
+        console.log();
+        if (allPassed) {
+            console.log('✨ All validations passed! Ready to release.');
+            process.exit(0);
+        }
+        else {
+            console.log('❌ Some validations failed. Please fix the issues above before releasing.');
+            process.exit(1);
+        }
+    }
+    main().catch((error) => {
+        console.error('❌ Validation failed:', error);
+        process.exit(1);
+    });
+}
+/* c8 ignore end */

package/dist/types/check-config.d.ts

@@ -0,0 +1,65 @@
+#!/usr/bin/env tsx
+/**
+ * Check and display release configuration and project status
+ *
+ * This script displays:
+ * - Environment variables and their values
+ * - Repository information
+ * - Git tags and latest version
+ * - Commits since last tag
+ * - Configuration files status
+ *
+ * Usage:
+ *   tsx check-config.ts
+ */
+import type { ExecSyncOptions } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+export interface CheckConfigDeps {
+    execSync: (command: string, options?: ExecSyncOptions) => Buffer | string;
+    existsSync: typeof existsSync;
+    readFileSync: typeof readFileSync;
+    getEnv: (key: string) => string | undefined;
+    log: (message: string) => void;
+}
+export declare function safeExec(command: string, deps: CheckConfigDeps): string | null;
+export declare function getEnvVar(name: string, deps: CheckConfigDeps, defaultValue?: string): string;
+export interface CheckConfigResult {
+    envVars: Record<string, string>;
+    repoUrl: string | null;
+    currentBranch: string | null;
+    latestTag: string | null;
+    commitCount: number;
+    filesStatus: Record<string, boolean>;
+    npmUsername: string | null;
+}
+/**
+ * Get current git branch
+ */
+export declare function getCurrentBranch(deps: CheckConfigDeps): string | null;
+/**
+ * Get latest git tag
+ */
+export declare function getLatestTag(deps: CheckConfigDeps): string | null;
+/**
+ * Get commit count since tag (or all commits if no tag)
+ */
+export declare function getCommitCount(deps: CheckConfigDeps, latestTag: string | null): number;
+/**
+ * Get files status (existence check)
+ */
+export declare function getFilesStatus(deps: CheckConfigDeps): Record<string, boolean>;
+/**
+ * Get npm username (if logged in)
+ */
+export declare function getNpmUsername(deps: CheckConfigDeps): string | null;
+/**
+ * Get all environment variables with defaults
+ */
+export declare function getEnvironmentVariables(deps: CheckConfigDeps): Record<string, string>;
+export declare function checkConfig(deps: CheckConfigDeps): CheckConfigResult;
+export declare function displayEnvironmentVariables(envVars: Record<string, string>): void;
+export declare function displayRepositoryInfo(deps: CheckConfigDeps, repoUrl: string | null, currentBranch: string | null): void;
+export declare function displayVersionAndTags(deps: CheckConfigDeps, latestTag: string | null): void;
+export declare function displayCommitsSinceLastTag(deps: CheckConfigDeps, latestTag: string | null): void;
+export declare function displayConfigurationFiles(deps: CheckConfigDeps, filesStatus: Record<string, boolean>): void;
+export declare function displayNpmStatus(deps: CheckConfigDeps, npmUsername: string | null): void;

package/dist/types/check-pr-status.d.ts

@@ -0,0 +1,51 @@
+#!/usr/bin/env tsx
+/**
+ * Check pull request hygiene (changelog + commits)
+ *
+ * This script inspects the current git workspace to determine whether:
+ * - The changelog (respecting CHANGELOG_FILE env override) has been modified
+ * - A `[skip-changelog]` marker appears in commit messages
+ * - Commits follow the conventional commit format
+ *
+ * Results are written to `$GITHUB_OUTPUT` when available so GitHub Actions steps
+ * can consume them without relying on continue-on-error semantics.
+ */
+import type { ExecSyncOptions } from 'node:child_process';
+export type ChangelogStatus = 'updated' | 'skipped' | 'missing';
+export interface PrCheckResult {
+    baseRef: string | null;
+    headRef: string;
+    changedFiles: string[];
+    commits: string[];
+    changelogStatus: ChangelogStatus;
+    skipChangelogMarker: boolean;
+    hasConventionalCommits: boolean;
+}
+export interface PrCheckDeps {
+    execSync: (command: string, options?: ExecSyncOptions) => Buffer | string;
+    getEnv: (key: string) => string | undefined;
+    writeOutput: (name: string, value: string) => void;
+    log: (message: string) => void;
+    warn: (message: string) => void;
+}
+export declare function safeExec(command: string, deps: PrCheckDeps): string | null;
+export declare function normalizeBaseRef(baseRef: string | null | undefined): string | null;
+export declare function parseArgs(argv: string[]): {
+    base: string | null;
+    head: string | null;
+};
+export declare function splitList(value: string | null): string[];
+export declare function hasSkipChangelog(commits: string[]): boolean;
+export declare function hasConventionalCommits(commits: string[]): boolean;
+export declare function evaluateChangelogStatus(changedFiles: string[], changelogPath: string, commits: string[]): {
+    status: ChangelogStatus;
+    skipMarker: boolean;
+};
+export declare function getDiffRange(baseRef: string | null, headRef: string): string;
+export declare function runPrCheck(args: {
+    base?: string | null;
+    head?: string | null;
+}, deps: PrCheckDeps): PrCheckResult;
+export declare function createDefaultDeps(): PrCheckDeps;
+export declare function writeOutputs(result: PrCheckResult, deps: PrCheckDeps): void;
+export declare function renderSummary(result: PrCheckResult, deps: PrCheckDeps): void;