edsger 0.13.0 → 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/dist/utils/git-branch-manager.d.ts

@@ -22,6 +22,10 @@ export declare function resetUncommittedChanges(verbose?: boolean): void;
  * Check if a Git branch exists locally
  */
 export declare function branchExists(branch: string): boolean;
+/**
+ * Check if a remote branch exists
+ */
+export declare function remoteBranchExists(branch: string): boolean;
 /**
  * Switch to a specific Git branch, creating it if it doesn't exist
  */

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

@@ -76,6 +76,23 @@ export function branchExists(branch) {
         return false;
     }
 }
+/**
+ * Check if a remote branch exists
+ */
+export function remoteBranchExists(branch) {
+    try {
+        // Fetch remote refs first to ensure we have latest info
+        execSync('git fetch origin --prune', { encoding: 'utf-8', stdio: 'pipe' });
+        execSync(`git rev-parse --verify origin/${branch}`, {
+            encoding: 'utf-8',
+            stdio: 'pipe',
+        });
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
 /**
  * Switch to a specific Git branch, creating it if it doesn't exist
  */
@@ -179,6 +196,50 @@ export function switchToFeatureBranchAndRebase(featureBranch, baseBranch = 'main
     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
+    try {
+        // Check for uncommitted changes and reset if found before any git operations
+        if (hasUncommittedChanges()) {
+            if (verbose) {
+                logInfo(`⚠️  Found uncommitted changes. Resetting to clean state before sync...`);
+            }
+            resetUncommittedChanges(verbose);
+        }
+        // Fetch to get latest remote state
+        execSync('git fetch origin', { encoding: 'utf-8', stdio: 'pipe' });
+        // Check if remote feature branch exists
+        try {
+            execSync(`git rev-parse --verify origin/${featureBranch}`, {
+                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}`, {
+                encoding: 'utf-8',
+                stdio: 'pipe',
+            });
+            if (verbose) {
+                logInfo(`✅ Synced local branch with origin/${featureBranch}`);
+            }
+        }
+        catch (e) {
+            // Remote branch doesn't exist, that's fine - we'll push later
+            if (verbose) {
+                logInfo(`   Remote branch origin/${featureBranch} doesn't exist yet, will create on push`);
+            }
+        }
+    }
+    catch (error) {
+        if (verbose) {
+            logInfo(`⚠️  Could not sync with remote feature branch, continuing with local branch`);
+        }
+    }
     // Rebase feature branch with latest main
     if (verbose) {
         logInfo(`📥 Rebasing ${featureBranch} with origin/${baseBranch}...`);

package/package.json

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

package/.claude/settings.local.json

@@ -1,28 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Read(//Users/steven/development/edsger/**)",
-      "Bash(npm run build)",
-      "Bash(node:*)",
-      "Bash(git add:*)",
-      "Bash(git commit:*)",
-      "Bash(ls:*)",
-      "Bash(cat:*)",
-      "Bash(npm run typecheck:*)",
-      "Bash(git diff:*)",
-      "WebSearch",
-      "WebFetch(domain:supabase.com)",
-      "Bash(npm install:*)",
-      "Bash(grep:*)",
-      "Bash(npx supabase gen types typescript --help:*)",
-      "Bash(git -C /Users/steven/development/edsger status)",
-      "Bash(git -C /Users/steven/development/edsger diff)",
-      "Bash(git -C /Users/steven/development/edsger log --oneline -5)",
-      "Bash(git -C /Users/steven/development/edsger add supabase/migrations/20251231000000_drop_unused_views.sql)",
-      "Bash(git -C /Users/steven/development/edsger commit -m \"$\\(cat <<''EOF''\nchore: drop unused database views\n\nRemove test_report_summary and user_stories_with_context views that are defined but never used in the application.\n\n🤖 Generated with [Claude Code]\\(https://claude.com/claude-code\\)\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")",
-      "Bash(git -C /Users/steven/development/edsger commit -m \"$\\(cat <<''EOF''\nchore: drop unused database views\n\nRemove test_report_summary and user_stories_with_context views\nthat are defined but never used in the application.\n\n🤖 Generated with [Claude Code]\\(https://claude.com/claude-code\\)\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}

package/dist/api/features/__tests__/regression-prevention.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Specialized tests for status regression prevention
- * Focuses on the core business requirement: preventing backward status movement
- */
-export {};