@oorabona/release-it-preset 0.3.0

package/dist/scripts/init-project.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env tsx
+/**
+ * Initialize a project with release-it-preset
+ *
+ * This script:
+ * - Creates CHANGELOG.md with Keep a Changelog template
+ * - Creates .release-it.json with extends configuration
+ * - Optionally adds scripts to package.json
+ *
+ * Usage:
+ *   tsx init-project.ts [--yes]
+ *
+ * Options:
+ *   --yes    Skip prompts and use defaults
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+const CHANGELOG_TEMPLATE = `# 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.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+- Initial release
+`;
+const RELEASE_IT_CONFIG = `{
+  "extends": "@oorabona/release-it-preset/config/default"
+}
+`;
+const SUGGESTED_SCRIPTS = {
+    'release': 'release-it-preset default',
+    'release:hotfix': 'release-it-preset hotfix',
+    'release:dry': 'release-it-preset default --dry-run',
+    'changelog:update': 'release-it-preset update',
+};
+export function parseArgs(args) {
+    /* c8 ignore next */
+    const argv = args || process.argv.slice(2);
+    return {
+        yes: argv.includes('--yes') || argv.includes('-y'),
+    };
+}
+export async function createChangelog(options, deps) {
+    const path = 'CHANGELOG.md';
+    if (deps.existsSync(path)) {
+        deps.warn(`⚠️  ${path} already exists`);
+        if (!options.yes) {
+            const overwrite = await deps.prompt('Overwrite it?');
+            if (!overwrite) {
+                deps.log(`ℹ️  Skipping ${path}`);
+                return false;
+            }
+        }
+        else {
+            deps.log(`ℹ️  Skipping ${path} (--yes mode, not overwriting existing files)`);
+            return false;
+        }
+    }
+    deps.writeFileSync(path, CHANGELOG_TEMPLATE);
+    deps.log(`✅ Created ${path}`);
+    return true;
+}
+export async function createReleaseItConfig(options, deps) {
+    const path = '.release-it.json';
+    if (deps.existsSync(path)) {
+        deps.warn(`⚠️  ${path} already exists`);
+        if (!options.yes) {
+            const overwrite = await deps.prompt('Overwrite it?');
+            if (!overwrite) {
+                deps.log(`ℹ️  Skipping ${path}`);
+                return false;
+            }
+        }
+        else {
+            deps.log(`ℹ️  Skipping ${path} (--yes mode, not overwriting existing files)`);
+            return false;
+        }
+    }
+    deps.writeFileSync(path, RELEASE_IT_CONFIG);
+    deps.log(`✅ Created ${path}`);
+    return true;
+}
+export async function updatePackageJson(options, deps) {
+    const path = 'package.json';
+    if (!deps.existsSync(path)) {
+        deps.warn(`⚠️  ${path} not found, skipping script addition`);
+        return false;
+    }
+    try {
+        const packageJson = JSON.parse(deps.readFileSync(path, 'utf8'));
+        if (!packageJson.scripts) {
+            packageJson.scripts = {};
+        }
+        const scriptsToAdd = {};
+        let hasConflicts = false;
+        for (const [name, command] of Object.entries(SUGGESTED_SCRIPTS)) {
+            if (packageJson.scripts[name]) {
+                deps.warn(`⚠️  Script "${name}" already exists in package.json`);
+                hasConflicts = true;
+            }
+            else {
+                scriptsToAdd[name] = command;
+            }
+        }
+        if (Object.keys(scriptsToAdd).length === 0) {
+            deps.log(`ℹ️  All suggested scripts already exist in package.json`);
+            return false;
+        }
+        if (!options.yes) {
+            deps.log(`\n📝 Suggested scripts to add to package.json:`);
+            for (const [name, command] of Object.entries(scriptsToAdd)) {
+                deps.log(`   "${name}": "${command}"`);
+            }
+            const addScripts = await deps.prompt('\nAdd these scripts to package.json?');
+            if (!addScripts) {
+                deps.log(`ℹ️  Skipping package.json scripts`);
+                return false;
+            }
+        }
+        Object.assign(packageJson.scripts, scriptsToAdd);
+        deps.writeFileSync(path, JSON.stringify(packageJson, null, 2) + '\n');
+        deps.log(`✅ Updated ${path} with ${Object.keys(scriptsToAdd).length} script(s)`);
+        return true;
+    }
+    catch (error) {
+        deps.warn(`❌ Failed to update ${path}: ${error}`);
+        return false;
+    }
+}
+export async function initProject(options, deps) {
+    deps.log('🚀 Initializing project with release-it-preset\n');
+    if (options.yes) {
+        deps.log('ℹ️  Running in --yes mode (non-interactive)\n');
+    }
+    const results = {
+        changelog: await createChangelog(options, deps),
+        releaseIt: await createReleaseItConfig(options, deps),
+        packageJson: await updatePackageJson(options, deps),
+    };
+    deps.log('\n📊 Summary:');
+    deps.log(`   CHANGELOG.md: ${results.changelog ? '✅ Created' : '⏭️  Skipped'}`);
+    deps.log(`   .release-it.json: ${results.releaseIt ? '✅ Created' : '⏭️  Skipped'}`);
+    deps.log(`   package.json: ${results.packageJson ? '✅ Updated' : '⏭️  Skipped'}`);
+    const anyCreated = Object.values(results).some((v) => v);
+    if (anyCreated) {
+        deps.log('\n🎉 Initialization complete!');
+        deps.log('\nNext steps:');
+        deps.log('   1. Review the generated files');
+        deps.log('   2. Update CHANGELOG.md [Unreleased] section');
+        deps.log('   3. Run: pnpm release-it-preset default --dry-run');
+    }
+    else {
+        deps.log('\n✨ All files already exist, nothing to do!');
+    }
+    return results;
+}
+/**
+ * CLI entry point - only runs when script is executed directly
+ */
+/* c8 ignore start */
+if (import.meta.url === `file://${process.argv[1]}`) {
+    async function realPrompt(question) {
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        return new Promise((resolve) => {
+            rl.question(`${question} (y/N): `, (answer) => {
+                rl.close();
+                resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+            });
+        });
+    }
+    const options = parseArgs();
+    initProject(options, {
+        existsSync,
+        readFileSync,
+        writeFileSync,
+        prompt: realPrompt,
+        log: console.log,
+        warn: console.warn,
+    }).catch((error) => {
+        console.error('❌ Initialization failed:', error);
+        process.exit(1);
+    });
+}
+/* c8 ignore end */

package/dist/scripts/lib/commit-parser.js

@@ -0,0 +1,67 @@
+/**
+ * Conventional commit parsing utilities
+ */
+/**
+ * Regex pattern for matching conventional commits
+ * Matches: type(scope)?: description
+ * Example: feat(api): add new endpoint
+ */
+export const CONVENTIONAL_COMMIT_REGEX = /^(\w+)(?:\(([^)]+)\))?(!)?\s*:\s*(.+)/m;
+/**
+ * Strict conventional commit types as defined by Conventional Commits specification
+ * Used for strict validation in PR checks
+ */
+export const STRICT_CONVENTIONAL_TYPES = [
+    'feat',
+    'fix',
+    'docs',
+    'style',
+    'refactor',
+    'perf',
+    'test',
+    'chore',
+    'build',
+    'ci',
+    'revert',
+];
+/**
+ * Regex for strict conventional commit validation (only approved types)
+ */
+export const STRICT_CONVENTIONAL_COMMIT_REGEX = new RegExp(`^(${STRICT_CONVENTIONAL_TYPES.join('|')})(\\(.+\\))?:\\s.+`, 'i');
+/**
+ * Check if a commit message matches conventional commit format (lenient)
+ *
+ * @param message Commit message to check
+ * @returns true if message matches conventional format
+ */
+export function isConventionalCommit(message) {
+    return CONVENTIONAL_COMMIT_REGEX.test(message);
+}
+/**
+ * Check if a commit message matches strict conventional commit format
+ *
+ * @param message Commit message to check
+ * @returns true if message matches strict format
+ */
+export function isStrictConventionalCommit(message) {
+    return STRICT_CONVENTIONAL_COMMIT_REGEX.test(message);
+}
+/**
+ * Extract conventional commit parts from a message
+ *
+ * @param message Commit message
+ * @returns Parsed parts or null if not conventional
+ */
+export function parseConventionalCommit(message) {
+    const match = message.match(CONVENTIONAL_COMMIT_REGEX);
+    if (!match) {
+        return null;
+    }
+    const [, type, scope, breaking, description] = match;
+    return {
+        type: type.trim(),
+        scope: scope?.trim(),
+        breaking: Boolean(breaking),
+        description: description.trim(),
+    };
+}

package/dist/scripts/lib/git-utils.js

@@ -0,0 +1,33 @@
+/**
+ * Git utility functions shared across scripts
+ */
+/**
+ * Get GitHub repository URL for commit/tag links
+ *
+ * Priority:
+ * 1. GITHUB_REPOSITORY environment variable (format: owner/repo)
+ * 2. Git remote URL (extracted from git config)
+ *
+ * @param deps Dependencies for git operations
+ * @returns Repository URL or empty string if not determinable
+ */
+export function getGitHubRepoUrl(deps) {
+    const githubRepo = deps.getEnv('GITHUB_REPOSITORY');
+    if (githubRepo) {
+        return `https://github.com/${githubRepo}`;
+    }
+    try {
+        const remote = deps.getEnv('GIT_REMOTE') || 'origin';
+        const remoteUrl = deps.execSync(`git config --get remote.${remote}.url`, { encoding: 'utf8' }).trim();
+        return remoteUrl
+            .replace(/^git@github\.com:/, 'https://github.com/')
+            .replace(/\.git$/, '');
+    }
+    catch (error) {
+        if (deps.warn) {
+            deps.warn('⚠️  Could not determine repository URL. Links will not be generated.');
+            deps.warn('   Set GITHUB_REPOSITORY environment variable (e.g., owner/repo)');
+        }
+        return '';
+    }
+}

package/dist/scripts/lib/semver-utils.js

@@ -0,0 +1,26 @@
+/**
+ * Semantic versioning utility functions
+ */
+/**
+ * Validate if a string is a valid semantic version
+ *
+ * @param version Version string to validate (can have optional 'v' prefix)
+ * @returns true if valid semver, false otherwise
+ */
+export function isValidSemver(version) {
+    const semverRegex = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/;
+    return semverRegex.test(version);
+}
+/**
+ * Validate and normalize a semantic version string
+ *
+ * @param version Version string to validate
+ * @throws Error if version is not valid semver
+ * @returns Normalized version without 'v' prefix
+ */
+export function validateAndNormalizeSemver(version) {
+    if (!isValidSemver(version)) {
+        throw new Error(`Invalid semantic version: "${version}". Expected format: [v]MAJOR.MINOR.PATCH[-prerelease][+buildmetadata]`);
+    }
+    return version.replace(/^v/, '');
+}

package/dist/scripts/lib/string-utils.js

@@ -0,0 +1,12 @@
+/**
+ * String utility functions shared across scripts
+ */
+/**
+ * Escape special regex characters in a string
+ *
+ * @param input String to escape
+ * @returns Escaped string safe for use in RegExp
+ */
+export function escapeRegExp(input) {
+    return input.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');
+}

package/dist/scripts/populate-unreleased-changelog.js

@@ -0,0 +1,236 @@
+#!/usr/bin/env tsx
+/**
+ * Populate [Unreleased] section with commits since the last tag
+ *
+ * This script:
+ * - Extracts commits since the last git tag
+ * - Parses conventional commit messages
+ * - Groups commits by type (Added, Fixed, Changed, etc.)
+ * - Updates the [Unreleased] section in CHANGELOG.md
+ * - Generates commit links using the repository URL
+ *
+ * Usage:
+ *   tsx populate-unreleased-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 { execSync } from 'node:child_process';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { getGitHubRepoUrl } from './lib/git-utils.js';
+import { CONVENTIONAL_COMMIT_REGEX } from './lib/commit-parser.js';
+/**
+ * Extract all conventional commit patterns from a commit body
+ */
+export function extractConventionalCommitParts(commitBody, sha) {
+    const parts = [];
+    const conventionalCommitRegex = new RegExp(CONVENTIONAL_COMMIT_REGEX.source, 'gm');
+    let match;
+    while ((match = conventionalCommitRegex.exec(commitBody)) !== null) {
+        const [, type, scope, breaking, description] = match;
+        if (type && description && description.trim()) {
+            const cleanDescription = description.trim().replace(/\s+/g, ' ');
+            parts.push({
+                type: type.trim(),
+                scope: scope?.trim(),
+                description: cleanDescription,
+                sha,
+                breaking: Boolean(breaking),
+            });
+        }
+    }
+    return parts;
+}
+/**
+ * Normalize commit types to standard changelog categories
+ */
+export function normalizeCommitType(type) {
+    const typeMap = {
+        feat: '### Added',
+        feature: '### Added',
+        add: '### Added',
+        fix: '### Fixed',
+        bugfix: '### Fixed',
+        security: '### Security',
+        perf: '### Changed',
+        refactor: '### Changed',
+        style: '### Changed',
+        docs: '### Changed',
+        test: '### Changed',
+        chore: '### Changed',
+        build: '### Changed',
+        deps: '### Changed',
+        dependency: '### Changed',
+        dependencies: '### Changed',
+        revert: '### Changed',
+        remove: '### Removed',
+        removed: '### Removed',
+        delete: '### Removed',
+        deleted: '### Removed',
+        ci: false,
+        release: false,
+        hotfix: false,
+        misc: '### Changed',
+    };
+    const result = typeMap[type.toLowerCase()];
+    return result !== undefined ? result : '### Changed';
+}
+/**
+ * Parse git log output and extract all conventional commit parts
+ */
+export function parseCommitsWithMultiplePrefixes(gitOutput, repoUrl) {
+    if (!gitOutput)
+        return '';
+    const commitEntries = gitOutput.split('|||END|||').filter((entry) => entry.trim());
+    const allParts = [];
+    for (const entry of commitEntries) {
+        const [sha, ...bodyParts] = entry.split('|');
+        const body = bodyParts.join('|').trim();
+        if (/\[skip-changelog\]/i.test(body)) {
+            continue;
+        }
+        if (sha && body) {
+            const shortSha = sha.trim().substring(0, 7);
+            const parts = extractConventionalCommitParts(body, shortSha);
+            if (parts.length === 0) {
+                const firstLine = body.split('\n')[0].trim();
+                if (firstLine) {
+                    allParts.push({
+                        type: 'misc',
+                        description: firstLine,
+                        sha: shortSha,
+                    });
+                }
+            }
+            else {
+                allParts.push(...parts);
+            }
+        }
+    }
+    const groupedParts = {};
+    const breakingChanges = [];
+    for (const part of allParts) {
+        // Collect breaking changes separately
+        if (part.breaking) {
+            breakingChanges.push(part);
+        }
+        const sectionName = normalizeCommitType(part.type);
+        if (sectionName === false) {
+            continue;
+        }
+        if (!groupedParts[sectionName]) {
+            groupedParts[sectionName] = [];
+        }
+        groupedParts[sectionName].push(part);
+    }
+    const sections = [];
+    const sectionOrder = ['### Added', '### Fixed', '### Changed', '### Removed', '### Security'];
+    // Add BREAKING CHANGES section first if there are any
+    if (breakingChanges.length > 0) {
+        sections.push('### ⚠️ BREAKING CHANGES');
+        sections.push(...breakingChanges.map((part) => {
+            const scopePart = part.scope ? ` (${part.scope})` : '';
+            const linkPart = repoUrl ? ` ([${part.sha}](${repoUrl}/commit/${part.sha}))` : ` (${part.sha})`;
+            return `- ${part.description}${scopePart}${linkPart}`;
+        }));
+        sections.push('');
+    }
+    for (const sectionTitle of sectionOrder) {
+        if (groupedParts[sectionTitle] && groupedParts[sectionTitle].length > 0) {
+            sections.push(sectionTitle);
+            sections.push(...groupedParts[sectionTitle].map((part) => {
+                const scopePart = part.scope ? ` (${part.scope})` : '';
+                const breakingIndicator = part.breaking ? ' ⚠️ BREAKING' : '';
+                const linkPart = repoUrl ? ` ([${part.sha}](${repoUrl}/commit/${part.sha}))` : ` (${part.sha})`;
+                return `- ${part.description}${scopePart}${breakingIndicator}${linkPart}`;
+            }));
+            sections.push('');
+        }
+    }
+    return sections.length > 0 ? sections.join('\n').trim() : 'No changes yet.';
+}
+/**
+ * Main function to populate changelog with dependency injection
+ */
+export function populateChangelog(deps) {
+    const changelogPath = deps.getEnv('CHANGELOG_FILE') || 'CHANGELOG.md';
+    deps.log('📝 Populating [Unreleased] section...');
+    let latestTag;
+    try {
+        latestTag = deps.execSync('git describe --tags --abbrev=0 2>/dev/null', { encoding: 'utf8' }).trim();
+        deps.log(`ℹ️  Latest tag: ${latestTag}`);
+    }
+    catch {
+        deps.log('ℹ️  No tags found, using all commits');
+        latestTag = '';
+    }
+    const gitLogCommand = latestTag
+        ? `git log --pretty=format:"%H|%B|||END|||" ${latestTag}..HEAD`
+        : `git log --pretty=format:"%H|%B|||END|||"`;
+    let gitOutput;
+    try {
+        gitOutput = deps.execSync(gitLogCommand, { encoding: 'utf8' }).trim();
+    }
+    catch {
+        deps.log('ℹ️  No new commits found');
+        gitOutput = '';
+    }
+    const repoUrl = getGitHubRepoUrl({
+        execSync: deps.execSync,
+        getEnv: deps.getEnv,
+        warn: deps.warn,
+    });
+    const commits = parseCommitsWithMultiplePrefixes(gitOutput, repoUrl);
+    const changelog = deps.readFileSync(changelogPath, 'utf8');
+    const unreleasedContent = commits && commits.trim() ? commits : 'No changes yet.';
+    const unreleasedRegex = /## \[Unreleased\][\s\S]*?(?=## \[|$)/;
+    const newUnreleasedSection = `## [Unreleased]\n\n${unreleasedContent}\n\n`;
+    let updatedChangelog;
+    if (changelog.match(unreleasedRegex)) {
+        updatedChangelog = changelog.replace(unreleasedRegex, newUnreleasedSection);
+    }
+    else {
+        const doubleNewlineIndex = changelog.indexOf('\n\n');
+        if (doubleNewlineIndex === -1) {
+            const trimmed = changelog.trimEnd();
+            const separator = trimmed.length === 0 ? '' : '\n\n';
+            updatedChangelog = `${trimmed}${separator}${newUnreleasedSection}`;
+        }
+        else {
+            const insertionPoint = doubleNewlineIndex + 2;
+            updatedChangelog = changelog.slice(0, insertionPoint) + newUnreleasedSection + changelog.slice(insertionPoint);
+        }
+    }
+    deps.writeFileSync(changelogPath, updatedChangelog);
+    const commitCount = unreleasedContent === 'No changes yet.'
+        ? 0
+        : unreleasedContent
+            .split('\n')
+            .filter((line) => line.trim().startsWith('- '))
+            .length;
+    deps.log(`✅ Updated [Unreleased] section with ${commitCount} commit(s)`);
+}
+/**
+ * CLI entry point - only runs when script is executed directly
+ */
+/* c8 ignore start */
+if (import.meta.url === `file://${process.argv[1]}`) {
+    try {
+        populateChangelog({
+            execSync,
+            readFileSync,
+            writeFileSync,
+            getEnv: (key) => process.env[key],
+            log: console.log,
+            warn: console.warn,
+            error: console.error,
+        });
+    }
+    catch (error) {
+        console.error('❌ Failed to populate [Unreleased] section:', error);
+        process.exit(1);
+    }
+}
+/* c8 ignore end */