claude-git-hooks 2.10.0 → 2.11.0

package/CHANGELOG.md

@@ -5,6 +5,39 @@ Todos los cambios notables en este proyecto se documentarán en este archivo.
 El formato está basado en [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 y este proyecto adhiere a [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.11.0] - 2026-02-03
+
+### ✨ Added
+
+- **Auto-push functionality in `create-pr` command** - Automatically detects and pushes unpublished branches before creating PR (#59, #34)
+  - Handles 3 scenarios: unpublished branch, unpushed commits, up-to-date branch
+  - Interactive confirmation prompt before pushing (configurable)
+  - Commit preview showing what will be pushed
+  - Diverged branch detection with helpful error message and resolution steps
+  - Never uses `git push --force` for security
+
+- **New configuration options** under `github.pr`:
+  - `autoPush: true` - Enable/disable auto-push (enabled by default)
+  - `pushConfirm: true` - Prompt for confirmation before push
+  - `showCommits: true` - Show commit preview before push
+  - `verifyRemote: true` - Verify remote exists before push
+
+- **New git-operations functions**:
+  - `getRemoteName()` - Get configured remote name (usually 'origin')
+  - `verifyRemoteExists()` - Check if remote is configured
+  - `getBranchPushStatus()` - Detect branch publish status and unpushed commits
+  - `pushBranch()` - Execute git push with upstream tracking
+
+### 🔧 Fixed
+
+- Issue #59: `create-pr` no longer fails when branch is not published to remote
+- Issue #34: Git push now integrated into create-pr workflow with proper error handling
+
+### 📚 Documentation
+
+- Updated CLAUDE.md with new git-operations functions and configuration options
+- Added comprehensive JSDoc comments for all new functions
+
 ## [2.10.0] - 2026-02-02
 
 ### 🏗️ Architecture - Modular CLI Refactoring

package/README.md

@@ -31,9 +31,16 @@ git commit -m "auto"
 
 ```bash
 claude-hooks create-pr develop
+# Automatically pushes branch if unpublished (with confirmation)
 # Analyzes diff, generates title/description, creates PR on GitHub
 ```
 
+**Auto-push feature (v2.11.0):**
+- Detects unpublished branches or unpushed commits
+- Shows commit preview before pushing
+- Prompts for confirmation (configurable)
+- Handles diverged branches gracefully
+
 ### GitHub Token Setup
 
 ```bash
@@ -221,7 +228,16 @@ Preset always wins - tech-stack specific has priority over user preferences.
   "version": "2.8.0",
   "preset": "backend",
   "overrides": {
-    "github": { "pr": { "defaultBase": "develop", "reviewers": ["user"] } },
+    "github": {
+      "pr": {
+        "defaultBase": "develop",
+        "reviewers": ["user"],
+        "autoPush": true,        // Auto-push unpublished branches (v2.11.0)
+        "pushConfirm": true,     // Prompt before push (v2.11.0)
+        "showCommits": true,     // Show commit preview (v2.11.0)
+        "verifyRemote": true     // Verify remote exists (v2.11.0)
+      }
+    },
     "subagents": { "batchSize": 2 }
   }
 }

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,101 @@ 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 6: Update remote and check for differences
         logger.debug('create-pr', 'Step 6: Fetching latest changes from remote');
         execSync('git fetch', { stdio: 'ignore' });

package/lib/config.js

@@ -101,6 +101,11 @@ const defaults = {
                 ai: ['ai', 'tooling'],
                 default: []
             },
+            // Auto-push configuration (v2.11.0)
+            autoPush: true,                // Auto-push unpublished branches
+            pushConfirm: true,             // Prompt for confirmation before push
+            verifyRemote: true,            // Verify remote exists before push
+            showCommits: true,             // Show commit preview before push
         },
     },
 

package/lib/utils/git-operations.js

@@ -328,6 +328,215 @@ const getStagedStats = () => {
     }
 };
 
+/**
+ * Gets the configured remote name
+ * Why: Determines which remote to use for push operations (usually 'origin')
+ *
+ * @returns {string} Remote name (default: 'origin')
+ */
+const getRemoteName = () => {
+    logger.debug('git-operations - getRemoteName', 'Getting remote name');
+
+    try {
+        // Get list of remotes
+        const remotes = execGitCommand('remote');
+        const remoteList = remotes.split(/\r?\n/).filter(r => r.length > 0);
+
+        if (remoteList.length === 0) {
+            logger.debug('git-operations - getRemoteName', 'No remotes configured');
+            return 'origin'; // Default even if not configured
+        }
+
+        // Prefer 'origin', otherwise use first remote
+        const remoteName = remoteList.includes('origin') ? 'origin' : remoteList[0];
+
+        logger.debug('git-operations - getRemoteName', 'Remote name determined', {
+            remoteName,
+            availableRemotes: remoteList
+        });
+
+        return remoteName;
+
+    } catch (error) {
+        logger.error('git-operations - getRemoteName', 'Failed to get remote name', error);
+        return 'origin'; // Fallback to default
+    }
+};
+
+/**
+ * Verifies that a remote exists and is configured
+ * Why: Prevents push failures by checking remote configuration first
+ *
+ * @param {string} remoteName - Name of remote to verify (e.g., 'origin')
+ * @returns {boolean} True if remote exists, false otherwise
+ */
+const verifyRemoteExists = (remoteName) => {
+    logger.debug('git-operations - verifyRemoteExists', 'Verifying remote exists', { remoteName });
+
+    try {
+        const remotes = execGitCommand('remote');
+        const remoteList = remotes.split(/\r?\n/).filter(r => r.length > 0);
+        const exists = remoteList.includes(remoteName);
+
+        logger.debug('git-operations - verifyRemoteExists', 'Remote verification result', {
+            remoteName,
+            exists,
+            availableRemotes: remoteList
+        });
+
+        return exists;
+
+    } catch (error) {
+        logger.error('git-operations - verifyRemoteExists', 'Failed to verify remote', error);
+        return false;
+    }
+};
+
+/**
+ * Gets branch push status (remote tracking, unpushed commits, divergence)
+ * Why: Determines if and how to push before creating PR
+ *
+ * @param {string} branchName - Branch to check
+ * @returns {Object} Status object with:
+ *   - hasRemote: boolean (branch exists on remote)
+ *   - hasUnpushedCommits: boolean (local commits not pushed)
+ *   - hasDiverged: boolean (local and remote histories differ)
+ *   - upstreamBranch: string (e.g., 'origin/feature-branch')
+ *   - unpushedCommits: Array<{sha, message}> (commits to push)
+ */
+const getBranchPushStatus = (branchName) => {
+    logger.debug('git-operations - getBranchPushStatus', 'Checking branch push status', { branchName });
+
+    const status = {
+        hasRemote: false,
+        hasUnpushedCommits: false,
+        hasDiverged: false,
+        upstreamBranch: null,
+        unpushedCommits: []
+    };
+
+    try {
+        // Check if branch has upstream tracking
+        // Use execSync directly to avoid logging expected "no upstream" errors
+        const upstream = execSync(
+            `git rev-parse --abbrev-ref --symbolic-full-name ${branchName}@{u}`,
+            { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
+        ).trim();
+
+        status.upstreamBranch = upstream;
+        status.hasRemote = true;
+
+        logger.debug('git-operations - getBranchPushStatus', 'Branch has upstream', {
+            branchName,
+            upstream
+        });
+
+        // Check for unpushed commits (local ahead of remote)
+        const unpushedLog = execGitCommand(`rev-list ${upstream}..${branchName} --oneline`);
+        if (unpushedLog) {
+            status.hasUnpushedCommits = true;
+            status.unpushedCommits = unpushedLog.split(/\r?\n/)
+                .filter(line => line.length > 0)
+                .map(line => {
+                    const [sha, ...messageParts] = line.split(' ');
+                    return {
+                        sha,
+                        message: messageParts.join(' ')
+                    };
+                });
+        }
+
+        // Check for divergence (remote has commits not in local)
+        const divergedLog = execGitCommand(`rev-list ${branchName}..${upstream} --oneline`);
+        if (divergedLog) {
+            status.hasDiverged = true;
+            logger.debug('git-operations - getBranchPushStatus', 'Branch has diverged', {
+                branchName,
+                remoteCommits: divergedLog.split(/\r?\n/).length
+            });
+        }
+
+    } catch (error) {
+        // No upstream means branch not published to remote (this is expected, not an error)
+        logger.debug('git-operations - getBranchPushStatus', 'Branch has no upstream (not published)', {
+            branchName
+        });
+
+        status.hasRemote = false;
+        status.hasUnpushedCommits = true; // All commits are unpushed
+
+        // Get all commits on this branch (not on any remote branch)
+        try {
+            const remoteName = getRemoteName();
+            const allCommits = execGitCommand(`rev-list ${branchName} --not --remotes=${remoteName} --oneline`);
+            if (allCommits) {
+                status.unpushedCommits = allCommits.split(/\r?\n/)
+                    .filter(line => line.length > 0)
+                    .map(line => {
+                        const [sha, ...messageParts] = line.split(' ');
+                        return {
+                            sha,
+                            message: messageParts.join(' ')
+                        };
+                    });
+            }
+        } catch (commitError) {
+            logger.debug('git-operations - getBranchPushStatus', 'Could not get unpushed commits', commitError);
+        }
+    }
+
+    logger.debug('git-operations - getBranchPushStatus', 'Push status determined', status);
+
+    return status;
+};
+
+/**
+ * Pushes branch to remote
+ * Why: Publishes local branch to remote before creating PR
+ *
+ * @param {string} branchName - Branch to push
+ * @param {Object} options - Push options
+ * @param {boolean} options.setUpstream - Use -u flag to set upstream tracking (default: false)
+ * @returns {Object} Result object with:
+ *   - success: boolean
+ *   - output: string (stdout)
+ *   - error: string (stderr)
+ */
+const pushBranch = (branchName, { setUpstream = false } = {}) => {
+    logger.debug('git-operations - pushBranch', 'Pushing branch', { branchName, setUpstream });
+
+    try {
+        const remoteName = getRemoteName();
+        const upstreamFlag = setUpstream ? '-u' : '';
+        const command = upstreamFlag
+            ? `push ${upstreamFlag} ${remoteName} ${branchName}`
+            : `push ${remoteName} ${branchName}`;
+
+        const output = execGitCommand(command);
+
+        logger.debug('git-operations - pushBranch', 'Push successful', {
+            branchName,
+            remoteName,
+            setUpstream
+        });
+
+        return {
+            success: true,
+            output,
+            error: ''
+        };
+
+    } catch (error) {
+        logger.error('git-operations - pushBranch', 'Push failed', error);
+
+        return {
+            success: false,
+            output: error.output || '',
+            error: error.cause?.message || error.message || 'Unknown push error'
+        };
+    }
+};
+
 export {
     GitError,
     getStagedFiles,
@@ -337,5 +546,9 @@ export {
     getRepoRoot,
     getCurrentBranch,
     getRepoName,
-    getStagedStats
+    getStagedStats,
+    getRemoteName,
+    verifyRemoteExists,
+    getBranchPushStatus,
+    pushBranch
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-git-hooks",
-    "version": "2.10.0",
+    "version": "2.11.0",
     "description": "Git hooks with Claude CLI for code analysis and automatic commit messages",
     "type": "module",
     "bin": {