edsger 0.13.1 → 0.13.2

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-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/package.json

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