@oorabona/release-it-preset 0.3.0

package/dist/scripts/check-config.js

@@ -0,0 +1,285 @@
+#!/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 { execSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { getGitHubRepoUrl } from './lib/git-utils.js';
+export function safeExec(command, deps) {
+    try {
+        return deps.execSync(command, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+export function getEnvVar(name, deps, defaultValue) {
+    const value = deps.getEnv(name);
+    if (value) {
+        return `${value} (from env)`;
+    }
+    if (defaultValue) {
+        return `${defaultValue} (default)`;
+    }
+    return '(not set)';
+}
+/**
+ * Get current git branch
+ */
+export function getCurrentBranch(deps) {
+    return safeExec('git rev-parse --abbrev-ref HEAD', deps);
+}
+/**
+ * Get latest git tag
+ */
+export function getLatestTag(deps) {
+    return safeExec('git describe --tags --abbrev=0', deps);
+}
+/**
+ * Get commit count since tag (or all commits if no tag)
+ */
+export function getCommitCount(deps, latestTag) {
+    const commits = latestTag
+        ? safeExec(`git log --pretty=format:"%h" ${latestTag}..HEAD`, deps)
+        : safeExec('git log --pretty=format:"%h"', deps);
+    return commits ? commits.split('\n').length : 0;
+}
+/**
+ * Get files status (existence check)
+ */
+export function getFilesStatus(deps) {
+    return {
+        'CHANGELOG.md': deps.existsSync('CHANGELOG.md'),
+        '.release-it.json': deps.existsSync('.release-it.json'),
+        'package.json': deps.existsSync('package.json'),
+        '.git': deps.existsSync('.git'),
+    };
+}
+/**
+ * Get npm username (if logged in)
+ */
+export function getNpmUsername(deps) {
+    return safeExec('npm whoami', deps);
+}
+/**
+ * Get all environment variables with defaults
+ */
+export function getEnvironmentVariables(deps) {
+    const vars = [
+        ['CHANGELOG_FILE', 'CHANGELOG.md'],
+        ['GIT_COMMIT_MESSAGE', 'release: bump v${version}'],
+        ['GIT_TAG_NAME', 'v${version}'],
+        ['GIT_REQUIRE_BRANCH', 'main'],
+        ['GIT_REQUIRE_UPSTREAM', 'false'],
+        ['GIT_REQUIRE_CLEAN', 'false'],
+        ['GIT_REMOTE', 'origin'],
+        ['GITHUB_RELEASE', 'false'],
+        ['GITHUB_REPOSITORY'],
+        ['NPM_PUBLISH', 'false'],
+        ['NPM_SKIP_CHECKS', 'false'],
+        ['NPM_ACCESS', 'public'],
+    ];
+    const envVars = {};
+    for (const [name, defaultValue] of vars) {
+        envVars[name] = getEnvVar(name, deps, defaultValue);
+    }
+    return envVars;
+}
+export function checkConfig(deps) {
+    const envVars = getEnvironmentVariables(deps);
+    const repoUrl = getGitHubRepoUrl({
+        execSync: deps.execSync,
+        getEnv: deps.getEnv,
+    }) || null;
+    const currentBranch = getCurrentBranch(deps);
+    const latestTag = getLatestTag(deps);
+    const commitCount = getCommitCount(deps, latestTag);
+    const filesStatus = getFilesStatus(deps);
+    const npmUsername = getNpmUsername(deps);
+    return {
+        envVars,
+        repoUrl,
+        currentBranch,
+        latestTag,
+        commitCount,
+        filesStatus,
+        npmUsername,
+    };
+}
+function section(title) {
+    console.log(`\n${'='.repeat(60)}`);
+    console.log(`  ${title}`);
+    console.log(`${'='.repeat(60)}\n`);
+}
+export function displayEnvironmentVariables(envVars) {
+    section('Environment Variables');
+    for (const [name, value] of Object.entries(envVars)) {
+        console.log(`  ${name.padEnd(25)} ${value}`);
+    }
+}
+export function displayRepositoryInfo(deps, repoUrl, currentBranch) {
+    section('Repository Information');
+    if (repoUrl) {
+        console.log(`  Repository URL: ${repoUrl}`);
+    }
+    else {
+        console.log(`  Repository URL: ❌ Could not determine`);
+    }
+    if (currentBranch) {
+        console.log(`  Current branch: ${currentBranch}`);
+    }
+    const remote = deps.getEnv('GIT_REMOTE') || 'origin';
+    const remoteUrl = safeExec(`git config --get remote.${remote}.url`, deps);
+    if (remoteUrl) {
+        console.log(`  Remote (${remote}): ${remoteUrl}`);
+    }
+    const upstream = safeExec(`git rev-parse --abbrev-ref --symbolic-full-name @{u}`, deps);
+    if (upstream) {
+        console.log(`  Upstream: ${upstream}`);
+    }
+    else {
+        console.log(`  Upstream: ❌ No upstream configured`);
+    }
+    const status = safeExec('git status --porcelain', deps);
+    if (status === '') {
+        console.log(`  Working directory: ✅ Clean`);
+    }
+    else if (status) {
+        const fileCount = status.split('\n').length;
+        console.log(`  Working directory: ⚠️  ${fileCount} uncommitted change(s)`);
+    }
+}
+export function displayVersionAndTags(deps, latestTag) {
+    section('Version & Tags');
+    const packageJsonPath = 'package.json';
+    if (deps.existsSync(packageJsonPath)) {
+        try {
+            const packageJson = JSON.parse(deps.readFileSync(packageJsonPath, 'utf8'));
+            console.log(`  Current version (package.json): ${packageJson.version || '❌ Not set'}`);
+        }
+        catch {
+            console.log(`  Current version: ❌ Failed to read package.json`);
+        }
+    }
+    else {
+        console.log(`  Current version: ❌ package.json not found`);
+    }
+    if (latestTag) {
+        console.log(`  Latest git tag: ${latestTag}`);
+    }
+    else {
+        console.log(`  Latest git tag: ❌ No tags found`);
+    }
+    const allTags = safeExec('git tag --sort=-v:refname', deps);
+    if (allTags) {
+        const tags = allTags.split('\n').slice(0, 5);
+        console.log(`  Recent tags (last 5):`);
+        for (const tag of tags) {
+            console.log(`    - ${tag}`);
+        }
+        const totalTags = allTags.split('\n').length;
+        if (totalTags > 5) {
+            console.log(`    ... and ${totalTags - 5} more`);
+        }
+    }
+}
+export function displayCommitsSinceLastTag(deps, latestTag) {
+    section('Commits Since Last Tag');
+    let commitRange;
+    if (latestTag) {
+        commitRange = `${latestTag}..HEAD`;
+        console.log(`  Range: ${commitRange}\n`);
+    }
+    else {
+        commitRange = 'HEAD';
+        console.log(`  No tags found, showing all commits\n`);
+    }
+    const commits = safeExec(`git log --pretty=format:"%h %s" ${commitRange}`, deps);
+    if (!commits) {
+        console.log(`  ✨ No commits since ${latestTag || 'repository creation'}`);
+        return;
+    }
+    const commitList = commits.split('\n');
+    console.log(`  Total commits: ${commitList.length}\n`);
+    const displayCount = Math.min(10, commitList.length);
+    console.log(`  Last ${displayCount} commit(s):`);
+    for (const commit of commitList.slice(0, displayCount)) {
+        console.log(`    ${commit}`);
+    }
+    if (commitList.length > displayCount) {
+        console.log(`    ... and ${commitList.length - displayCount} more`);
+    }
+}
+export function displayConfigurationFiles(deps, filesStatus) {
+    section('Configuration Files');
+    const files = [
+        { path: 'CHANGELOG.md', desc: 'Changelog' },
+        { path: '.release-it.json', desc: 'Release-it config' },
+        { path: 'package.json', desc: 'Package manifest' },
+        { path: '.git', desc: 'Git repository' },
+    ];
+    for (const { path, desc } of files) {
+        const exists = filesStatus[path];
+        const icon = exists ? '✅' : '❌';
+        console.log(`  ${icon} ${desc.padEnd(20)} ${path}`);
+    }
+    const changelogPath = deps.getEnv('CHANGELOG_FILE') || 'CHANGELOG.md';
+    if (changelogPath !== 'CHANGELOG.md' && deps.existsSync(changelogPath)) {
+        console.log(`  ✅ ${'Custom changelog'.padEnd(20)} ${changelogPath} (from env)`);
+    }
+}
+export function displayNpmStatus(deps, npmUsername) {
+    section('npm Status');
+    if (npmUsername) {
+        console.log(`  ✅ Logged in as: ${npmUsername}`);
+    }
+    else {
+        console.log(`  ❌ Not logged in (run: npm login)`);
+    }
+    const registry = safeExec('npm config get registry', deps);
+    if (registry) {
+        console.log(`  Registry: ${registry}`);
+    }
+}
+/**
+ * CLI entry point - only runs when script is executed directly
+ */
+/* c8 ignore start */
+if (import.meta.url === `file://${process.argv[1]}`) {
+    async function main() {
+        console.log('🔍 Checking release configuration and project status...');
+        const deps = {
+            execSync,
+            existsSync,
+            readFileSync,
+            getEnv: (key) => process.env[key],
+            log: console.log,
+        };
+        const result = checkConfig(deps);
+        displayEnvironmentVariables(result.envVars);
+        displayRepositoryInfo(deps, result.repoUrl, result.currentBranch);
+        displayVersionAndTags(deps, result.latestTag);
+        displayCommitsSinceLastTag(deps, result.latestTag);
+        displayConfigurationFiles(deps, result.filesStatus);
+        displayNpmStatus(deps, result.npmUsername);
+        console.log('\n' + '='.repeat(60));
+        console.log('\n✨ Check complete!');
+        console.log('\nTo validate release readiness, run:');
+        console.log('  pnpm release-it-preset validate\n');
+    }
+    main().catch((error) => {
+        console.error('❌ Check failed:', error);
+        process.exit(1);
+    });
+}
+/* c8 ignore end */

package/dist/scripts/check-pr-status.js

@@ -0,0 +1,164 @@
+#!/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 { execSync } from 'node:child_process';
+import { appendFileSync } from 'node:fs';
+import { STRICT_CONVENTIONAL_COMMIT_REGEX } from './lib/commit-parser.js';
+const SKIP_CHANGELOG_REGEX = /\[skip-changelog]/i;
+export function safeExec(command, deps) {
+    try {
+        return deps.execSync(command, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+    }
+    catch (error) {
+        deps.warn(`⚠️  Command failed: ${command}\n${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+export function normalizeBaseRef(baseRef) {
+    if (!baseRef || baseRef.trim() === '') {
+        return null;
+    }
+    const trimmed = baseRef.trim();
+    if (trimmed.includes('/') || trimmed.startsWith('refs/')) {
+        return trimmed;
+    }
+    return `origin/${trimmed}`;
+}
+export function parseArgs(argv) {
+    let base = null;
+    let head = null;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--base' && argv[i + 1]) {
+            base = argv[++i];
+            continue;
+        }
+        if (arg === '--head' && argv[i + 1]) {
+            head = argv[++i];
+            continue;
+        }
+    }
+    return { base, head };
+}
+export function splitList(value) {
+    if (!value) {
+        return [];
+    }
+    return value
+        .split('\n')
+        .map(entry => entry.trim())
+        .filter(entry => entry.length > 0);
+}
+export function hasSkipChangelog(commits) {
+    return commits.some(commit => SKIP_CHANGELOG_REGEX.test(commit));
+}
+export function hasConventionalCommits(commits) {
+    return commits.some(commit => STRICT_CONVENTIONAL_COMMIT_REGEX.test(commit));
+}
+export function evaluateChangelogStatus(changedFiles, changelogPath, commits) {
+    const changelogFile = changelogPath || 'CHANGELOG.md';
+    const normalizedChangelog = changelogFile.trim();
+    const skipMarker = hasSkipChangelog(commits);
+    if (changedFiles.includes(normalizedChangelog)) {
+        return { status: 'updated', skipMarker };
+    }
+    if (skipMarker) {
+        return { status: 'skipped', skipMarker };
+    }
+    return { status: 'missing', skipMarker };
+}
+export function getDiffRange(baseRef, headRef) {
+    if (!baseRef) {
+        return headRef;
+    }
+    return `${baseRef}..${headRef}`;
+}
+export function runPrCheck(args, deps) {
+    const envBase = deps.getEnv('PR_BASE_REF') ?? deps.getEnv('GITHUB_BASE_REF') ?? null;
+    const envHead = deps.getEnv('PR_HEAD_REF') ?? deps.getEnv('GITHUB_HEAD_REF') ?? null;
+    const baseRef = normalizeBaseRef(args.base ?? envBase);
+    const headRef = (args.head ?? envHead ?? 'HEAD').trim() || 'HEAD';
+    const diffRange = getDiffRange(baseRef, headRef);
+    const changedFilesOutput = safeExec(baseRef ? `git diff --name-only ${diffRange}` : `git diff --name-only ${headRef}`, deps);
+    const changedFiles = splitList(changedFilesOutput);
+    const commitsOutput = safeExec(baseRef ? `git log ${diffRange} --pretty=format:%s` : `git log ${headRef} --pretty=format:%s`, deps);
+    const commits = splitList(commitsOutput);
+    const changelogPath = deps.getEnv('CHANGELOG_FILE') ?? 'CHANGELOG.md';
+    const changelogEvaluation = evaluateChangelogStatus(changedFiles, changelogPath, commits);
+    const conventional = hasConventionalCommits(commits);
+    return {
+        baseRef,
+        headRef,
+        changedFiles,
+        commits,
+        changelogStatus: changelogEvaluation.status,
+        skipChangelogMarker: changelogEvaluation.skipMarker,
+        hasConventionalCommits: conventional,
+    };
+}
+export function createDefaultDeps() {
+    return {
+        execSync,
+        getEnv: (key) => process.env[key],
+        writeOutput: (name, value) => {
+            const outputFile = process.env.GITHUB_OUTPUT;
+            if (!outputFile) {
+                return;
+            }
+            appendFileSync(outputFile, `${name}=${value}\n`, { encoding: 'utf8' });
+        },
+        log: console.log,
+        warn: console.warn,
+    };
+}
+export function writeOutputs(result, deps) {
+    const commitsEncoded = Buffer.from(JSON.stringify(result.commits), 'utf8').toString('base64');
+    const filesEncoded = Buffer.from(JSON.stringify(result.changedFiles), 'utf8').toString('base64');
+    deps.writeOutput('changelog_status', result.changelogStatus);
+    deps.writeOutput('skip_changelog', result.skipChangelogMarker ? 'true' : 'false');
+    deps.writeOutput('conventional_commits', result.hasConventionalCommits ? 'true' : 'false');
+    deps.writeOutput('commit_messages', commitsEncoded);
+    deps.writeOutput('changed_files', filesEncoded);
+    deps.writeOutput('base_ref', result.baseRef ?? '');
+    deps.writeOutput('head_ref', result.headRef);
+}
+export function renderSummary(result, deps) {
+    deps.log('🔍 PR hygiene check');
+    deps.log(`  • Base ref: ${result.baseRef ?? '(not provided)'}`);
+    deps.log(`  • Head ref: ${result.headRef}`);
+    deps.log(`  • Commits inspected: ${result.commits.length}`);
+    switch (result.changelogStatus) {
+        case 'updated':
+            deps.log('✅ CHANGELOG: updated in this PR');
+            break;
+        case 'skipped':
+            deps.log('ℹ️  CHANGELOG: skipped via [skip-changelog] marker');
+            break;
+        default:
+            deps.log('⚠️  CHANGELOG: no updates and no [skip-changelog] marker');
+    }
+    if (result.hasConventionalCommits) {
+        deps.log('✅ Conventional commits detected');
+    }
+    else {
+        deps.log('ℹ️  No conventional commits found');
+    }
+}
+/* c8 ignore start */
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const deps = createDefaultDeps();
+    const args = parseArgs(process.argv.slice(2));
+    const result = runPrCheck(args, deps);
+    writeOutputs(result, deps);
+    renderSummary(result, deps);
+}
+/* c8 ignore end */

package/dist/scripts/extract-changelog.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env tsx
+/**
+ * Extract changelog entry for a specific version
+ *
+ * This script reads CHANGELOG.md and extracts the section for a given version.
+ * Used primarily for generating GitHub release notes.
+ *
+ * Usage:
+ *   tsx extract-changelog.ts <version>
+ *
+ * Example:
+ *   tsx extract-changelog.ts 1.2.3
+ *
+ * Environment variables:
+ *   CHANGELOG_FILE - Path to changelog file (default: CHANGELOG.md)
+ */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { validateAndNormalizeSemver } from './lib/semver-utils.js';
+import { escapeRegExp } from './lib/string-utils.js';
+export function extractChangelog(version, deps) {
+    // Validate semver format
+    const normalizedVersion = validateAndNormalizeSemver(version);
+    const versionLabels = [`v${normalizedVersion}`, normalizedVersion];
+    const tag = version.startsWith('v') ? version : `v${normalizedVersion}`;
+    const changelogFile = deps.getEnv('CHANGELOG_FILE') || 'CHANGELOG.md';
+    const changelogPath = join(deps.getCwd(), changelogFile);
+    const changelog = deps.readFileSync(changelogPath, 'utf8');
+    const labelPattern = versionLabels.map(escapeRegExp).join('|');
+    const versionBlock = new RegExp(`^(?<prefix>[^\n]*?##\\s*\\[?(?:${labelPattern})\\]?[^\n]*\r?\n)(?<content>[\\s\\S]*?)(?=^##\\s|^\\s*---\\s*$|$(?![\\s\\S]))`, 'm');
+    const match = changelog.match(versionBlock);
+    if (!match || !match.groups) {
+        const humanLabels = versionLabels.map((label) => `[${label}]`).join(' or ');
+        throw new Error(`No ${humanLabels} section found in ${changelogFile}`);
+    }
+    const versionContent = match.groups.content.trim();
+    if (!versionContent) {
+        throw new Error(`No changelog entry found for ${tag}`);
+    }
+    const entry = match[0].trim();
+    return `# Release ${tag}\n\n${entry}`;
+}
+/**
+ * CLI entry point - only runs when script is executed directly
+ */
+/* c8 ignore start */
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const version = process.argv[2];
+    if (!version) {
+        console.error('Usage: tsx scripts/extract-changelog.ts <version>');
+        process.exit(1);
+    }
+    try {
+        const result = extractChangelog(version, {
+            readFileSync,
+            getEnv: (key) => process.env[key],
+            getCwd: () => process.cwd(),
+        });
+        console.log(result);
+    }
+    catch (error) {
+        console.error(`❌ ${error instanceof Error ? error.message : error}`);
+        process.exit(1);
+    }
+}
+/* c8 ignore end */