edsger 0.4.7 → 0.4.8

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

@@ -3,11 +3,13 @@
  * Verifies that all PR review comments have been addressed and resolves them
  * Uses GitHub GraphQL API to accurately detect unresolved review threads
  */
+import { EdsgerConfig } from '../../types/index.js';
 export interface CodeRefineVerificationOptions {
     featureId: string;
     mcpServerUrl: string;
     mcpToken: string;
     githubToken: string;
+    config: EdsgerConfig;
     verbose?: boolean;
 }
 export interface CodeRefineVerificationData {
@@ -42,7 +44,7 @@ export interface CodeRefineVerificationResult {
     data: CodeRefineVerificationData;
 }
 /**
- * Verify and resolve PR review comments using GraphQL API
+ * Verify and resolve PR review comments using GraphQL API and LLM analysis
  */
 export declare function verifyAndResolveComments(options: CodeRefineVerificationOptions): Promise<CodeRefineVerificationResult>;
 export declare function checkCodeRefineVerificationRequirements(): Promise<boolean>;

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

@@ -4,9 +4,42 @@
  * Uses GitHub GraphQL API to accurately detect unresolved review threads
  */
 import { Octokit } from '@octokit/rest';
+import { query } from '@anthropic-ai/claude-code';
 import { logInfo, logError } from '../../utils/logger.js';
 import { parsePullRequestUrl, fetchPRReviews, } from '../code-refine/context-fetcher.js';
 import { getFeature } from '../../api/features/get-feature.js';
+/**
+ * Fetch PR file changes (diff information)
+ */
+async function fetchPRFileChanges(octokit, owner, repo, prNumber, verbose) {
+    try {
+        if (verbose) {
+            logInfo('📂 Fetching PR file changes...');
+        }
+        const { data: files } = await octokit.pulls.listFiles({
+            owner,
+            repo,
+            pull_number: prNumber,
+            per_page: 100,
+        });
+        const fileChanges = files.map((file) => ({
+            filename: file.filename,
+            status: file.status,
+            additions: file.additions,
+            deletions: file.deletions,
+            changes: file.changes,
+            patch: file.patch,
+        }));
+        if (verbose) {
+            logInfo(`✅ Found ${fileChanges.length} changed files`);
+        }
+        return fileChanges;
+    }
+    catch (error) {
+        logError(`Failed to fetch PR file changes: ${error}`);
+        return [];
+    }
+}
 /**
  * Fetch unresolved review threads using GitHub GraphQL API
  * This provides accurate resolution status unlike REST API
@@ -78,22 +111,152 @@ async function fetchUnresolvedReviewThreads(octokit, owner, repo, prNumber, verb
     }
 }
 /**
- * Analyze why a comment thread is unresolved and provide specific reason
- * Note: Outdated threads are auto-resolved, so this only analyzes truly unresolved threads
+ * Analyze whether a review thread has been addressed by examining code changes
+ * Uses LLM to intelligently determine if the feedback was addressed
  */
-function analyzeUnresolvedThread(thread) {
+async function analyzeThreadWithLLM(thread, fileChange, config, verbose) {
     const firstComment = thread.comments.nodes[0];
     if (!firstComment) {
-        return 'Comment thread exists but has no comments';
+        return {
+            isAddressed: false,
+            reason: 'Comment thread exists but has no comments',
+        };
     }
-    const reasons = [];
-    // Since outdated threads are filtered out, remaining threads need code changes
-    reasons.push('Code at this location has not been modified to address the feedback');
-    // Check if there are multiple comments (discussion ongoing)
-    if (thread.comments.totalCount > 1) {
-        reasons.push(`Discussion ongoing (${thread.comments.totalCount} comments in thread)`);
+    // If file was not changed at all, feedback definitely not addressed
+    if (!fileChange || !fileChange.patch) {
+        return {
+            isAddressed: false,
+            reason: `File ${firstComment.path} has not been modified in this PR`,
+        };
+    }
+    // If file was deleted, thread should be resolved as obsolete
+    if (fileChange.status === 'removed') {
+        return {
+            isAddressed: true,
+            reason: 'File has been removed',
+        };
+    }
+    try {
+        if (verbose) {
+            logInfo(`🤖 Using LLM to analyze if comment in ${firstComment.path}:${firstComment.line} has been addressed...`);
+        }
+        const analysisPrompt = createThreadAnalysisPrompt(thread, fileChange, firstComment);
+        let lastResponse = '';
+        let analysisResult = null;
+        function* userMessage() {
+            yield {
+                type: 'user',
+                message: { role: 'user', content: analysisPrompt },
+            };
+        }
+        for await (const message of query({
+            prompt: userMessage(),
+            options: {
+                model: config.claude.model || 'sonnet',
+                maxTurns: 10,
+                permissionMode: 'bypassPermissions',
+            },
+        })) {
+            if (message.type === 'assistant' && message.message?.content) {
+                for (const content of message.message.content) {
+                    if (content.type === 'text') {
+                        lastResponse += content.text + '\n';
+                    }
+                }
+            }
+            if (message.type === 'result') {
+                if (message.subtype === 'success') {
+                    const responseText = message.result || lastResponse;
+                    // Try to extract JSON from response
+                    const jsonMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+                    if (jsonMatch) {
+                        analysisResult = JSON.parse(jsonMatch[1]);
+                    }
+                    else {
+                        // Try to parse directly
+                        try {
+                            analysisResult = JSON.parse(responseText);
+                        }
+                        catch {
+                            // Fallback: look for isAddressed boolean in text
+                            const isAddressedMatch = /isAddressed["']?\s*:\s*(true|false)/i.exec(responseText);
+                            if (isAddressedMatch) {
+                                analysisResult = {
+                                    isAddressed: isAddressedMatch[1].toLowerCase() === 'true',
+                                    reason: responseText.split('\n').find((line) => line.trim()) ||
+                                        'Analysis completed',
+                                };
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (analysisResult) {
+            if (verbose) {
+                logInfo(`   ${analysisResult.isAddressed ? '✅' : '❌'} ${analysisResult.reason}`);
+            }
+            return analysisResult;
+        }
+        // Fallback if LLM analysis failed
+        return {
+            isAddressed: false,
+            reason: 'Unable to analyze - please review manually',
+        };
+    }
+    catch (error) {
+        if (verbose) {
+            logError(`LLM analysis failed: ${error}`);
+        }
+        return {
+            isAddressed: false,
+            reason: 'Analysis failed - please review manually',
+        };
     }
-    return reasons.join('; ');
+}
+/**
+ * Create prompt for LLM to analyze if a comment thread has been addressed
+ */
+function createThreadAnalysisPrompt(thread, fileChange, firstComment) {
+    const allComments = thread.comments.nodes
+        .map((c, idx) => `Comment ${idx + 1} by @${c.author.login}:\n${c.body}`)
+        .join('\n\n');
+    return `You are analyzing whether a code review comment has been addressed by subsequent code changes.
+
+**Review Thread Information:**
+- File: ${firstComment.path}
+- Line: ${firstComment.line || 'N/A'}
+- Thread has ${thread.comments.totalCount} comment(s)
+
+**Review Comments:**
+${allComments}
+
+**Code Changes in This File:**
+\`\`\`diff
+${fileChange.patch || '(No patch available)'}
+\`\`\`
+
+**Your Task:**
+Analyze whether the code changes adequately address the feedback in the review comments. Consider:
+1. Does the feedback request a specific code change?
+2. Have those changes (or equivalent changes) been made?
+3. If the feedback points to a specific line, have related areas of code been modified to address the concern?
+
+**Important:** The comment may point to a specific line, but the fix might be in nearby code. Focus on whether the **underlying issue** was addressed, not just whether that exact line was modified.
+
+Return your analysis in this JSON format:
+\`\`\`json
+{
+  "isAddressed": true or false,
+  "reason": "Brief explanation of why you determined the feedback was or was not addressed"
+}
+\`\`\`
+
+Example responses:
+- If a comment says "add null check" and the diff shows a null check was added nearby: {"isAddressed": true, "reason": "Null check added in related code"}
+- If a comment suggests a refactor but no relevant changes are visible: {"isAddressed": false, "reason": "No refactoring changes visible in diff"}
+- If code was modified in related areas addressing the concern: {"isAddressed": true, "reason": "Related code modified to address the concern"}
+`;
 }
 /**
  * Mark review threads as resolved using GraphQL API
@@ -132,10 +295,10 @@ async function resolveReviewThreads(octokit, threads, verbose) {
     return markedCount;
 }
 /**
- * Verify and resolve PR review comments using GraphQL API
+ * Verify and resolve PR review comments using GraphQL API and LLM analysis
  */
 export async function verifyAndResolveComments(options) {
-    const { featureId, mcpServerUrl, mcpToken, githubToken, verbose } = options;
+    const { featureId, mcpServerUrl, mcpToken, githubToken, config, verbose } = options;
     if (verbose) {
         logInfo(`Starting code refine verification for feature ID: ${featureId}`);
     }
@@ -155,10 +318,11 @@ export async function verifyAndResolveComments(options) {
         const octokit = new Octokit({
             auth: githubToken,
         });
-        // Fetch unresolved review threads using GraphQL API
-        const [unresolvedThreads, reviews] = await Promise.all([
+        // Fetch unresolved review threads, reviews, and file changes
+        const [unresolvedThreads, reviews, fileChanges] = await Promise.all([
             fetchUnresolvedReviewThreads(octokit, owner, repo, prNumber, verbose),
             fetchPRReviews(octokit, owner, repo, prNumber, verbose),
+            fetchPRFileChanges(octokit, owner, repo, prNumber, verbose),
         ]);
         // Check if there's anything to verify
         if (reviews.length === 0 && unresolvedThreads.length === 0) {
@@ -178,16 +342,46 @@ export async function verifyAndResolveComments(options) {
                 },
             };
         }
+        // Use LLM to intelligently analyze unresolved threads
+        if (verbose && unresolvedThreads.length > 0) {
+            logInfo(`🔍 Analyzing ${unresolvedThreads.length} unresolved threads with LLM...`);
+        }
+        // Analyze each thread with LLM to determine if it's truly unresolved
+        const threadAnalysisResults = await Promise.all(unresolvedThreads.map(async (thread) => {
+            const firstComment = thread.comments.nodes[0];
+            const fileChange = fileChanges.find((fc) => fc.filename === firstComment?.path);
+            const analysis = await analyzeThreadWithLLM(thread, fileChange, config, verbose);
+            return {
+                thread,
+                analysis,
+            };
+        }));
+        // Separate threads that LLM determined are addressed vs not addressed
+        const addressedThreads = threadAnalysisResults.filter((result) => result.analysis.isAddressed);
+        const trulyUnresolvedThreads = threadAnalysisResults.filter((result) => !result.analysis.isAddressed);
+        if (verbose) {
+            logInfo(`📊 LLM Analysis: ${addressedThreads.length} threads addressed, ${trulyUnresolvedThreads.length} still need attention`);
+        }
+        // Auto-resolve threads that LLM determined are addressed
+        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);
+            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');
         if (verbose) {
-            logInfo(`📊 Review Threads: ${unresolvedThreads.length} unresolved`);
+            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`);
             }
         }
-        // If all threads are resolved AND no reviews requesting changes, success
-        if (unresolvedThreads.length === 0 && unresolvedReviews.length === 0) {
+        // If all threads are truly resolved (after LLM analysis) AND no reviews requesting changes, success
+        if (trulyUnresolvedThreads.length === 0 && unresolvedReviews.length === 0) {
             if (verbose) {
                 logInfo('✅ All comments have been addressed! All review threads are resolved.');
             }
@@ -202,13 +396,14 @@ export async function verifyAndResolveComments(options) {
                     totalReviews: reviews.length,
                     unresolvedReviews: 0,
                     totalComments: unresolvedThreads.length,
-                    resolvedComments: 0,
+                    resolvedComments: addressedThreads.length,
                     unresolvedComments: 0,
+                    commentsMarkedResolved: addressedThreads.length,
                 },
             };
         }
         else {
-            // Verification failed - build detailed info with specific failure reasons
+            // Verification failed - build detailed info with specific failure reasons from LLM analysis
             if (verbose) {
                 if (unresolvedReviews.length > 0) {
                     logInfo(`⚠️  ${unresolvedReviews.length} reviews still requesting changes`);
@@ -219,27 +414,26 @@ export async function verifyAndResolveComments(options) {
                         }
                     });
                 }
-                if (unresolvedThreads.length > 0) {
-                    logInfo(`⚠️  ${unresolvedThreads.length} review threads still need to be addressed`);
-                    unresolvedThreads.forEach((thread) => {
-                        const firstComment = thread.comments.nodes[0];
+                if (trulyUnresolvedThreads.length > 0) {
+                    logInfo(`⚠️  ${trulyUnresolvedThreads.length} review threads still need to be addressed`);
+                    trulyUnresolvedThreads.forEach((result) => {
+                        const firstComment = result.thread.comments.nodes[0];
                         if (firstComment) {
                             logInfo(`  - Comment by @${firstComment.author.login}`);
                             logInfo(`    File: ${firstComment.path}:${firstComment.line || '?'}`);
                             logInfo(`    ${firstComment.body.substring(0, 100)}...`);
-                            logInfo(`    Reason: ${analyzeUnresolvedThread(thread)}`);
+                            logInfo(`    LLM Analysis: ${result.analysis.reason}`);
                         }
                     });
                 }
             }
-            // Build targeted suggestions based on specific unresolved issues
+            // Build targeted suggestions based on LLM analysis
             const suggestions = [];
-            // Create specific suggestions for each unresolved comment
-            unresolvedThreads.forEach((thread, index) => {
-                const firstComment = thread.comments.nodes[0];
+            // Create specific suggestions for each truly unresolved comment (based on LLM analysis)
+            trulyUnresolvedThreads.forEach((result, index) => {
+                const firstComment = result.thread.comments.nodes[0];
                 if (firstComment) {
-                    const reason = analyzeUnresolvedThread(thread);
-                    suggestions.push(`${index + 1}. [${firstComment.path}:${firstComment.line || '?'}] by @${firstComment.author.login}: ${reason}`);
+                    suggestions.push(`${index + 1}. [${firstComment.path}:${firstComment.line || '?'}] by @${firstComment.author.login}: ${result.analysis.reason}`);
                 }
             });
             // Add review-specific suggestions if any
@@ -249,16 +443,16 @@ export async function verifyAndResolveComments(options) {
                     suggestions.push(`  - @${review.user.login}: ${review.body ? review.body.substring(0, 150) : 'No details provided'}${review.body && review.body.length > 150 ? '...' : ''}`);
                 });
             }
-            // Build detailed unresolved info with failure reasons
-            const unresolvedCommentDetails = unresolvedThreads.map((thread) => {
-                const firstComment = thread.comments.nodes[0];
+            // Build detailed unresolved info with LLM-analyzed failure reasons
+            const unresolvedCommentDetails = trulyUnresolvedThreads.map((result) => {
+                const firstComment = result.thread.comments.nodes[0];
                 return {
                     commentId: firstComment.id,
                     author: firstComment.author.login,
                     file: firstComment.path,
                     line: firstComment.line,
                     body: firstComment.body,
-                    failureReason: analyzeUnresolvedThread(thread),
+                    failureReason: result.analysis.reason, // Use LLM analysis result
                     url: firstComment.url,
                 };
             });
@@ -270,14 +464,14 @@ export async function verifyAndResolveComments(options) {
                 submittedAt: review.submitted_at,
             }));
             let errorMessage = '';
-            if (unresolvedReviews.length > 0 && unresolvedThreads.length > 0) {
-                errorMessage = `${unresolvedReviews.length} reviews and ${unresolvedThreads.length} review threads still need to be addressed`;
+            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)`;
             }
             else if (unresolvedReviews.length > 0) {
                 errorMessage = `${unresolvedReviews.length} reviews still requesting changes`;
             }
             else {
-                errorMessage = `${unresolvedThreads.length} review comments still need to be addressed`;
+                errorMessage = `${trulyUnresolvedThreads.length} review comments still need to be addressed (based on LLM analysis)`;
             }
             return {
                 status: 'error',
@@ -286,9 +480,10 @@ export async function verifyAndResolveComments(options) {
                     featureId,
                     totalReviews: reviews.length,
                     unresolvedReviews: unresolvedReviews.length,
-                    totalComments: unresolvedThreads.length,
-                    resolvedComments: 0,
-                    unresolvedComments: unresolvedThreads.length,
+                    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,
                     suggestions,
                     unresolvedReviewDetails,
                     unresolvedCommentDetails,

package/dist/workflow-runner/config/phase-configs.js

@@ -42,6 +42,7 @@ const executeCodeRefineVerification = async (options, config) => {
         mcpServerUrl: options.mcpServerUrl,
         mcpToken: options.mcpToken,
         githubToken,
+        config, // Add config parameter for LLM analysis
         verbose: options.verbose,
     });
 };

package/package.json

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