edsger 0.21.4 → 0.21.6

package/dist/phases/code-implementation/branch-pr-creator.js

@@ -42,6 +42,7 @@ export function devBranchToFeatBranch(devBranchName) {
 }
 /**
  * Push a branch to remote
+ * Falls back to force-with-lease if normal push fails (e.g., after rebase)
  */
 async function pushBranch(branchName, verbose) {
     try {
@@ -66,8 +67,27 @@ async function pushBranch(branchName, verbose) {
                 return { success: true };
             }
             catch (retryError) {
-                const errorMessage = retryError instanceof Error ? retryError.message : String(retryError);
-                return { success: false, error: errorMessage };
+                // If push still fails (likely non-fast-forward after rebase),
+                // use force-with-lease for safer force push
+                if (verbose) {
+                    logInfo(`⚠️  Push rejected, attempting force push with lease...`);
+                }
+                try {
+                    execSync(`git push --force-with-lease origin ${branchName}`, {
+                        encoding: 'utf-8',
+                        stdio: verbose ? 'inherit' : 'pipe',
+                    });
+                    if (verbose) {
+                        logInfo(`✅ Successfully force pushed ${branchName}`);
+                    }
+                    return { success: true };
+                }
+                catch (forceError) {
+                    const errorMessage = forceError instanceof Error
+                        ? forceError.message
+                        : String(forceError);
+                    return { success: false, error: errorMessage };
+                }
             }
         }
     }

package/dist/phases/code-implementation/index.js

@@ -6,7 +6,7 @@ import { fetchCodeImplementationContext, formatContextForPrompt, } from './conte
 import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
 import { buildImplementationResult, buildVerificationFailureResult, buildNoResultsError, } from './outcome.js';
 import { performVerificationCycle } from '../code-implementation-verification/index.js';
-import { prepareCustomBranchGitEnvironment, syncFeatBranchWithMain, } from '../../utils/git-branch-manager.js';
+import { prepareCustomBranchGitEnvironmentAsync, syncFeatBranchWithMain, } from '../../utils/git-branch-manager.js';
 import { getCurrentBranch, updateBranch, getBranches, createBranches, getBaseBranchInfo, } from '../../services/branches.js';
 import { createBranchPullRequest, } from './branch-pr-creator.js';
 import { getGitHubConfig } from '../../api/github.js';
@@ -114,7 +114,7 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
     // Determine the actual base branch for branch chaining
     // If the current feature branch depends on another branch, use that as the base
     let actualBaseBranch = baseBranch;
-    let needsRebase = false;
+    let originalBaseBranch;
     if (currentBranch && currentBranch.base_branch_id) {
         try {
             const allBranches = await getBranches({
@@ -123,20 +123,20 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
             });
             const baseBranchInfo = await getBaseBranchInfo(currentBranch, allBranches, baseBranch);
             actualBaseBranch = baseBranchInfo.baseBranch;
-            needsRebase = baseBranchInfo.needsRebase;
+            originalBaseBranch = baseBranchInfo.originalBaseBranch;
             if (verbose) {
                 logInfo(`🔗 Branch chaining detected:`);
                 logInfo(`   Current branch: ${currentBranch.name}`);
                 logInfo(`   Base branch: ${actualBaseBranch}`);
+                if (originalBaseBranch) {
+                    logInfo(`   Original base branch: ${originalBaseBranch} (for --onto rebase)`);
+                }
                 if (baseBranchInfo.baseBranchMerged) {
-                    logInfo(`   Parent branch merged: yes (using main)`);
+                    logInfo(`   Parent branch merged: yes`);
                 }
                 else {
                     logInfo(`   Parent branch merged: no (using parent branch)`);
                 }
-                if (needsRebase) {
-                    logInfo(`   Rebase needed: yes`);
-                }
             }
         }
         catch (error) {
@@ -178,29 +178,15 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
             }
         }
     }
-    const cleanupGit = prepareCustomBranchGitEnvironment(devBranchName, actualBaseBranch, verbose);
-    // Force push after rebase to trigger GitHub to recalculate PR diff
-    if (featSyncedToMain) {
-        try {
-            const { execSync } = await import('child_process');
-            if (verbose) {
-                logInfo(`📤 Force pushing ${devBranchName} to trigger PR diff recalculation...`);
-            }
-            execSync(`git push --force-with-lease origin ${devBranchName}`, {
-                encoding: 'utf-8',
-                stdio: verbose ? 'inherit' : 'pipe',
-            });
-            if (verbose) {
-                logInfo(`✅ Successfully force pushed ${devBranchName}`);
-            }
-        }
-        catch (pushError) {
-            if (verbose) {
-                logInfo(`⚠️  Could not force push ${devBranchName}: ${pushError instanceof Error ? pushError.message : String(pushError)}`);
-            }
-            // Don't fail the whole process if push fails
-        }
-    }
+    // Use async version to support --onto rebase for branch chaining
+    // This correctly handles cases where base branch was squash-merged
+    const { cleanup: cleanupGit } = await prepareCustomBranchGitEnvironmentAsync({
+        featureBranch: devBranchName,
+        baseBranch: actualBaseBranch,
+        originalBaseBranch, // For --onto rebase when base branch was squash-merged
+        verbose,
+        forcePushAfterRebase: featSyncedToMain, // Trigger GitHub to recalculate PR diff
+    });
     try {
         // Fetch all required context information via MCP endpoints
         if (verbose) {
@@ -856,6 +842,7 @@ const parseImplementationResponse = (response, featureId) => {
 };
 /**
  * Push branch to remote repository
+ * Falls back to force-with-lease if normal push fails (e.g., after rebase)
  */
 async function pushToRemote(branchName, verbose) {
     try {
@@ -883,11 +870,31 @@ async function pushToRemote(branchName, verbose) {
                 return { success: true };
             }
             catch (retryError) {
-                const errorMessage = retryError instanceof Error ? retryError.message : String(retryError);
-                return {
-                    success: false,
-                    error: errorMessage,
-                };
+                // If push still fails (likely non-fast-forward after rebase),
+                // use force-with-lease for safer force push
+                // force-with-lease ensures we don't overwrite others' work by checking remote state
+                if (verbose) {
+                    logInfo(`⚠️  Push rejected, attempting force push with lease...`);
+                }
+                try {
+                    execSync(`git push --force-with-lease origin ${branchName}`, {
+                        encoding: 'utf-8',
+                        stdio: verbose ? 'inherit' : 'pipe',
+                    });
+                    if (verbose) {
+                        logInfo(`✅ Successfully force pushed ${branchName}`);
+                    }
+                    return { success: true };
+                }
+                catch (forceError) {
+                    const errorMessage = forceError instanceof Error
+                        ? forceError.message
+                        : String(forceError);
+                    return {
+                        success: false,
+                        error: errorMessage,
+                    };
+                }
             }
         }
     }

package/dist/phases/pull-request/creator.js

@@ -62,12 +62,44 @@ const discardUncommittedChanges = (verbose) => {
 };
 /**
  * Switch to an existing branch
+ * By default, checks remote if branch doesn't exist locally (handles multi-clone scenarios)
+ * @param branch - The branch to switch to
+ * @param verbose - Whether to log verbose output
  */
 const switchToBranch = (branch, verbose) => {
     try {
-        // First check if branch exists
+        // First check if branch exists locally
         if (!branchExists(branch)) {
-            throw new Error(`Branch '${branch}' does not exist. The branch should have been created during code implementation phase.`);
+            // Branch doesn't exist locally, try to fetch and create tracking branch from remote
+            if (verbose) {
+                console.log(`🔍 Branch '${branch}' not found locally, checking remote...`);
+            }
+            try {
+                // Fetch to get latest remote refs
+                execSync('git fetch origin', { encoding: 'utf-8', stdio: 'pipe' });
+                // Check if remote branch exists
+                execSync(`git rev-parse --verify origin/${branch}`, {
+                    encoding: 'utf-8',
+                    stdio: 'pipe',
+                });
+                // Remote branch exists, create local tracking branch
+                if (verbose) {
+                    console.log(`📥 Found branch '${branch}' on remote, creating local tracking branch...`);
+                }
+                // Discard any uncommitted changes before creating branch
+                discardUncommittedChanges(verbose);
+                execSync(`git checkout -b ${branch} --track origin/${branch}`, {
+                    encoding: 'utf-8',
+                });
+                if (verbose) {
+                    console.log(`✅ Created and switched to tracking branch: ${branch}`);
+                }
+                return;
+            }
+            catch (e) {
+                // Remote branch doesn't exist either
+                throw new Error(`Branch '${branch}' does not exist locally or on remote. The branch should have been created during code implementation phase.`);
+            }
         }
         if (verbose) {
             console.log(`🔀 Switching to branch: ${branch}`);
@@ -85,6 +117,7 @@ const switchToBranch = (branch, verbose) => {
 };
 /**
  * Push current branch to remote
+ * Falls back to force-with-lease if normal push fails (e.g., after rebase)
  */
 const pushBranch = (branch, verbose) => {
     try {
@@ -97,7 +130,22 @@ const pushBranch = (branch, verbose) => {
         }
     }
     catch (error) {
-        throw new Error(`Failed to push branch: ${error}`);
+        // If push fails (likely non-fast-forward after rebase),
+        // use force-with-lease for safer force push
+        if (verbose) {
+            console.log(`⚠️  Push rejected, attempting force push with lease...`);
+        }
+        try {
+            execSync(`git push --force-with-lease origin ${branch}`, {
+                encoding: 'utf-8',
+            });
+            if (verbose) {
+                console.log(`✅ Successfully force pushed ${branch}`);
+            }
+        }
+        catch (forceError) {
+            throw new Error(`Failed to push branch: ${forceError}`);
+        }
     }
 };
 /**
@@ -208,6 +256,7 @@ export async function createPullRequest(config, feature) {
             console.log(`🔍 Current branch: ${currentBranch}`);
         }
         // If we're on the base branch, switch to dev branch (should already exist)
+        // Default behavior now checks remote if not found locally (multi-clone scenario)
         if (currentBranch === baseBranch) {
             const devBranch = `dev/${feature.id}`;
             if (verbose) {

package/dist/utils/git-branch-manager.d.ts

@@ -68,10 +68,34 @@ export declare function branchExists(branch: string): boolean;
  * Check if a remote branch exists
  */
 export declare function remoteBranchExists(branch: string): boolean;
+/**
+ * Options for switchToBranch
+ */
+export interface SwitchToBranchOptions {
+    /**
+     * Skip checking remote for branch existence.
+     * By default, switchToBranch will check remote if branch doesn't exist locally,
+     * and create a tracking branch if found on remote.
+     * Set this to true to skip the remote check (useful for well-known local branches like 'main').
+     */
+    skipRemoteCheck?: boolean;
+}
 /**
  * Switch to a specific Git branch, creating it if it doesn't exist
+ *
+ * By default, if the branch doesn't exist locally, it will:
+ * 1. Fetch from origin to check if branch exists on remote
+ * 2. If found on remote, create a local tracking branch from it
+ * 3. If not found on remote, create a new branch from current HEAD
+ *
+ * This handles multi-clone scenarios where a branch may have been created
+ * and pushed from another local clone.
+ *
+ * @param branch - The branch name to switch to
+ * @param verbose - Whether to log verbose output
+ * @param options - Additional options for branch switching
  */
-export declare function switchToBranch(branch: string, verbose?: boolean): void;
+export declare function switchToBranch(branch: string, verbose?: boolean, options?: SwitchToBranchOptions): void;
 /**
  * Pull latest changes from remote for a specific branch
  */

package/dist/utils/git-branch-manager.js

@@ -240,20 +240,32 @@ export function remoteBranchExists(branch) {
 }
 /**
  * Switch to a specific Git branch, creating it if it doesn't exist
+ *
+ * By default, if the branch doesn't exist locally, it will:
+ * 1. Fetch from origin to check if branch exists on remote
+ * 2. If found on remote, create a local tracking branch from it
+ * 3. If not found on remote, create a new branch from current HEAD
+ *
+ * This handles multi-clone scenarios where a branch may have been created
+ * and pushed from another local clone.
+ *
+ * @param branch - The branch name to switch to
+ * @param verbose - Whether to log verbose output
+ * @param options - Additional options for branch switching
  */
-export function switchToBranch(branch, verbose) {
+export function switchToBranch(branch, verbose, options) {
     try {
         if (verbose) {
             logInfo(`🔄 Switching to branch ${branch}...`);
         }
         // Check if branch exists locally
-        const exists = branchExists(branch);
-        if (exists) {
-            // Branch exists, just switch to it
+        const localExists = branchExists(branch);
+        if (localExists) {
+            // Branch exists locally, just switch to it
             execSync(`git checkout ${branch}`, { encoding: 'utf-8', stdio: 'pipe' });
         }
-        else {
-            // Branch doesn't exist, create it from current HEAD
+        else if (options?.skipRemoteCheck) {
+            // Skip remote check, just create from current HEAD
             if (verbose) {
                 logInfo(`   Branch ${branch} doesn't exist, creating it...`);
             }
@@ -262,6 +274,37 @@ export function switchToBranch(branch, verbose) {
                 stdio: 'pipe',
             });
         }
+        else {
+            // Default: Check if branch exists on remote before creating locally
+            // This handles multi-clone scenarios where branch was pushed from another clone
+            try {
+                // Fetch to get latest remote refs
+                execSync('git fetch origin', { encoding: 'utf-8', stdio: 'pipe' });
+                // Check if remote branch exists
+                execSync(`git rev-parse --verify origin/${branch}`, {
+                    encoding: 'utf-8',
+                    stdio: 'pipe',
+                });
+                // Remote branch exists, create local tracking branch from it
+                if (verbose) {
+                    logInfo(`   Branch ${branch} found on remote, creating local tracking branch...`);
+                }
+                execSync(`git checkout -b ${branch} --track origin/${branch}`, {
+                    encoding: 'utf-8',
+                    stdio: 'pipe',
+                });
+            }
+            catch (e) {
+                // Remote branch doesn't exist, create new branch from current HEAD
+                if (verbose) {
+                    logInfo(`   Branch ${branch} doesn't exist locally or remotely, creating new branch...`);
+                }
+                execSync(`git checkout -b ${branch}`, {
+                    encoding: 'utf-8',
+                    stdio: 'pipe',
+                });
+            }
+        }
         if (verbose) {
             logInfo(`✅ Switched to ${branch} branch`);
         }
@@ -338,11 +381,12 @@ export function switchToFeatureBranchAndRebase(featureBranch, baseBranch = 'main
         }
     }
     // Switch to feature branch (will create if doesn't exist)
+    // Default behavior now checks remote first (handles multi-clone scenarios)
     if (getCurrentBranch() !== featureBranch) {
         switchToBranch(featureBranch, verbose);
     }
-    // Sync with remote feature branch if it exists
-    // This handles the case where the branch was pushed from another machine
+    // Sync with remote feature branch if it exists and local branch needs updating
+    // This handles the case where local branch exists but is behind remote
     try {
         // Check for uncommitted changes and reset if found before any git operations
         if (hasUncommittedChanges()) {
@@ -351,7 +395,7 @@ export function switchToFeatureBranchAndRebase(featureBranch, baseBranch = 'main
             }
             resetUncommittedChanges(verbose);
         }
-        // Fetch to get latest remote state
+        // Fetch to get latest remote state (may have been fetched in switchToBranch, but ensures fresh data)
         execSync('git fetch origin', { encoding: 'utf-8', stdio: 'pipe' });
         // Check if remote feature branch exists
         try {
@@ -359,18 +403,35 @@ export function switchToFeatureBranchAndRebase(featureBranch, baseBranch = 'main
                 encoding: 'utf-8',
                 stdio: 'pipe',
             });
-            // Remote branch exists, sync with it
-            if (verbose) {
-                logInfo(`📥 Syncing with remote feature branch origin/${featureBranch}...`);
-            }
-            // Reset local branch to match remote branch
-            // This ensures we have all commits from the remote (e.g., from another machine)
-            execSync(`git reset --hard origin/${featureBranch}`, {
+            // Remote branch exists, check if we need to sync
+            // Get local and remote commit SHAs
+            const localSha = execSync(`git rev-parse ${featureBranch}`, {
                 encoding: 'utf-8',
                 stdio: 'pipe',
-            });
-            if (verbose) {
-                logInfo(`✅ Synced local branch with origin/${featureBranch}`);
+            }).trim();
+            const remoteSha = execSync(`git rev-parse origin/${featureBranch}`, {
+                encoding: 'utf-8',
+                stdio: 'pipe',
+            }).trim();
+            if (localSha !== remoteSha) {
+                // Local and remote differ, reset to remote
+                if (verbose) {
+                    logInfo(`📥 Syncing with remote feature branch origin/${featureBranch}...`);
+                    logInfo(`   Local:  ${localSha.substring(0, 7)}`);
+                    logInfo(`   Remote: ${remoteSha.substring(0, 7)}`);
+                }
+                // Reset local branch to match remote branch
+                // This ensures we have all commits from the remote (e.g., from another machine)
+                execSync(`git reset --hard origin/${featureBranch}`, {
+                    encoding: 'utf-8',
+                    stdio: 'pipe',
+                });
+                if (verbose) {
+                    logInfo(`✅ Synced local branch with origin/${featureBranch}`);
+                }
+            }
+            else if (verbose) {
+                logInfo(`✅ Local branch is up to date with origin/${featureBranch}`);
             }
         }
         catch (e) {
@@ -660,10 +721,12 @@ export async function switchToFeatureBranchAndRebaseAsync(options) {
         }
     }
     // Switch to feature branch (will create if doesn't exist)
+    // Default behavior now checks remote first (handles multi-clone scenarios)
     if (getCurrentBranch() !== featureBranch) {
         switchToBranch(featureBranch, verbose);
     }
-    // Sync with remote feature branch if it exists
+    // Sync with remote feature branch if it exists and local branch needs updating
+    // This handles the case where local branch exists but is behind remote
     try {
         if (hasUncommittedChanges()) {
             if (verbose) {
@@ -671,21 +734,40 @@ export async function switchToFeatureBranchAndRebaseAsync(options) {
             }
             resetUncommittedChanges(verbose);
         }
+        // Fetch to get latest remote state (may have been fetched in switchToBranch, but ensures fresh data)
         execSync('git fetch origin', { encoding: 'utf-8', stdio: 'pipe' });
         try {
             execSync(`git rev-parse --verify origin/${featureBranch}`, {
                 encoding: 'utf-8',
                 stdio: 'pipe',
             });
-            if (verbose) {
-                logInfo(`📥 Syncing with remote feature branch origin/${featureBranch}...`);
-            }
-            execSync(`git reset --hard origin/${featureBranch}`, {
+            // Remote branch exists, check if we need to sync
+            // Get local and remote commit SHAs
+            const localSha = execSync(`git rev-parse ${featureBranch}`, {
                 encoding: 'utf-8',
                 stdio: 'pipe',
-            });
-            if (verbose) {
-                logInfo(`✅ Synced local branch with origin/${featureBranch}`);
+            }).trim();
+            const remoteSha = execSync(`git rev-parse origin/${featureBranch}`, {
+                encoding: 'utf-8',
+                stdio: 'pipe',
+            }).trim();
+            if (localSha !== remoteSha) {
+                // Local and remote differ, reset to remote
+                if (verbose) {
+                    logInfo(`📥 Syncing with remote feature branch origin/${featureBranch}...`);
+                    logInfo(`   Local:  ${localSha.substring(0, 7)}`);
+                    logInfo(`   Remote: ${remoteSha.substring(0, 7)}`);
+                }
+                execSync(`git reset --hard origin/${featureBranch}`, {
+                    encoding: 'utf-8',
+                    stdio: 'pipe',
+                });
+                if (verbose) {
+                    logInfo(`✅ Synced local branch with origin/${featureBranch}`);
+                }
+            }
+            else if (verbose) {
+                logInfo(`✅ Local branch is up to date with origin/${featureBranch}`);
             }
         }
         catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.21.4",
+  "version": "0.21.6",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"