edsger 0.21.5 → 0.21.7

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) {

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}`);
@@ -224,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/services/branches.d.ts

@@ -61,19 +61,15 @@ export declare function getNextPendingBranch(options: PipelinePhaseOptions): Pro
 export declare function allBranchesCompleted(options: PipelinePhaseOptions): Promise<boolean>;
 /**
  * Get the base branch information for a branch.
- * Returns:
- * - If base_branch_id is null: use main (first branch in chain)
- * - If base_branch_id is set and that branch is completed: use main
- *   (completed means feat merged to main)
- * - If base_branch_id is set and that branch is merged: use base branch's feat branch
- *   (merged means dev merged to feat, not to main)
- * - If base_branch_id is set and that branch is not merged: use base branch's dev branch
  *
- * When base branch is merged/completed (squash merge), we need to use `git rebase --onto` to
- * correctly rebase only the new commits. This function returns both the new base
- * and the original base for this purpose:
- * - completed: baseBranch=main, originalBaseBranch=feat/xxx
- * - merged: baseBranch=feat/xxx, originalBaseBranch=dev/xxx
+ * Rebase strategies based on base branch status:
+ * - no base_branch_id: git rebase main (first branch in chain)
+ * - completed (feat merged to main): git rebase main
+ * - merged (dev merged to feat): git rebase --onto main feat/xxx
+ * - in_progress/pending: git rebase dev/xxx (base on parent dev branch)
+ *
+ * For 'merged' status, we use --onto to rebase only new commits (after feat branch)
+ * onto main, avoiding conflicts from re-applying squashed commits.
  */
 export declare function getBaseBranchInfo(branch: Branch, allBranches: Branch[], mainBranch?: string): Promise<{
     baseBranch: string;

package/dist/services/branches.js

@@ -160,19 +160,15 @@ export async function allBranchesCompleted(options) {
 }
 /**
  * Get the base branch information for a branch.
- * Returns:
- * - If base_branch_id is null: use main (first branch in chain)
- * - If base_branch_id is set and that branch is completed: use main
- *   (completed means feat merged to main)
- * - If base_branch_id is set and that branch is merged: use base branch's feat branch
- *   (merged means dev merged to feat, not to main)
- * - If base_branch_id is set and that branch is not merged: use base branch's dev branch
  *
- * When base branch is merged/completed (squash merge), we need to use `git rebase --onto` to
- * correctly rebase only the new commits. This function returns both the new base
- * and the original base for this purpose:
- * - completed: baseBranch=main, originalBaseBranch=feat/xxx
- * - merged: baseBranch=feat/xxx, originalBaseBranch=dev/xxx
+ * Rebase strategies based on base branch status:
+ * - no base_branch_id: git rebase main (first branch in chain)
+ * - completed (feat merged to main): git rebase main
+ * - merged (dev merged to feat): git rebase --onto main feat/xxx
+ * - in_progress/pending: git rebase dev/xxx (base on parent dev branch)
+ *
+ * For 'merged' status, we use --onto to rebase only new commits (after feat branch)
+ * onto main, avoiding conflicts from re-applying squashed commits.
  */
 export async function getBaseBranchInfo(branch, allBranches, mainBranch = 'main') {
     // No base branch - start from main (first branch in chain)
@@ -195,27 +191,21 @@ export async function getBaseBranchInfo(branch, allBranches, mainBranch = 'main'
     }
     // Check if base branch is completed (feat merged to main)
     if (baseBranch.status === 'completed') {
-        // Base branch's feat is merged to main - rebase directly from main
-        // Use feat branch as originalBaseBranch for --onto
-        if (!baseBranch.branch_name) {
-            return {
-                baseBranch: mainBranch,
-                needsRebase: false,
-                baseBranchMerged: true,
-            };
-        }
-        const featBranchName = baseBranch.branch_name.replace(/^dev\//, 'feat/');
+        // Base branch's feat is already squash-merged to main
+        // Just rebase directly to main - no need for --onto
+        // Main already contains all the changes, so a normal rebase will work correctly
         return {
             baseBranch: mainBranch,
-            originalBaseBranch: featBranchName, // Use feat branch for --onto
-            needsRebase: true,
+            // Don't set originalBaseBranch - we want a normal rebase, not --onto
+            needsRebase: false,
             baseBranchMerged: true,
         };
     }
-    // Check if base branch is merged (dev merged to feat)
+    // Check if base branch is merged (dev merged to feat, but feat not yet merged to main)
     if (baseBranch.status === 'merged') {
-        // Base branch's dev is merged to feat - rebase from base branch's feat branch
-        // Convert dev/xxx/1-name to feat/xxx/1-name
+        // Base branch's dev is squash-merged to feat
+        // Use --onto to rebase only new commits (after feat branch) onto main
+        // This correctly handles the case where feat contains squashed commits
         if (!baseBranch.branch_name) {
             return {
                 baseBranch: mainBranch,
@@ -225,8 +215,8 @@ export async function getBaseBranchInfo(branch, allBranches, mainBranch = 'main'
         }
         const featBranchName = baseBranch.branch_name.replace(/^dev\//, 'feat/');
         return {
-            baseBranch: featBranchName,
-            originalBaseBranch: baseBranch.branch_name, // Return original dev branch for --onto
+            baseBranch: mainBranch, // Rebase onto main
+            originalBaseBranch: featBranchName, // Use feat branch for --onto
             needsRebase: true,
             baseBranchMerged: true,
         };

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.5",
+  "version": "0.21.7",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"