edsger 0.21.6 → 0.21.8

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

@@ -114,6 +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 rebaseTargetBranch;
     let originalBaseBranch;
     if (currentBranch && currentBranch.base_branch_id) {
         try {
@@ -123,11 +124,15 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
             });
             const baseBranchInfo = await getBaseBranchInfo(currentBranch, allBranches, baseBranch);
             actualBaseBranch = baseBranchInfo.baseBranch;
+            rebaseTargetBranch = baseBranchInfo.rebaseTargetBranch;
             originalBaseBranch = baseBranchInfo.originalBaseBranch;
             if (verbose) {
                 logInfo(`🔗 Branch chaining detected:`);
                 logInfo(`   Current branch: ${currentBranch.name}`);
-                logInfo(`   Base branch: ${actualBaseBranch}`);
+                logInfo(`   Base branch (for new branches): ${actualBaseBranch}`);
+                if (rebaseTargetBranch) {
+                    logInfo(`   Rebase target: ${rebaseTargetBranch}`);
+                }
                 if (originalBaseBranch) {
                     logInfo(`   Original base branch: ${originalBaseBranch} (for --onto rebase)`);
                 }
@@ -183,7 +188,8 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
     const { cleanup: cleanupGit } = await prepareCustomBranchGitEnvironmentAsync({
         featureBranch: devBranchName,
         baseBranch: actualBaseBranch,
-        originalBaseBranch, // For --onto rebase when base branch was squash-merged
+        rebaseTargetBranch, // For --onto rebase target (e.g., main) when base branch is merged
+        originalBaseBranch, // For --onto rebase starting point when base branch was squash-merged
         verbose,
         forcePushAfterRebase: featSyncedToMain, // Trigger GitHub to recalculate PR diff
     });

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

@@ -76,6 +76,7 @@ export const refineCodeFromPRFeedback = async (options, config) => {
     let currentBranch = null;
     let allBranches = [];
     let baseBranchForRebase = 'main'; // Default base branch for rebase
+    let rebaseTargetBranchForRebase; // Target for --onto rebase (e.g., main)
     let originalBaseBranchForRebase; // For --onto when base was squash-merged
     try {
         // Get all branches to determine base branch info
@@ -92,9 +93,12 @@ export const refineCodeFromPRFeedback = async (options, config) => {
             const baseBranchInfo = await getBaseBranchInfo(currentBranch, allBranches, 'main');
             // Always use the baseBranch from getBaseBranchInfo - it handles all cases:
             // - No base branch: returns 'main'
-            // - Base branch merged: returns feat branch (dev/xxx -> feat/xxx)
+            // - Base branch merged: returns feat branch (new branches created from feat/xxx)
+            // - Base branch completed: returns main
             // - Base branch not merged: returns dev branch
             baseBranchForRebase = baseBranchInfo.baseBranch;
+            // When base branch is merged, rebaseTargetBranch is 'main' (target for --onto)
+            rebaseTargetBranchForRebase = baseBranchInfo.rebaseTargetBranch;
             // When base branch is merged (squash merge), we need originalBaseBranch for --onto
             originalBaseBranchForRebase = baseBranchInfo.originalBaseBranch;
             if (verbose) {
@@ -162,6 +166,7 @@ export const refineCodeFromPRFeedback = async (options, config) => {
         ? await prepareCustomBranchGitEnvironmentAsync({
             featureBranch: branchName,
             baseBranch: baseBranchForRebase,
+            rebaseTargetBranch: rebaseTargetBranchForRebase,
             originalBaseBranch: originalBaseBranchForRebase,
             verbose,
             resolveConflicts: true,

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

@@ -128,6 +128,7 @@ export const reviewPullRequest = async (options, config) => {
     let currentBranch = null;
     let allBranches = [];
     let baseBranchForRebase = 'main'; // Default base branch for rebase
+    let rebaseTargetBranchForRebase; // Target for --onto rebase (e.g., main)
     let originalBaseBranchForRebase; // For --onto when base was squash-merged
     try {
         // Get all branches to determine base branch info
@@ -145,9 +146,12 @@ export const reviewPullRequest = async (options, config) => {
             const baseBranchInfo = await getBaseBranchInfo(currentBranch, allBranches, 'main');
             // Always use the baseBranch from getBaseBranchInfo - it handles all cases:
             // - No base branch: returns 'main'
-            // - Base branch merged: returns feat branch (dev/xxx -> feat/xxx)
+            // - Base branch merged: returns feat branch (new branches created from feat/xxx)
+            // - Base branch completed: returns main
             // - Base branch not merged: returns dev branch
             baseBranchForRebase = baseBranchInfo.baseBranch;
+            // When base branch is merged, rebaseTargetBranch is 'main' (target for --onto)
+            rebaseTargetBranchForRebase = baseBranchInfo.rebaseTargetBranch;
             // When base branch is merged (squash merge), we need originalBaseBranch for --onto
             originalBaseBranchForRebase = baseBranchInfo.originalBaseBranch;
             if (verbose) {
@@ -215,6 +219,7 @@ export const reviewPullRequest = async (options, config) => {
         ? await prepareCustomBranchGitEnvironmentAsync({
             featureBranch: branchName,
             baseBranch: baseBranchForRebase,
+            rebaseTargetBranch: rebaseTargetBranchForRebase,
             originalBaseBranch: originalBaseBranchForRebase,
             verbose,
             resolveConflicts: true,

package/dist/services/branches.d.ts

@@ -61,22 +61,20 @@ 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): create from feat/xxx, then git rebase --onto main feat/xxx
+ * - in_progress/pending: git rebase dev/xxx (base on parent dev branch)
+ *
+ * For 'merged' status:
+ * - New branches are created from feat/xxx (which contains squashed commits)
+ * - We use --onto to rebase only new commits (after feat branch) onto main
  */
 export declare function getBaseBranchInfo(branch: Branch, allBranches: Branch[], mainBranch?: string): Promise<{
     baseBranch: string;
+    rebaseTargetBranch?: string;
     originalBaseBranch?: string;
     needsRebase: boolean;
     baseBranchMerged: boolean;

package/dist/services/branches.js

@@ -160,19 +160,16 @@ 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): create from feat/xxx, then git rebase --onto main feat/xxx
+ * - in_progress/pending: git rebase dev/xxx (base on parent dev branch)
+ *
+ * For 'merged' status:
+ * - New branches are created from feat/xxx (which contains squashed commits)
+ * - We use --onto to rebase only new commits (after feat branch) onto main
  */
 export async function getBaseBranchInfo(branch, allBranches, mainBranch = 'main') {
     // No base branch - start from main (first branch in chain)
@@ -195,27 +192,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
+        // New branches should be created from feat/xxx (which has the squashed commits)
+        // Use --onto to rebase only new commits (after feat branch) onto main
         if (!baseBranch.branch_name) {
             return {
                 baseBranch: mainBranch,
@@ -225,8 +216,9 @@ 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: featBranchName, // Create new branches from feat/xxx
+            rebaseTargetBranch: mainBranch, // Rebase onto main
+            originalBaseBranch: featBranchName, // Use feat branch for --onto starting point
             needsRebase: true,
             baseBranchMerged: true,
         };

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

@@ -174,10 +174,21 @@ export declare function syncFeatBranchWithMain(featBranch: string, githubToken:
  */
 export interface RebaseWithConflictResolutionOptions {
     featureBranch: string;
+    /**
+     * Base branch to create new branches from.
+     * For merged parent branches, this is feat/xxx.
+     * For completed parent branches, this is main.
+     */
     baseBranch?: string;
+    /**
+     * Target branch for --onto rebase.
+     * When set, uses `git rebase --onto rebaseTargetBranch originalBaseBranch`.
+     * If not set, baseBranch is used as the rebase target.
+     */
+    rebaseTargetBranch?: string;
     /**
      * Original base branch before squash merge.
-     * When set, uses `git rebase --onto baseBranch originalBaseBranch` to only
+     * When set, uses `git rebase --onto <target> originalBaseBranch` to only
      * rebase commits that are new relative to originalBaseBranch.
      * This is required when the base branch was squash-merged, otherwise
      * git will try to reapply all the original commits causing many conflicts.

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

@@ -689,7 +689,10 @@ export async function syncFeatBranchWithMain(featBranch, githubToken, owner, rep
  * @returns Object containing the previous branch name and conflict resolution result
  */
 export async function switchToFeatureBranchAndRebaseAsync(options) {
-    const { featureBranch, baseBranch = 'main', originalBaseBranch, verbose, resolveConflicts = false, conflictResolverConfig, forcePushAfterRebase = false, } = options;
+    const { featureBranch, baseBranch = 'main', rebaseTargetBranch, originalBaseBranch, verbose, resolveConflicts = false, conflictResolverConfig, forcePushAfterRebase = false, } = options;
+    // Determine the actual target branch for rebase
+    // If rebaseTargetBranch is set (e.g., main), use it; otherwise use baseBranch
+    const actualRebaseTarget = rebaseTargetBranch || baseBranch;
     const previousBranch = getCurrentBranch();
     if (verbose) {
         logInfo(`\n🔄 Preparing feature branch: ${featureBranch}`);
@@ -781,13 +784,13 @@ export async function switchToFeatureBranchAndRebaseAsync(options) {
             logInfo(`⚠️  Could not sync with remote feature branch, continuing with local branch`);
         }
     }
-    // Rebase feature branch with latest base branch
+    // Rebase feature branch with latest target branch
     if (verbose) {
         if (originalBaseBranch) {
-            logInfo(`📥 Rebasing ${featureBranch} onto origin/${baseBranch} (from ${originalBaseBranch})...`);
+            logInfo(`📥 Rebasing ${featureBranch} onto origin/${actualRebaseTarget} (from ${originalBaseBranch})...`);
         }
         else {
-            logInfo(`📥 Rebasing ${featureBranch} with origin/${baseBranch}...`);
+            logInfo(`📥 Rebasing ${featureBranch} with origin/${actualRebaseTarget}...`);
         }
     }
     try {
@@ -797,8 +800,8 @@ export async function switchToFeatureBranchAndRebaseAsync(options) {
             }
             resetUncommittedChanges(verbose);
         }
-        // Fetch the base branch first
-        execSync(`git fetch origin ${baseBranch}`, {
+        // Fetch the target branch first
+        execSync(`git fetch origin ${actualRebaseTarget}`, {
             encoding: 'utf-8',
             stdio: 'pipe',
         });
@@ -807,23 +810,28 @@ export async function switchToFeatureBranchAndRebaseAsync(options) {
             // This prevents re-applying commits that were already included in the squash
             // Command: git rebase --onto <new-base> <old-base>
             // This rebases commits from <old-base>..HEAD onto <new-base>
+            // Also fetch the originalBaseBranch for the --onto reference
+            execSync(`git fetch origin ${originalBaseBranch}`, {
+                encoding: 'utf-8',
+                stdio: 'pipe',
+            });
             if (verbose) {
                 logInfo(`   Using --onto to rebase only new commits (after ${originalBaseBranch})`);
             }
-            execSync(`git rebase --onto origin/${baseBranch} origin/${originalBaseBranch}`, {
+            execSync(`git rebase --onto origin/${actualRebaseTarget} origin/${originalBaseBranch}`, {
                 encoding: 'utf-8',
                 stdio: verbose ? 'inherit' : 'pipe',
             });
         }
         else {
             // Normal rebase
-            execSync(`git rebase origin/${baseBranch}`, {
+            execSync(`git rebase origin/${actualRebaseTarget}`, {
                 encoding: 'utf-8',
                 stdio: verbose ? 'inherit' : 'pipe',
             });
         }
         if (verbose) {
-            logInfo(`✅ Successfully rebased ${featureBranch} with origin/${baseBranch}\n`);
+            logInfo(`✅ Successfully rebased ${featureBranch} with origin/${actualRebaseTarget}\n`);
         }
         // Force push after rebase to trigger GitHub to recalculate PR diff
         if (forcePushAfterRebase) {
@@ -866,7 +874,7 @@ export async function switchToFeatureBranchAndRebaseAsync(options) {
             });
             if (result.success) {
                 if (verbose) {
-                    logInfo(`✅ Successfully resolved conflicts and rebased ${featureBranch} with origin/${baseBranch}\n`);
+                    logInfo(`✅ Successfully resolved conflicts and rebased ${featureBranch} with origin/${actualRebaseTarget}\n`);
                 }
                 // Force push after rebase to trigger GitHub to recalculate PR diff
                 if (forcePushAfterRebase) {
@@ -898,7 +906,7 @@ export async function switchToFeatureBranchAndRebaseAsync(options) {
             else {
                 // Conflict resolution failed, abort rebase
                 abortRebase(verbose);
-                throw new Error(`Failed to automatically resolve conflicts during rebase ${featureBranch} with ${baseBranch}.\n` +
+                throw new Error(`Failed to automatically resolve conflicts during rebase ${featureBranch} with ${actualRebaseTarget}.\n` +
                     `${result.error || 'Unknown error'}\n` +
                     `Please resolve conflicts manually and try again.`);
             }
@@ -909,7 +917,7 @@ export async function switchToFeatureBranchAndRebaseAsync(options) {
         if (verbose) {
             logError(`❌ Rebase failed and was aborted. Repository is in clean state.`);
         }
-        throw new Error(`Failed to rebase ${featureBranch} with ${baseBranch}: ${error instanceof Error ? error.message : String(error)}\n` +
+        throw new Error(`Failed to rebase ${featureBranch} with ${actualRebaseTarget}: ${error instanceof Error ? error.message : String(error)}\n` +
             `This usually means there are conflicts between your feature branch and base branch.\n` +
             `Please resolve conflicts manually and try again.`);
     }

package/package.json

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