edsger 0.13.1 → 0.13.3

package/dist/phases/code-refine/context.d.ts

@@ -20,6 +20,7 @@ export interface PRReviewComment {
 }
 export interface PRReview {
     id: number;
+    node_id: string;
     user: {
         login: string;
     };

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

@@ -30,8 +30,19 @@ export async function fetchPRReviews(octokit, owner, repo, prNumber, verbose) {
         repo,
         pull_number: prNumber,
     });
-    // Filter for reviews that request changes
-    const requestChangesReviews = reviews.filter((review) => review.state === 'CHANGES_REQUESTED');
+    // Filter for reviews that request changes and map to our interface
+    const requestChangesReviews = reviews
+        .filter((review) => review.state === 'CHANGES_REQUESTED')
+        .map((review) => ({
+        id: review.id,
+        node_id: review.node_id, // REST API also returns node_id
+        user: {
+            login: review.user?.login || 'unknown',
+        },
+        body: review.body ?? null,
+        state: review.state,
+        submitted_at: review.submitted_at ?? null,
+    }));
     if (verbose) {
         console.log(`✅ Found ${requestChangesReviews.length} reviews requesting changes`);
     }
@@ -117,6 +128,7 @@ export async function fetchPRDataGraphQL(octokit, owner, repo, prNumber, verbose
     // Transform GraphQL reviews to our interface
     const reviews = (pullRequest.reviews.nodes || []).map((review) => ({
         id: review.databaseId,
+        node_id: review.id, // GraphQL Node ID for mutations
         user: {
             login: review.author?.login || 'unknown',
         },

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/phases/code-refine-verification/github.d.ts

@@ -4,6 +4,7 @@
  */
 import { Octokit } from '@octokit/rest';
 import { ReviewThread, PRFileChange } from './types.js';
+import { PRReview } from '../code-refine/context.js';
 /**
  * Fetch complete file content from a specific ref (branch/commit)
  */
@@ -21,3 +22,9 @@ export declare function fetchUnresolvedReviewThreads(octokit: Octokit, owner: st
  * Mark review threads as resolved using GraphQL API
  */
 export declare function resolveReviewThreads(octokit: Octokit, threads: ReviewThread[], verbose?: boolean): Promise<number>;
+/**
+ * Dismiss pull request reviews using GraphQL API
+ * This is used to automatically dismiss "CHANGES_REQUESTED" reviews
+ * after all feedback has been addressed by code refine
+ */
+export declare function dismissReviews(octokit: Octokit, reviews: PRReview[], resolvedCommentsCount: number, verbose?: boolean): Promise<number>;

package/dist/phases/code-refine-verification/github.js

@@ -188,3 +188,49 @@ export async function resolveReviewThreads(octokit, threads, verbose) {
     }
     return markedCount;
 }
+/**
+ * Dismiss pull request reviews using GraphQL API
+ * This is used to automatically dismiss "CHANGES_REQUESTED" reviews
+ * after all feedback has been addressed by code refine
+ */
+export async function dismissReviews(octokit, reviews, resolvedCommentsCount, verbose) {
+    let dismissedCount = 0;
+    for (const review of reviews) {
+        try {
+            if (verbose) {
+                logInfo(`🔄 Dismissing review ${review.id} by @${review.user.login}...`);
+            }
+            // Build dismiss message explaining what was resolved
+            const message = `All feedback has been addressed by automated code refine.\n\n` +
+                `✅ Resolved ${resolvedCommentsCount} review comment(s).\n\n` +
+                `Please re-review if you disagree with any changes.`;
+            const mutation = `
+        mutation($pullRequestReviewId: ID!, $message: String!) {
+          dismissPullRequestReview(input: {
+            pullRequestReviewId: $pullRequestReviewId
+            message: $message
+          }) {
+            pullRequestReview {
+              id
+              state
+            }
+          }
+        }
+      `;
+            await octokit.graphql(mutation, {
+                pullRequestReviewId: review.node_id,
+                message,
+            });
+            dismissedCount++;
+            if (verbose) {
+                logInfo(`✅ Dismissed review ${review.id} by @${review.user.login}`);
+            }
+        }
+        catch (error) {
+            if (verbose) {
+                logError(`Failed to dismiss review ${review.id} by @${review.user.login}: ${error}`);
+            }
+        }
+    }
+    return dismissedCount;
+}

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

@@ -7,7 +7,7 @@ import { Octokit } from '@octokit/rest';
 import { logInfo, logError } from '../../utils/logger.js';
 import { parsePullRequestUrl, fetchPRReviews } from '../code-refine/context.js';
 import { getFeature } from '../../api/features/get-feature.js';
-import { fetchPRFileChanges, fetchUnresolvedReviewThreads, resolveReviewThreads, } from './github.js';
+import { fetchPRFileChanges, fetchUnresolvedReviewThreads, resolveReviewThreads, dismissReviews, } from './github.js';
 import { analyzeAllThreads } from './llm-analyzer.js';
 // Re-export types for backward compatibility
 export * from './types.js';
@@ -65,31 +65,52 @@ export async function verifyAndResolveComments(options) {
         const addressedThreads = threadAnalysisResults.filter((result) => result.analysis.isAddressed);
         const trulyUnresolvedThreads = threadAnalysisResults.filter((result) => !result.analysis.isAddressed);
         // Auto-resolve threads that LLM determined are addressed
+        let totalResolvedComments = 0;
         if (addressedThreads.length > 0) {
             if (verbose) {
                 logInfo(`✅ Auto-resolving ${addressedThreads.length} threads that have been addressed...`);
             }
             const resolvedCount = await resolveReviewThreads(octokit, addressedThreads.map((r) => r.thread), verbose);
+            totalResolvedComments = resolvedCount;
             if (verbose) {
                 logInfo(`✅ Successfully resolved ${resolvedCount} threads`);
             }
         }
-        // Check reviews - they need to be dismissed or re-reviewed
-        const unresolvedReviews = reviews.filter((review) => review.state === 'CHANGES_REQUESTED');
+        // Check reviews - they need to be dismissed if all comments are addressed
+        const changesRequestedReviews = reviews.filter((review) => review.state === 'CHANGES_REQUESTED');
         if (verbose) {
             logInfo(`📊 Review Threads: ${trulyUnresolvedThreads.length} still unresolved (after LLM analysis)`);
             if (reviews.length > 0) {
-                logInfo(`📊 Reviews: ${reviews.length - unresolvedReviews.length} addressed, ${unresolvedReviews.length} still requesting changes`);
+                logInfo(`📊 Reviews: ${changesRequestedReviews.length} requesting changes`);
             }
         }
-        // If all threads are truly resolved (after LLM analysis) AND no reviews requesting changes, success
-        if (trulyUnresolvedThreads.length === 0 && unresolvedReviews.length === 0) {
+        // If all threads are truly resolved, dismiss the "CHANGES_REQUESTED" reviews
+        let dismissedReviewsCount = 0;
+        if (trulyUnresolvedThreads.length === 0 &&
+            changesRequestedReviews.length > 0) {
+            if (verbose) {
+                logInfo(`🔄 All comments addressed. Dismissing ${changesRequestedReviews.length} review(s) requesting changes...`);
+            }
+            dismissedReviewsCount = await dismissReviews(octokit, changesRequestedReviews, totalResolvedComments, verbose);
+            if (verbose) {
+                logInfo(`✅ Successfully dismissed ${dismissedReviewsCount} review(s)`);
+            }
+        }
+        // If all threads are truly resolved (after LLM analysis) AND reviews are dismissed, success
+        const allReviewsDismissed = changesRequestedReviews.length === 0 ||
+            dismissedReviewsCount === changesRequestedReviews.length;
+        if (trulyUnresolvedThreads.length === 0 && allReviewsDismissed) {
             if (verbose) {
                 logInfo('✅ All comments have been addressed! All review threads are resolved.');
             }
-            const successMessage = reviews.length > 0
-                ? 'All reviews and review comments have been addressed and resolved'
-                : 'All review comments have been addressed and resolved';
+            let successMessage = 'All review comments have been addressed and resolved';
+            if (dismissedReviewsCount > 0) {
+                successMessage = `All reviews and review comments have been addressed. ${dismissedReviewsCount} review(s) dismissed.`;
+            }
+            else if (reviews.length > 0) {
+                successMessage =
+                    'All reviews and review comments have been addressed and resolved';
+            }
             return {
                 status: 'success',
                 message: successMessage,
@@ -101,15 +122,18 @@ export async function verifyAndResolveComments(options) {
                     resolvedComments: addressedThreads.length,
                     unresolvedComments: 0,
                     commentsMarkedResolved: addressedThreads.length,
+                    dismissedReviews: dismissedReviewsCount,
                 },
             };
         }
         else {
             // Verification failed - build detailed info with specific failure reasons from LLM analysis
+            // Calculate remaining reviews that weren't dismissed
+            const remainingReviewsCount = changesRequestedReviews.length - dismissedReviewsCount;
             if (verbose) {
-                if (unresolvedReviews.length > 0) {
-                    logInfo(`⚠️  ${unresolvedReviews.length} reviews still requesting changes`);
-                    unresolvedReviews.forEach((review) => {
+                if (remainingReviewsCount > 0) {
+                    logInfo(`⚠️  ${remainingReviewsCount} reviews still requesting changes (failed to dismiss)`);
+                    changesRequestedReviews.forEach((review) => {
                         logInfo(`  - Review ${review.id} by @${review.user.login}`);
                         if (review.body) {
                             logInfo(`    ${review.body.substring(0, 100)}...`);
@@ -138,10 +162,10 @@ export async function verifyAndResolveComments(options) {
                     suggestions.push(`${index + 1}. [${firstComment.path}:${firstComment.line || '?'}] by @${firstComment.author.login}: ${result.analysis.reason}`);
                 }
             });
-            // Add review-specific suggestions if any
-            if (unresolvedReviews.length > 0) {
-                suggestions.push(`\n${unresolvedReviews.length} review(s) requesting changes need to be addressed:`);
-                unresolvedReviews.forEach((review) => {
+            // Add review-specific suggestions if any reviews failed to dismiss
+            if (remainingReviewsCount > 0) {
+                suggestions.push(`\n${remainingReviewsCount} review(s) requesting changes could not be automatically dismissed:`);
+                changesRequestedReviews.forEach((review) => {
                     suggestions.push(`  - @${review.user.login}: ${review.body ? review.body.substring(0, 150) : 'No details provided'}${review.body && review.body.length > 150 ? '...' : ''}`);
                 });
             }
@@ -158,7 +182,7 @@ export async function verifyAndResolveComments(options) {
                     url: firstComment.url,
                 };
             });
-            const unresolvedReviewDetails = unresolvedReviews.map((review) => ({
+            const unresolvedReviewDetails = changesRequestedReviews.map((review) => ({
                 reviewId: review.id,
                 author: review.user.login,
                 state: review.state,
@@ -166,11 +190,11 @@ export async function verifyAndResolveComments(options) {
                 submittedAt: review.submitted_at,
             }));
             let errorMessage = '';
-            if (unresolvedReviews.length > 0 && trulyUnresolvedThreads.length > 0) {
-                errorMessage = `${unresolvedReviews.length} reviews and ${trulyUnresolvedThreads.length} review threads still need to be addressed (based on LLM analysis)`;
+            if (remainingReviewsCount > 0 && trulyUnresolvedThreads.length > 0) {
+                errorMessage = `${remainingReviewsCount} reviews and ${trulyUnresolvedThreads.length} review threads still need to be addressed (based on LLM analysis)`;
             }
-            else if (unresolvedReviews.length > 0) {
-                errorMessage = `${unresolvedReviews.length} reviews still requesting changes`;
+            else if (remainingReviewsCount > 0) {
+                errorMessage = `${remainingReviewsCount} reviews could not be dismissed`;
             }
             else {
                 errorMessage = `${trulyUnresolvedThreads.length} review comments still need to be addressed (based on LLM analysis)`;
@@ -181,11 +205,12 @@ export async function verifyAndResolveComments(options) {
                 data: {
                     featureId,
                     totalReviews: reviews.length,
-                    unresolvedReviews: unresolvedReviews.length,
+                    unresolvedReviews: remainingReviewsCount,
                     totalComments: unresolvedThreads.length, // Original count before LLM analysis
                     resolvedComments: addressedThreads.length, // LLM determined these are addressed
                     unresolvedComments: trulyUnresolvedThreads.length, // LLM determined these still need work
                     commentsMarkedResolved: addressedThreads.length,
+                    dismissedReviews: dismissedReviewsCount,
                     suggestions,
                     unresolvedReviewDetails,
                     unresolvedCommentDetails,

package/dist/phases/code-refine-verification/types.d.ts

@@ -43,6 +43,7 @@ export interface CodeRefineVerificationData {
     resolvedComments: number;
     unresolvedComments: number;
     commentsMarkedResolved?: number;
+    dismissedReviews?: number;
     suggestions?: string[];
     unresolvedReviewDetails?: Array<{
         reviewId: number;

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.1",
+  "version": "0.13.3",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"
@@ -53,4 +53,4 @@
       "optional": false
     }
   }
-}
+}