claude-git-hooks 2.10.0 → 2.12.0

package/lib/commands/bump-version.js

@@ -0,0 +1,452 @@
+/**
+ * File: bump-version.js
+ * Purpose: Bump version command with automatic CHANGELOG and Git tag
+ *
+ * Workflow:
+ * 1. Validate prerequisites (clean working directory, valid branch, remote)
+ * 2. Detect project type and current version
+ * 3. Calculate new version with optional suffix
+ * 4. Update version file(s)
+ * 5. [Optional] Generate and update CHANGELOG
+ * 6. Create annotated Git tag
+ * 7. Push tag to remote
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import {
+    detectProjectType,
+    getCurrentVersion,
+    incrementVersion,
+    updateVersion,
+    parseVersion
+} from '../utils/version-manager.js';
+import {
+    createTag,
+    pushTags,
+    tagExists,
+    formatTagName
+} from '../utils/git-tag-manager.js';
+import {
+    generateChangelogEntry,
+    updateChangelogFile
+} from '../utils/changelog-generator.js';
+import {
+    getRepoRoot,
+    getCurrentBranch,
+    verifyRemoteExists,
+    getRemoteName
+} from '../utils/git-operations.js';
+import { getConfig } from '../config.js';
+import { showInfo, showSuccess, showError, showWarning, promptConfirmation } from '../utils/interactive-ui.js';
+import logger from '../utils/logger.js';
+import {
+    colors,
+    error,
+    success,
+    info,
+    warning,
+    checkGitRepo
+} from './helpers.js';
+
+/**
+ * Validates prerequisites before version bump
+ * Why: Prevents version bump in invalid state
+ *
+ * @returns {Object} Validation result: { valid, errors }
+ */
+function validatePrerequisites() {
+    logger.debug('bump-version - validatePrerequisites', 'Validating prerequisites');
+
+    const errors = [];
+
+    try {
+        // Check if git repo
+        if (!checkGitRepo()) {
+            errors.push('Not a git repository');
+        }
+
+        // Check for clean working directory
+        try {
+            const status = execSync('git status --porcelain', { encoding: 'utf8' }).trim();
+            if (status) {
+                errors.push('Working directory has uncommitted changes');
+            }
+        } catch (err) {
+            errors.push('Failed to check git status');
+        }
+
+        // Check for valid branch (not detached HEAD)
+        const currentBranch = getCurrentBranch();
+        if (!currentBranch || currentBranch === 'unknown') {
+            errors.push('Not on a valid branch (detached HEAD?)');
+        }
+
+        // Check for remote
+        const remoteName = getRemoteName();
+        if (!verifyRemoteExists(remoteName)) {
+            errors.push(`Remote '${remoteName}' does not exist`);
+        }
+
+        const valid = errors.length === 0;
+
+        logger.debug('bump-version - validatePrerequisites', 'Validation complete', {
+            valid,
+            errorCount: errors.length
+        });
+
+        return { valid, errors };
+
+    } catch (err) {
+        logger.error('bump-version - validatePrerequisites', 'Validation failed', err);
+        return {
+            valid: false,
+            errors: ['Validation error: ' + err.message]
+        };
+    }
+}
+
+/**
+ * Parses command line arguments
+ * Why: Extracts bump type and options from CLI args
+ *
+ * @param {Array<string>} args - CLI arguments
+ * @returns {Object} Parsed args: { bumpType, suffix, updateChangelog, baseBranch, dryRun, noTag, noPush }
+ */
+function parseArguments(args) {
+    logger.debug('bump-version - parseArguments', 'Parsing arguments', { args });
+
+    const parsed = {
+        bumpType: null,
+        suffix: null,
+        updateChangelog: false,
+        baseBranch: 'main',
+        dryRun: false,
+        noTag: false,
+        noPush: false
+    };
+
+    // First argument should be bump type
+    if (args.length === 0) {
+        return parsed;
+    }
+
+    const firstArg = args[0].toLowerCase();
+    if (['major', 'minor', 'patch'].includes(firstArg)) {
+        parsed.bumpType = firstArg;
+    }
+
+    // Parse options
+    for (let i = 1; i < args.length; i++) {
+        const arg = args[i];
+
+        if (arg === '--suffix' && i + 1 < args.length) {
+            parsed.suffix = args[i + 1];
+            i++; // Skip next arg
+        } else if (arg === '--update-changelog') {
+            parsed.updateChangelog = true;
+            // Check if next arg is a branch name (not starting with --)
+            if (i + 1 < args.length && !args[i + 1].startsWith('--')) {
+                parsed.baseBranch = args[i + 1];
+                i++; // Skip next arg
+            }
+        } else if (arg === '--dry-run') {
+            parsed.dryRun = true;
+        } else if (arg === '--no-tag') {
+            parsed.noTag = true;
+        } else if (arg === '--no-push') {
+            parsed.noPush = true;
+        }
+    }
+
+    logger.debug('bump-version - parseArguments', 'Arguments parsed', parsed);
+
+    return parsed;
+}
+
+/**
+ * Displays dry run preview
+ * Why: Shows what would change without applying
+ *
+ * @param {Object} info - Version info
+ */
+function showDryRunPreview(info) {
+    console.log('');
+    console.log(`${colors.yellow}═════════════════════════════════════════════════${colors.reset}`);
+    console.log(`${colors.yellow}           DRY RUN - No changes will be made      ${colors.reset}`);
+    console.log(`${colors.yellow}═════════════════════════════════════════════════${colors.reset}`);
+    console.log('');
+    console.log(`${colors.blue}Project Type:${colors.reset} ${info.projectType}`);
+    console.log(`${colors.blue}Current Version:${colors.reset} ${info.currentVersion}`);
+    console.log(`${colors.green}New Version:${colors.reset} ${info.newVersion}`);
+    console.log(`${colors.blue}Tag Name:${colors.reset} ${info.tagName}`);
+    console.log('');
+
+    if (info.files.length > 0) {
+        console.log(`${colors.blue}Files to update:${colors.reset}`);
+        info.files.forEach(file => console.log(`  - ${file}`));
+        console.log('');
+    }
+
+    if (info.updateChangelog) {
+        console.log(`${colors.blue}CHANGELOG:${colors.reset} Will be generated and updated`);
+        console.log('');
+    }
+
+    console.log(`${colors.yellow}Run without --dry-run to apply these changes${colors.reset}`);
+    console.log('');
+}
+
+/**
+ * Bump version command
+ * @param {Array<string>} args - Command arguments
+ */
+export async function runBumpVersion(args) {
+    logger.debug('bump-version', 'Starting bump-version command', { args });
+
+    // Parse arguments
+    const options = parseArguments(args);
+
+    if (!options.bumpType) {
+        error('Usage: claude-hooks bump-version <major|minor|patch> [options]');
+        console.log('');
+        console.log('Options:');
+        console.log('  --suffix <value>         Add version suffix (e.g., SNAPSHOT, RC)');
+        console.log('  --update-changelog [branch]  Generate CHANGELOG entry (default branch: main)');
+        console.log('  --dry-run                Preview changes without applying');
+        console.log('  --no-tag                 Skip Git tag creation');
+        console.log('  --no-push                Create tag but don\'t push to remote');
+        console.log('');
+        console.log('Examples:');
+        console.log('  claude-hooks bump-version minor --suffix SNAPSHOT');
+        console.log('  claude-hooks bump-version patch --update-changelog');
+        console.log('  claude-hooks bump-version major --dry-run');
+        return;
+    }
+
+    showInfo(`🔢 Bumping version (${options.bumpType})...`);
+    console.log('');
+
+    // Step 1: Validate prerequisites
+    logger.debug('bump-version', 'Step 1: Validating prerequisites');
+    const validation = validatePrerequisites();
+
+    if (!validation.valid) {
+        showError('Prerequisites validation failed:');
+        console.log('');
+        validation.errors.forEach(err => console.log(`  ❌ ${err}`));
+        console.log('');
+        console.log('Please fix these issues:');
+        console.log('  - Commit or stash uncommitted changes: git stash');
+        console.log('  - Checkout a branch: git checkout main');
+        console.log('  - Configure remote: git remote add origin <url>');
+        console.log('');
+        process.exit(1);
+    }
+
+    showSuccess('Prerequisites validated');
+
+    // Step 2: Detect project type and current version
+    logger.debug('bump-version', 'Step 2: Detecting project type and version');
+    const projectType = detectProjectType();
+
+    if (projectType === 'none') {
+        showError('No version files found');
+        console.log('');
+        console.log('This command requires either:');
+        console.log('  - package.json (Node.js project)');
+        console.log('  - pom.xml (Maven project)');
+        console.log('');
+        process.exit(1);
+    }
+
+    const versions = getCurrentVersion(projectType);
+    const currentVersion = versions.resolved;
+
+    if (!currentVersion) {
+        showError('Could not determine current version');
+        process.exit(1);
+    }
+
+    // Warn if monorepo has version mismatch
+    if (versions.mismatch) {
+        showWarning('Version mismatch detected in monorepo:');
+        console.log(`  package.json: ${versions.packageJson}`);
+        console.log(`  pom.xml: ${versions.pomXml}`);
+        console.log('');
+        console.log('Both files will be updated to the new version.');
+        console.log('');
+    }
+
+    showInfo(`Project: ${projectType}`);
+    showInfo(`Current version: ${currentVersion}`);
+
+    // Step 3: Calculate new version
+    logger.debug('bump-version', 'Step 3: Calculating new version');
+    const newVersion = incrementVersion(currentVersion, options.bumpType, options.suffix);
+    const tagName = formatTagName(newVersion);
+
+    showSuccess(`New version: ${newVersion}`);
+    console.log('');
+
+    // Prepare files list
+    const filesToUpdate = [];
+    if (projectType === 'node' || projectType === 'both') {
+        filesToUpdate.push('package.json');
+    }
+    if (projectType === 'maven' || projectType === 'both') {
+        filesToUpdate.push('pom.xml');
+    }
+
+    // Dry run preview
+    if (options.dryRun) {
+        showDryRunPreview({
+            projectType,
+            currentVersion,
+            newVersion,
+            tagName,
+            files: filesToUpdate,
+            updateChangelog: options.updateChangelog
+        });
+        return;
+    }
+
+    // Confirm with user
+    const shouldContinue = await promptConfirmation(
+        `Update version to ${newVersion}?`,
+        true
+    );
+
+    if (!shouldContinue) {
+        showInfo('Version bump cancelled');
+        process.exit(0);
+    }
+
+    console.log('');
+
+    try {
+        // Step 4: Update version files
+        logger.debug('bump-version', 'Step 4: Updating version files');
+        showInfo('Updating version files...');
+        updateVersion(projectType, newVersion);
+
+        filesToUpdate.forEach(file => {
+            showSuccess(`✓ Updated ${file}`);
+        });
+
+        console.log('');
+
+        // Step 5: Generate CHANGELOG (if requested)
+        if (options.updateChangelog) {
+            logger.debug('bump-version', 'Step 5: Generating CHANGELOG');
+            showInfo('Generating CHANGELOG entry...');
+
+            const config = await getConfig();
+            const isReleaseVersion = !options.suffix; // Final version if no suffix
+
+            const changelogResult = await generateChangelogEntry({
+                version: newVersion,
+                isReleaseVersion,
+                baseBranch: options.baseBranch,
+                config
+            });
+
+            if (changelogResult.content) {
+                const updated = updateChangelogFile(changelogResult.content);
+                if (updated) {
+                    showSuccess('✓ CHANGELOG.md updated');
+                } else {
+                    showWarning('⚠ Failed to update CHANGELOG.md');
+                }
+            } else {
+                showWarning('⚠ No commits found for CHANGELOG');
+            }
+
+            console.log('');
+        }
+
+        // Step 6: Create Git tag (if not disabled)
+        if (!options.noTag) {
+            logger.debug('bump-version', 'Step 6: Creating Git tag');
+            showInfo('Creating Git tag...');
+
+            // Check if tag already exists
+            const exists = await tagExists(tagName, 'local');
+            if (exists) {
+                showWarning(`Tag ${tagName} already exists locally`);
+                const shouldOverwrite = await promptConfirmation(
+                    'Overwrite existing tag?',
+                    false
+                );
+
+                if (!shouldOverwrite) {
+                    showInfo('Tag creation skipped');
+                    console.log('');
+                    console.log('Version files updated successfully, but tag was not created.');
+                    return;
+                }
+            }
+
+            const tagMessage = `Release version ${newVersion}`;
+            const tagResult = createTag(newVersion, tagMessage, { force: exists });
+
+            if (tagResult.success) {
+                showSuccess(`✓ Tag created: ${tagName}`);
+                console.log('');
+
+                // Step 7: Push tag (if not disabled)
+                if (!options.noPush) {
+                    logger.debug('bump-version', 'Step 7: Pushing tag to remote');
+                    showInfo('Pushing tag to remote...');
+
+                    const pushResult = pushTags(null, tagName);
+
+                    if (pushResult.success) {
+                        showSuccess(`✓ Tag pushed to remote`);
+                    } else {
+                        showError(`Failed to push tag: ${pushResult.error}`);
+                        console.log('');
+                        console.log('You can push the tag manually:');
+                        console.log(`  git push origin ${tagName}`);
+                    }
+                } else {
+                    showInfo('Tag push skipped (--no-push)');
+                    console.log('');
+                    console.log('To push the tag later:');
+                    console.log(`  git push origin ${tagName}`);
+                }
+            } else {
+                showError(`Failed to create tag: ${tagResult.error}`);
+            }
+        } else {
+            showInfo('Tag creation skipped (--no-tag)');
+        }
+
+        // Success summary
+        console.log('');
+        console.log(`${colors.green}════════════════════════════════════════════════${colors.reset}`);
+        console.log(`${colors.green}        Version Bump Complete ✅                ${colors.reset}`);
+        console.log(`${colors.green}════════════════════════════════════════════════${colors.reset}`);
+        console.log('');
+        console.log(`${colors.blue}Old version:${colors.reset} ${currentVersion}`);
+        console.log(`${colors.blue}New version:${colors.reset} ${newVersion}`);
+        console.log(`${colors.blue}Tag:${colors.reset} ${tagName}`);
+        console.log('');
+        console.log('Next steps:');
+        console.log('  1. Review the changes: git diff');
+        console.log('  2. Commit the version bump: git add . && git commit -m "chore: bump version to ' + newVersion + '"');
+        console.log('  3. Create PR: claude-hooks create-pr main');
+        console.log('');
+
+    } catch (err) {
+        logger.error('bump-version', 'Version bump failed', err);
+        showError(`Version bump failed: ${err.message}`);
+        console.log('');
+        console.log('The operation was interrupted. You may need to:');
+        console.log('  - Revert changes: git checkout .');
+        console.log('  - Delete tag if created: git tag -d ' + tagName);
+        console.log('');
+        process.exit(1);
+    }
+}

package/lib/commands/create-pr.js

@@ -11,7 +11,8 @@ import { loadPrompt } from '../utils/prompt-builder.js';
 import { getConfig } from '../config.js';
 import { getOrPromptTaskId, formatWithTaskId } from '../utils/task-id.js';
 import { getReviewersForFiles } from '../utils/github-client.js';
-import { showPRPreview, promptMenu, showSuccess, showError, showInfo, showWarning } from '../utils/interactive-ui.js';
+import { showPRPreview, promptMenu, showSuccess, showError, showInfo, showWarning, promptConfirmation } from '../utils/interactive-ui.js';
+import { getBranchPushStatus, pushBranch } from '../utils/git-operations.js';
 import logger from '../utils/logger.js';
 import {
     error,
@@ -136,6 +137,205 @@ export async function runCreatePr(args) {
 
         logger.debug('create-pr', 'No existing PR found, continuing');
 
+        // Step 5.5: Check branch status and auto-push if needed (v2.11.0)
+        logger.debug('create-pr', 'Step 5.5: Checking branch push status');
+        const pushStatus = getBranchPushStatus(currentBranch);
+        const pushConfig = config.github?.pr;
+
+        logger.debug('create-pr', 'Branch push status', {
+            hasRemote: pushStatus.hasRemote,
+            hasUnpushedCommits: pushStatus.hasUnpushedCommits,
+            hasDiverged: pushStatus.hasDiverged,
+            unpushedCount: pushStatus.unpushedCommits.length
+        });
+
+        if (!pushStatus.hasRemote || pushStatus.hasUnpushedCommits) {
+            // Branch needs to be pushed
+
+            if (pushStatus.hasDiverged) {
+                // ABORT: Cannot push diverged branch
+                logger.error('create-pr', 'Branch has diverged from remote', {
+                    branch: currentBranch,
+                    upstream: pushStatus.upstreamBranch
+                });
+                showError('Branch has diverged from remote');
+                console.log('');
+                console.log('Please resolve conflicts manually:');
+                console.log(`  git pull origin ${currentBranch}`);
+                console.log('');
+                process.exit(1);
+            }
+
+            if (!pushConfig?.autoPush) {
+                // Auto-push disabled - show error
+                logger.debug('create-pr', 'Auto-push disabled, aborting', { autoPush: pushConfig?.autoPush });
+                showError('Branch not pushed to remote');
+                console.log('');
+                console.log('Please push your branch first:');
+                console.log(`  git push -u origin ${currentBranch}`);
+                console.log('');
+                process.exit(1);
+            }
+
+            // Show push preview
+            if (pushConfig?.showCommits && pushStatus.unpushedCommits.length > 0) {
+                console.log('');
+                showInfo('Commits to push:');
+                pushStatus.unpushedCommits.forEach(commit => {
+                    console.log(`  ${commit.sha.substring(0, 7)} ${commit.message}`);
+                });
+            }
+
+            // Confirm with user
+            if (pushConfig?.pushConfirm) {
+                console.log('');
+                const shouldPush = await promptConfirmation(
+                    `Push branch '${currentBranch}' to remote?`,
+                    true  // default yes
+                );
+
+                if (!shouldPush) {
+                    logger.debug('create-pr', 'User declined push, aborting');
+                    showInfo('Push cancelled - cannot create PR without pushing');
+                    process.exit(0);
+                }
+            }
+
+            // Execute push
+            console.log('');
+            showInfo('Pushing branch to remote...');
+            logger.debug('create-pr', 'Executing push', {
+                branch: currentBranch,
+                setUpstream: !pushStatus.hasRemote
+            });
+
+            const pushResult = pushBranch(currentBranch, {
+                setUpstream: !pushStatus.hasRemote
+            });
+
+            if (!pushResult.success) {
+                logger.error('create-pr', 'Push failed', {
+                    branch: currentBranch,
+                    error: pushResult.error
+                });
+                showError('Failed to push branch');
+                console.error('');
+                console.error(`  ${pushResult.error}`);
+                console.error('');
+                process.exit(1);
+            }
+
+            logger.debug('create-pr', 'Push completed successfully');
+            showSuccess('Branch pushed successfully');
+            console.log('');
+        } else {
+            logger.debug('create-pr', 'Branch already up-to-date with remote, skipping push');
+        }
+
+        // Step 5.6: Version alignment validation (Issue #44)
+        logger.debug('create-pr', 'Step 5.6: Validating version alignment');
+        const { validateVersionAlignment } = await import('../utils/version-manager.js');
+        const versionCheck = await validateVersionAlignment();
+
+        if (!versionCheck.aligned) {
+            showWarning('Version misalignment detected:');
+            console.log('');
+
+            for (const issue of versionCheck.issues) {
+                console.log(`  ${issue.source}: ${issue.version || 'not found'}`);
+            }
+
+            console.log('');
+            console.log('To fix version alignment:');
+            console.log('  claude-hooks bump-version patch --update-changelog');
+            console.log('');
+
+            const shouldContinue = await promptConfirmation(
+                'Continue creating PR despite version misalignment?',
+                false  // default no
+            );
+
+            if (!shouldContinue) {
+                showInfo('PR creation cancelled - please align versions first');
+                process.exit(0);
+            }
+        }
+
+        if (versionCheck.aligned && versionCheck.comparison === 'equal') {
+            showWarning('Local version equals remote version');
+            console.log(`  Local: ${versionCheck.localVersion}`);
+            console.log(`  Remote: ${versionCheck.remoteVersion}`);
+            console.log('');
+            console.log('To bump version:');
+            console.log('  claude-hooks bump-version patch  # or minor/major');
+            console.log('');
+
+            const shouldContinue = await promptConfirmation(
+                'Continue creating PR without version bump?',
+                true  // default yes (might be non-release PR)
+            );
+
+            if (!shouldContinue) {
+                showInfo('PR creation cancelled');
+                process.exit(0);
+            }
+        }
+
+        if (versionCheck.aligned && versionCheck.comparison === 'less') {
+            showError('Local version is less than remote version!');
+            console.log(`  Local: ${versionCheck.localVersion}`);
+            console.log(`  Remote: ${versionCheck.remoteVersion}`);
+            console.log('');
+            console.log('This usually means you need to pull latest changes:');
+            console.log(`  git pull origin ${baseBranch}`);
+            console.log('');
+
+            const shouldContinue = await promptConfirmation(
+                'Continue creating PR despite version being behind?',
+                false  // default no
+            );
+
+            if (!shouldContinue) {
+                showInfo('PR creation cancelled');
+                process.exit(0);
+            }
+        }
+
+        // Step 5.7: Check for unpushed tags (Issue #44)
+        logger.debug('create-pr', 'Step 5.7: Checking for unpushed tags');
+        const { compareLocalAndRemoteTags, pushTags: pushTagsUtil } = await import('../utils/git-tag-manager.js');
+        const tagComparison = await compareLocalAndRemoteTags();
+
+        if (tagComparison.localNewer.length > 0) {
+            showWarning(`Local tags not pushed: ${tagComparison.localNewer.join(', ')}`);
+            console.log('');
+
+            const shouldPushTags = await promptConfirmation(
+                'Push tags to remote?',
+                true  // default yes
+            );
+
+            if (shouldPushTags) {
+                showInfo('Pushing tags...');
+                const pushResult = pushTagsUtil(null, tagComparison.localNewer);
+
+                if (pushResult.success) {
+                    showSuccess('Tags pushed successfully');
+                } else {
+                    showError(`Failed to push some tags: ${pushResult.error}`);
+                    if (pushResult.failed.length > 0) {
+                        console.log('Failed tags:');
+                        pushResult.failed.forEach(f => console.log(`  - ${f.tag}: ${f.error}`));
+                    }
+                }
+
+                console.log('');
+            } else {
+                showInfo('Tag push skipped');
+                console.log('');
+            }
+        }
+
         // Step 6: Update remote and check for differences
         logger.debug('create-pr', 'Step 6: Fetching latest changes from remote');
         execSync('git fetch', { stdio: 'ignore' });