edsger 0.41.0 → 0.41.2

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

@@ -0,0 +1,597 @@
+/**
+ * Code Refine Verification
+ * Verifies that all PR review comments have been addressed and resolves them
+ * 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.js';
+import { getFeature } from '../../api/features/get-feature.js';
+/**
+ * Fetch complete file content from a specific ref (branch/commit)
+ */
+async function fetchFileContent(octokit, owner, repo, ref, path, verbose) {
+    try {
+        const { data } = await octokit.repos.getContent({
+            owner,
+            repo,
+            ref,
+            path,
+        });
+        // Handle file content (not directory)
+        if ('content' in data && !Array.isArray(data)) {
+            // Content is base64 encoded
+            return Buffer.from(data.content, 'base64').toString('utf-8');
+        }
+        return undefined;
+    }
+    catch (error) {
+        if (verbose) {
+            logError(`Failed to fetch content for ${path} at ref ${ref}: ${error}`);
+        }
+        return undefined;
+    }
+}
+/**
+ * Fetch PR file changes (diff information and full content)
+ */
+async function fetchPRFileChanges(octokit, owner, repo, prNumber, verbose) {
+    try {
+        if (verbose) {
+            logInfo('📂 Fetching PR file changes and content...');
+        }
+        // Get PR details to get the head ref
+        const { data: pr } = await octokit.pulls.get({
+            owner,
+            repo,
+            pull_number: prNumber,
+        });
+        const headRef = pr.head.sha;
+        // Get list of changed files
+        const { data: files } = await octokit.pulls.listFiles({
+            owner,
+            repo,
+            pull_number: prNumber,
+            per_page: 100,
+        });
+        if (verbose) {
+            logInfo(`✅ Found ${files.length} changed files`);
+            logInfo(`📥 Fetching full content for changed files from ${headRef.substring(0, 7)}...`);
+        }
+        // Fetch full content for each file in parallel
+        const fileChanges = await Promise.all(files.map(async (file) => {
+            let fullContent;
+            // Only fetch content for files that were not deleted
+            if (file.status !== 'removed') {
+                fullContent = await fetchFileContent(octokit, owner, repo, headRef, file.filename, verbose);
+            }
+            return {
+                filename: file.filename,
+                status: file.status,
+                additions: file.additions,
+                deletions: file.deletions,
+                changes: file.changes,
+                patch: file.patch,
+                fullContent,
+            };
+        }));
+        if (verbose) {
+            const filesWithContent = fileChanges.filter((f) => f.fullContent).length;
+            logInfo(`✅ Retrieved full content for ${filesWithContent}/${fileChanges.length} 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
+ */
+async function fetchUnresolvedReviewThreads(octokit, owner, repo, prNumber, verbose) {
+    try {
+        if (verbose) {
+            logInfo('🔍 Fetching review threads via GraphQL API...');
+        }
+        const query = `
+      query($owner: String!, $repo: String!, $prNumber: Int!) {
+        repository(owner: $owner, name: $repo) {
+          pullRequest(number: $prNumber) {
+            reviewThreads(first: 100) {
+              nodes {
+                id
+                isResolved
+                isOutdated
+                comments(first: 100) {
+                  totalCount
+                  nodes {
+                    id
+                    author {
+                      login
+                    }
+                    body
+                    path
+                    line
+                    url
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    `;
+        const result = await octokit.graphql(query, {
+            owner,
+            repo,
+            prNumber,
+        });
+        const allThreads = result?.repository?.pullRequest?.reviewThreads?.nodes || [];
+        // Filter for truly unresolved threads
+        // - Exclude resolved threads (isResolved = true)
+        // - Exclude outdated threads (isOutdated = true) - these mean code has changed, should auto-resolve
+        const unresolvedThreads = allThreads.filter((thread) => !thread.isResolved && !thread.isOutdated);
+        // Separate outdated threads that should be auto-resolved
+        const outdatedThreads = allThreads.filter((thread) => !thread.isResolved && thread.isOutdated);
+        if (verbose) {
+            logInfo(`📊 Found ${unresolvedThreads.length} unresolved review threads (out of ${allThreads.length} total)`);
+            if (outdatedThreads.length > 0) {
+                logInfo(`📊 Found ${outdatedThreads.length} outdated threads (code changed, will auto-resolve)`);
+            }
+        }
+        // Auto-resolve outdated threads
+        if (outdatedThreads.length > 0) {
+            const markedCount = await resolveReviewThreads(octokit, outdatedThreads, verbose);
+            if (verbose) {
+                logInfo(`✅ Auto-resolved ${markedCount} outdated threads`);
+            }
+        }
+        return unresolvedThreads;
+    }
+    catch (error) {
+        logError(`Failed to fetch review threads via GraphQL: ${error}`);
+        // Fallback to empty array if GraphQL fails
+        return [];
+    }
+}
+/**
+ * Analyze whether a review thread has been addressed by examining code changes
+ * Uses LLM to intelligently determine if the feedback was addressed
+ */
+async function analyzeThreadWithLLM(thread, fileChange, config, verbose) {
+    const firstComment = thread.comments.nodes[0];
+    if (!firstComment) {
+        return {
+            isAddressed: false,
+            reason: 'Comment thread exists but has no comments',
+        };
+    }
+    // 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',
+        };
+    }
+}
+/**
+ * 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');
+    // Build the code context section
+    let codeContext = '';
+    // Include diff (what changed)
+    if (fileChange.patch) {
+        codeContext += `**Code Changes (Diff):**
+\`\`\`diff
+${fileChange.patch}
+\`\`\`
+
+`;
+    }
+    // Include full file content for better context
+    if (fileChange.fullContent) {
+        // Truncate very large files to avoid context limits
+        const maxLength = 10000;
+        const content = fileChange.fullContent.length > maxLength
+            ? fileChange.fullContent.substring(0, maxLength) +
+                '\n\n... (file truncated, showing first 10000 characters)'
+            : fileChange.fullContent;
+        codeContext += `**Complete File Content (After Changes):**
+\`\`\`
+${content}
+\`\`\`
+
+`;
+    }
+    if (!codeContext) {
+        codeContext = '(No code information available)\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}
+
+${codeContext}
+
+**Your Task:**
+Analyze whether the code changes adequately address the feedback in the review comments. You have access to:
+1. **The diff** showing what was changed
+2. **The complete file content** after changes for full context
+
+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, use the full file content to understand the broader context
+4. Check if related areas of code were modified to address the concern
+5. Use the complete file to verify the fix is properly integrated
+
+**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
+- Use the full file content to understand the complete context and verify the implementation
+
+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 code shows a null check was added: {"isAddressed": true, "reason": "Null check added in the updated code"}
+- If a comment suggests a refactor but no relevant changes are visible: {"isAddressed": false, "reason": "No refactoring changes visible in diff or file content"}
+- If code was modified in related areas addressing the concern: {"isAddressed": true, "reason": "Related code modified to address the concern"}
+- If the full context shows the issue is resolved differently: {"isAddressed": true, "reason": "Issue resolved through alternative implementation visible in full file"}
+`;
+}
+/**
+ * Mark review threads as resolved using GraphQL API
+ */
+async function resolveReviewThreads(octokit, threads, verbose) {
+    let markedCount = 0;
+    for (const thread of threads) {
+        try {
+            if (verbose) {
+                logInfo(`✅ Marking thread ${thread.id} as resolved...`);
+            }
+            const mutation = `
+        mutation($threadId: ID!) {
+          resolveReviewThread(input: {threadId: $threadId}) {
+            thread {
+              id
+              isResolved
+            }
+          }
+        }
+      `;
+            await octokit.graphql(mutation, {
+                threadId: thread.id,
+            });
+            markedCount++;
+            if (verbose) {
+                logInfo(`✅ Thread ${thread.id} marked as resolved`);
+            }
+        }
+        catch (error) {
+            if (verbose) {
+                logError(`Failed to resolve thread ${thread.id}: ${error}`);
+            }
+        }
+    }
+    return markedCount;
+}
+/**
+ * Verify and resolve PR review comments using GraphQL API and LLM analysis
+ */
+export async function verifyAndResolveComments(options) {
+    const { featureId, githubToken, config, verbose } = options;
+    if (verbose) {
+        logInfo(`Starting code refine verification for feature ID: ${featureId}`);
+    }
+    try {
+        // Fetch feature info using shared API
+        const feature = await getFeature(featureId, verbose);
+        if (!feature.pull_request_url) {
+            throw new Error(`Feature ${featureId} does not have a pull request URL. Cannot perform verification.`);
+        }
+        // Parse PR URL
+        const prInfo = parsePullRequestUrl(feature.pull_request_url);
+        if (!prInfo) {
+            throw new Error(`Invalid pull request URL: ${feature.pull_request_url}. Expected format: https://github.com/owner/repo/pull/123`);
+        }
+        const { owner, repo, prNumber } = prInfo;
+        // Initialize Octokit with GitHub token (supports both REST and GraphQL)
+        const octokit = new Octokit({
+            auth: githubToken,
+        });
+        // 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) {
+            if (verbose) {
+                logInfo('✅ No reviews or unresolved review threads found. Verification complete.');
+            }
+            return {
+                status: 'success',
+                message: 'No reviews or review comments to verify',
+                data: {
+                    featureId,
+                    totalReviews: 0,
+                    unresolvedReviews: 0,
+                    totalComments: 0,
+                    resolvedComments: 0,
+                    unresolvedComments: 0,
+                },
+            };
+        }
+        // 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: ${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 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.');
+            }
+            const successMessage = reviews.length > 0
+                ? 'All reviews and review comments have been addressed and resolved'
+                : 'All review comments have been addressed and resolved';
+            return {
+                status: 'success',
+                message: successMessage,
+                data: {
+                    featureId,
+                    totalReviews: reviews.length,
+                    unresolvedReviews: 0,
+                    totalComments: unresolvedThreads.length,
+                    resolvedComments: addressedThreads.length,
+                    unresolvedComments: 0,
+                    commentsMarkedResolved: addressedThreads.length,
+                },
+            };
+        }
+        else {
+            // 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`);
+                    unresolvedReviews.forEach((review) => {
+                        logInfo(`  - Review ${review.id} by @${review.user.login}`);
+                        if (review.body) {
+                            logInfo(`    ${review.body.substring(0, 100)}...`);
+                        }
+                    });
+                }
+                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(`    LLM Analysis: ${result.analysis.reason}`);
+                        }
+                    });
+                }
+            }
+            // Build targeted suggestions based on LLM analysis
+            const suggestions = [];
+            // 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) {
+                    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) => {
+                    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 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: result.analysis.reason, // Use LLM analysis result
+                    url: firstComment.url,
+                };
+            });
+            const unresolvedReviewDetails = unresolvedReviews.map((review) => ({
+                reviewId: review.id,
+                author: review.user.login,
+                state: review.state,
+                body: review.body,
+                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)`;
+            }
+            else if (unresolvedReviews.length > 0) {
+                errorMessage = `${unresolvedReviews.length} reviews still requesting changes`;
+            }
+            else {
+                errorMessage = `${trulyUnresolvedThreads.length} review comments still need to be addressed (based on LLM analysis)`;
+            }
+            return {
+                status: 'error',
+                message: errorMessage,
+                data: {
+                    featureId,
+                    totalReviews: reviews.length,
+                    unresolvedReviews: unresolvedReviews.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,
+                },
+            };
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Code refine verification failed: ${errorMessage}`);
+        return {
+            status: 'error',
+            message: `Verification failed: ${errorMessage}`,
+            data: {
+                featureId,
+                totalReviews: 0,
+                unresolvedReviews: 0,
+                totalComments: 0,
+                resolvedComments: 0,
+                unresolvedComments: 0,
+                suggestions: [
+                    `Verification failed with error: ${errorMessage}`,
+                    'Please check the error message and try again',
+                ],
+            },
+        };
+    }
+}

package/dist/phases/code-review/analyzer.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Code Review Analyzer
+ * Reviews GitHub PR code and creates review comments with REQUEST_CHANGES
+ */
+import { EdsgerConfig } from '../../types/index.js';
+export interface CodeReviewOptions {
+    featureId: string;
+    githubToken: string;
+    verbose?: boolean;
+}
+export interface ReviewComment {
+    path: string;
+    line: number;
+    side: 'LEFT' | 'RIGHT';
+    body: string;
+}
+export interface CodeReviewResult {
+    featureId: string;
+    status: 'success' | 'error';
+    message: string;
+    reviewId?: number;
+    reviewUrl?: string;
+    commentsCount?: number;
+    summary?: string;
+}
+/**
+ * Main code review function
+ */
+export declare const reviewPullRequest: (options: CodeReviewOptions, config: EdsgerConfig) => Promise<CodeReviewResult>;