edsger 0.13.2 → 0.13.3

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

@@ -8,7 +8,9 @@ import { execSync } from 'child_process';
 import { fetchCodeRefineContext, } from './context.js';
 import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
 import { createSystemPrompt, createCodeRefinePrompt } from './prompts.js';
-import { preparePhaseGitEnvironment, hasUncommittedChanges, getUncommittedFiles, } from '../../utils/git-branch-manager.js';
+import { preparePhaseGitEnvironment, hasUncommittedChanges, getUncommittedFiles, syncFeatBranchWithMain, } from '../../utils/git-branch-manager.js';
+import { getFeature } from '../../api/features/get-feature.js';
+import { parsePullRequestUrl } from './context.js';
 function userMessage(content) {
     return {
         type: 'user',
@@ -62,6 +64,23 @@ export const refineCodeFromPRFeedback = async (options, config) => {
     if (verbose) {
         logInfo(`Starting code refine for feature ID: ${featureId}`);
     }
+    // Sync feat branch with main before preparing git environment
+    // This prevents extra commits from appearing in PR when dev branch is rebased
+    try {
+        const feature = await getFeature(featureId, verbose);
+        if (feature.pull_request_url) {
+            const prInfo = parsePullRequestUrl(feature.pull_request_url);
+            if (prInfo) {
+                await syncFeatBranchWithMain(featureId, githubToken, prInfo.owner, prInfo.repo, 'main', verbose);
+            }
+        }
+    }
+    catch (error) {
+        if (verbose) {
+            logInfo(`⚠️  Could not sync feat branch: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Continue even if sync fails - it's not critical
+    }
     // Prepare git environment: switch to feature branch and rebase with main
     const cleanupGit = preparePhaseGitEnvironment(featureId, 'main', verbose);
     try {

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

@@ -71,3 +71,16 @@ export declare function returnToMainBranch(baseBranch?: string, verbose?: boolea
  * @returns Cleanup function that will return to main branch
  */
 export declare function preparePhaseGitEnvironment(featureId: string, baseBranch?: string, verbose?: boolean): () => void;
+/**
+ * Sync feat branch with main using GitHub API
+ * This ensures the feat branch (PR base) is up to date with main,
+ * preventing extra commits from appearing in PRs when dev branch is rebased.
+ *
+ * @param featureId - The feature ID (will be used to construct branch name "feat/{featureId}")
+ * @param githubToken - GitHub personal access token or app token
+ * @param owner - Repository owner
+ * @param repo - Repository name
+ * @param baseBranch - The base branch to sync from (default: "main")
+ * @param verbose - Whether to log verbose output
+ */
+export declare function syncFeatBranchWithMain(featureId: string, githubToken: string, owner: string, repo: string, baseBranch?: string, verbose?: boolean): Promise<boolean>;

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

@@ -3,6 +3,7 @@
  * Shared utilities for consistent git branch management across all phases
  */
 import { execSync } from 'child_process';
+import { Octokit } from '@octokit/rest';
 import { logInfo, logError } from './logger.js';
 /**
  * Get current Git branch name
@@ -358,3 +359,100 @@ export function preparePhaseGitEnvironment(featureId, baseBranch = 'main', verbo
     // Return cleanup function
     return cleanup;
 }
+/**
+ * Sync feat branch with main using GitHub API
+ * This ensures the feat branch (PR base) is up to date with main,
+ * preventing extra commits from appearing in PRs when dev branch is rebased.
+ *
+ * @param featureId - The feature ID (will be used to construct branch name "feat/{featureId}")
+ * @param githubToken - GitHub personal access token or app token
+ * @param owner - Repository owner
+ * @param repo - Repository name
+ * @param baseBranch - The base branch to sync from (default: "main")
+ * @param verbose - Whether to log verbose output
+ */
+export async function syncFeatBranchWithMain(featureId, githubToken, owner, repo, baseBranch = 'main', verbose) {
+    const featBranch = `feat/${featureId}`;
+    try {
+        const octokit = new Octokit({ auth: githubToken });
+        // Check if feat branch exists
+        if (verbose) {
+            logInfo(`🔍 Checking if ${featBranch} branch exists...`);
+        }
+        try {
+            await octokit.repos.getBranch({
+                owner,
+                repo,
+                branch: featBranch,
+            });
+        }
+        catch (error) {
+            if (error.status === 404) {
+                if (verbose) {
+                    logInfo(`ℹ️  ${featBranch} branch does not exist, skipping sync`);
+                }
+                return true; // Not an error, just no feat branch yet
+            }
+            throw error;
+        }
+        // Get the latest SHA of the base branch
+        const { data: baseBranchData } = await octokit.repos.getBranch({
+            owner,
+            repo,
+            branch: baseBranch,
+        });
+        const mainSha = baseBranchData.commit.sha;
+        // Get the current SHA of the feat branch
+        const { data: featBranchData } = await octokit.repos.getBranch({
+            owner,
+            repo,
+            branch: featBranch,
+        });
+        const featSha = featBranchData.commit.sha;
+        // Check if feat branch is already up to date (same as main or ahead)
+        // We need to merge main into feat to keep it updated
+        if (verbose) {
+            logInfo(`📥 Syncing ${featBranch} with ${baseBranch}...`);
+            logInfo(`   ${baseBranch} SHA: ${mainSha.substring(0, 7)}`);
+            logInfo(`   ${featBranch} SHA: ${featSha.substring(0, 7)}`);
+        }
+        // Use GitHub merge API to merge main into feat branch
+        try {
+            await octokit.repos.merge({
+                owner,
+                repo,
+                base: featBranch,
+                head: baseBranch,
+                commit_message: `chore: sync ${featBranch} with ${baseBranch}`,
+            });
+            if (verbose) {
+                logInfo(`✅ Successfully synced ${featBranch} with ${baseBranch}`);
+            }
+        }
+        catch (mergeError) {
+            // 409 means nothing to merge (already up to date)
+            if (mergeError.status === 409) {
+                if (verbose) {
+                    logInfo(`ℹ️  ${featBranch} is already up to date with ${baseBranch}`);
+                }
+                return true;
+            }
+            // 404 means branch doesn't exist (shouldn't happen since we checked above)
+            if (mergeError.status === 404) {
+                if (verbose) {
+                    logInfo(`ℹ️  ${featBranch} branch not found, skipping sync`);
+                }
+                return true;
+            }
+            throw mergeError;
+        }
+        return true;
+    }
+    catch (error) {
+        if (verbose) {
+            logError(`⚠️  Failed to sync ${featBranch} with ${baseBranch}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        // Don't fail the whole process if sync fails, just log warning
+        return false;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.13.2",
+  "version": "0.13.3",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"
@@ -53,4 +53,4 @@
       "optional": false
     }
   }
-}
+}