edsger 0.41.1 → 0.41.2

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

@@ -0,0 +1,423 @@
+/**
+ * Context fetcher for code refine phase
+ * Fetches GitHub PR review comments and reviews using GraphQL API
+ */
+import { Octokit } from '@octokit/rest';
+import { getFeature } from '../../api/features/get-feature.js';
+/**
+ * Extract owner, repo, and PR number from GitHub PR URL
+ */
+export function parsePullRequestUrl(pullRequestUrl) {
+    const match = pullRequestUrl.match(/github\.com\/([^\/]+)\/([^\/]+)\/pull\/(\d+)/);
+    if (!match) {
+        return null;
+    }
+    return {
+        owner: match[1],
+        repo: match[2],
+        prNumber: parseInt(match[3], 10),
+    };
+}
+/**
+ * Fetch PR reviews that request changes
+ */
+export async function fetchPRReviews(octokit, owner, repo, prNumber, verbose) {
+    if (verbose) {
+        console.log(`📋 Fetching PR reviews for ${owner}/${repo}#${prNumber}...`);
+    }
+    const { data: reviews } = await octokit.pulls.listReviews({
+        owner,
+        repo,
+        pull_number: prNumber,
+    });
+    // Filter for reviews that request changes
+    const requestChangesReviews = reviews.filter((review) => review.state === 'CHANGES_REQUESTED');
+    if (verbose) {
+        console.log(`✅ Found ${requestChangesReviews.length} reviews requesting changes`);
+    }
+    return requestChangesReviews;
+}
+/**
+ * Fetch PR review comments
+ */
+export async function fetchPRReviewComments(octokit, owner, repo, prNumber, verbose) {
+    if (verbose) {
+        console.log(`💬 Fetching PR review comments for ${owner}/${repo}#${prNumber}...`);
+    }
+    const { data: comments } = await octokit.pulls.listReviewComments({
+        owner,
+        repo,
+        pull_number: prNumber,
+    });
+    if (verbose) {
+        console.log(`✅ Found ${comments.length} review comments`);
+    }
+    return comments;
+}
+/**
+ * Fetch PR data using GraphQL API including review threads and reviews
+ */
+export async function fetchPRDataGraphQL(octokit, owner, repo, prNumber, verbose) {
+    if (verbose) {
+        console.log(`🔍 Fetching PR data via GraphQL for ${owner}/${repo}#${prNumber}...`);
+    }
+    const query = `
+    query($owner: String!, $repo: String!, $prNumber: Int!) {
+      repository(owner: $owner, name: $repo) {
+        pullRequest(number: $prNumber) {
+          reviews(first: 100) {
+            nodes {
+              id
+              databaseId
+              author {
+                login
+              }
+              body
+              state
+              submittedAt
+            }
+          }
+          reviewThreads(first: 100) {
+            nodes {
+              id
+              isResolved
+              isOutdated
+              line
+              originalLine
+              startLine
+              originalStartLine
+              diffSide
+              comments(first: 100) {
+                nodes {
+                  id
+                  databaseId
+                  body
+                  path
+                  originalPosition
+                  diffHunk
+                  createdAt
+                  url
+                  author {
+                    login
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  `;
+    const result = await octokit.graphql(query, {
+        owner,
+        repo,
+        prNumber,
+    });
+    const pullRequest = result.repository.pullRequest;
+    // Transform GraphQL reviews to our interface
+    const reviews = (pullRequest.reviews.nodes || []).map((review) => ({
+        id: review.databaseId,
+        user: {
+            login: review.author?.login || 'unknown',
+        },
+        body: review.body,
+        state: review.state,
+        submitted_at: review.submittedAt,
+    }));
+    // Transform GraphQL review threads to our interface
+    const reviewThreads = (pullRequest.reviewThreads.nodes || []).map((thread) => ({
+        id: thread.id,
+        isResolved: thread.isResolved,
+        isOutdated: thread.isOutdated,
+        line: thread.line,
+        originalLine: thread.originalLine,
+        startLine: thread.startLine,
+        originalStartLine: thread.originalStartLine,
+        diffSide: thread.diffSide,
+        comments: (thread.comments.nodes || []).map((comment) => ({
+            id: comment.databaseId,
+            body: comment.body,
+            path: comment.path,
+            line: thread.line, // Use thread's line for consistency
+            user: {
+                login: comment.author?.login || 'unknown',
+            },
+            created_at: comment.createdAt,
+            position: comment.originalPosition,
+            original_position: comment.originalPosition,
+            diff_hunk: comment.diffHunk,
+            url: comment.url,
+        })),
+    }));
+    // Filter for reviews requesting changes
+    const changesRequestedReviews = reviews.filter((review) => review.state === 'CHANGES_REQUESTED');
+    // Filter for unresolved threads
+    const unresolvedThreads = reviewThreads.filter((thread) => !thread.isResolved);
+    if (verbose) {
+        console.log(`✅ Found ${changesRequestedReviews.length} reviews requesting changes`);
+        console.log(`✅ Found ${unresolvedThreads.length} unresolved review threads`);
+    }
+    return {
+        reviewThreads: unresolvedThreads,
+        reviews: changesRequestedReviews,
+    };
+}
+/**
+ * Fetch user stories via MCP
+ */
+export async function fetchUserStories(featureId, verbose) {
+    try {
+        if (verbose) {
+            console.log(`📖 Fetching user stories for ${featureId}...`);
+        }
+        const mcpServerUrl = process.env.MCP_SERVER_URL;
+        const mcpToken = process.env.MCP_TOKEN;
+        const response = await fetch(`${mcpServerUrl}/mcp`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${mcpToken}`,
+            },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'user_stories/list',
+                params: {
+                    feature_id: featureId,
+                },
+            }),
+        });
+        if (!response.ok) {
+            if (verbose) {
+                console.log(`⚠️ Could not fetch user stories: ${response.status}`);
+            }
+            return [];
+        }
+        const data = await response.json();
+        if (data.error || !data.result) {
+            if (verbose) {
+                console.log(`⚠️ User stories not available`);
+            }
+            return [];
+        }
+        return data.result.user_stories || [];
+    }
+    catch (error) {
+        if (verbose) {
+            console.log(`⚠️ Error fetching user stories: ${error}`);
+        }
+        return [];
+    }
+}
+/**
+ * Fetch test cases via MCP
+ */
+export async function fetchTestCases(featureId, verbose) {
+    try {
+        if (verbose) {
+            console.log(`🧪 Fetching test cases for ${featureId}...`);
+        }
+        const mcpServerUrl = process.env.MCP_SERVER_URL;
+        const mcpToken = process.env.MCP_TOKEN;
+        const response = await fetch(`${mcpServerUrl}/mcp`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${mcpToken}`,
+            },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'test_cases/list',
+                params: {
+                    feature_id: featureId,
+                },
+            }),
+        });
+        if (!response.ok) {
+            if (verbose) {
+                console.log(`⚠️ Could not fetch test cases: ${response.status}`);
+            }
+            return [];
+        }
+        const data = await response.json();
+        if (data.error || !data.result) {
+            if (verbose) {
+                console.log(`⚠️ Test cases not available`);
+            }
+            return [];
+        }
+        return data.result.test_cases || [];
+    }
+    catch (error) {
+        if (verbose) {
+            console.log(`⚠️ Error fetching test cases: ${error}`);
+        }
+        return [];
+    }
+}
+/**
+ * Fetch complete code refine context
+ */
+export async function fetchCodeRefineContext(featureId, githubToken, verbose) {
+    // 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 code refine.`);
+    }
+    // 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
+    const octokit = new Octokit({
+        auth: githubToken,
+    });
+    // Fetch PR data using GraphQL API and additional context
+    const [prData, userStories, testCases] = await Promise.all([
+        fetchPRDataGraphQL(octokit, owner, repo, prNumber, verbose),
+        fetchUserStories(featureId, verbose),
+        fetchTestCases(featureId, verbose),
+    ]);
+    // Extract review comments from unresolved threads
+    const reviewComments = prData.reviewThreads.flatMap((thread) => thread.comments);
+    if (verbose) {
+        console.log(`📊 Summary: ${prData.reviews.length} reviews requesting changes, ${prData.reviewThreads.length} unresolved threads, ${reviewComments.length} total comments`);
+    }
+    return {
+        featureId,
+        featureName: feature.name,
+        featureDescription: feature.description ?? null,
+        pullRequestUrl: feature.pull_request_url,
+        pullRequestNumber: prNumber,
+        owner,
+        repo,
+        reviews: prData.reviews,
+        reviewComments,
+        reviewThreads: prData.reviewThreads,
+        technicalDesign: feature.technical_design,
+        userStories,
+        testCases,
+    };
+}
+/**
+ * Format code refine context for prompt
+ */
+export function formatContextForPrompt(context) {
+    const sections = [];
+    // Feature information
+    sections.push(`# Feature Information`);
+    sections.push(`**Feature ID**: ${context.featureId}`);
+    sections.push(`**Feature Name**: ${context.featureName}`);
+    if (context.featureDescription) {
+        sections.push(`**Description**: ${context.featureDescription}`);
+    }
+    sections.push(`**Pull Request**: ${context.pullRequestUrl} (#${context.pullRequestNumber})`);
+    sections.push('');
+    // Reviews requesting changes
+    if (context.reviews.length > 0) {
+        sections.push(`## Code Reviews Requesting Changes`);
+        sections.push('');
+        context.reviews.forEach((review, idx) => {
+            sections.push(`### Review ${idx + 1} by @${review.user.login}`);
+            sections.push(`**Submitted**: ${review.submitted_at}`);
+            if (review.body) {
+                sections.push(`**Feedback**:`);
+                sections.push(review.body);
+            }
+            sections.push('');
+        });
+    }
+    // Review threads (unresolved conversations)
+    if (context.reviewThreads && context.reviewThreads.length > 0) {
+        sections.push(`## Unresolved Review Threads`);
+        sections.push(`*These conversations must be resolved before the PR can be merged.*`);
+        sections.push('');
+        context.reviewThreads.forEach((thread, idx) => {
+            sections.push(`### Thread ${idx + 1} ${thread.isOutdated ? '(Outdated)' : ''}`);
+            // Show thread location
+            if (thread.line !== null) {
+                sections.push(`**Line**: ${thread.line}`);
+            }
+            if (thread.startLine !== null && thread.startLine !== thread.line) {
+                sections.push(`**Line Range**: ${thread.startLine} - ${thread.line || thread.originalLine}`);
+            }
+            sections.push(`**Status**: ❌ Unresolved`);
+            sections.push('');
+            // Show all comments in this thread
+            thread.comments.forEach((comment, commentIdx) => {
+                sections.push(`#### ${commentIdx === 0 ? 'Original Comment' : `Reply ${commentIdx}`} by @${comment.user.login}`);
+                if (comment.path) {
+                    sections.push(`**File**: ${comment.path}`);
+                }
+                if (comment.url) {
+                    sections.push(`**URL**: ${comment.url}`);
+                }
+                if (commentIdx === 0 && comment.diff_hunk) {
+                    sections.push(`**Context**:`);
+                    sections.push('```diff');
+                    sections.push(comment.diff_hunk);
+                    sections.push('```');
+                }
+                sections.push(`**Comment**:`);
+                sections.push(comment.body);
+                sections.push('');
+            });
+        });
+    }
+    else if (context.reviewComments.length > 0) {
+        // Fallback to old format if no thread data available
+        sections.push(`## Review Comments`);
+        sections.push('');
+        context.reviewComments.forEach((comment, idx) => {
+            sections.push(`### Comment ${idx + 1} by @${comment.user.login}`);
+            if (comment.path) {
+                sections.push(`**File**: ${comment.path}`);
+            }
+            if (comment.line !== null) {
+                sections.push(`**Line**: ${comment.line}`);
+            }
+            if (comment.diff_hunk) {
+                sections.push(`**Context**:`);
+                sections.push('```diff');
+                sections.push(comment.diff_hunk);
+                sections.push('```');
+            }
+            sections.push(`**Comment**:`);
+            sections.push(comment.body);
+            sections.push('');
+        });
+    }
+    // Technical design
+    if (context.technicalDesign) {
+        sections.push(`## Technical Design`);
+        sections.push('');
+        sections.push(context.technicalDesign);
+        sections.push('');
+    }
+    // User stories
+    if (context.userStories && context.userStories.length > 0) {
+        sections.push(`## User Stories`);
+        sections.push('');
+        context.userStories.forEach((story) => {
+            sections.push(`### ${story.title}`);
+            sections.push(story.description || '');
+            sections.push('');
+        });
+    }
+    // Test cases
+    if (context.testCases && context.testCases.length > 0) {
+        sections.push(`## Test Cases`);
+        sections.push('');
+        context.testCases.forEach((testCase) => {
+            sections.push(`### ${testCase.title}`);
+            if (testCase.description) {
+                sections.push(testCase.description);
+            }
+            sections.push('');
+        });
+    }
+    return sections.join('\n');
+}

package/dist/phases/code-refine-verification/analysis/llm-analyzer.d.ts

@@ -0,0 +1,22 @@
+/**
+ * LLM-based analysis for code review comment verification
+ * Uses Claude to intelligently determine if feedback has been addressed
+ */
+import { ReviewThread, PRFileChange } from '../types.js';
+import { EdsgerConfig } from '../../../types/index.js';
+export interface ThreadAnalysisResult {
+    isAddressed: boolean;
+    reason: string;
+}
+/**
+ * Analyze whether a review thread has been addressed by examining code changes
+ * Uses LLM to intelligently determine if the feedback was addressed
+ */
+export declare function analyzeThreadWithLLM(thread: ReviewThread, fileChange: PRFileChange | undefined, config: EdsgerConfig, verbose?: boolean): Promise<ThreadAnalysisResult>;
+/**
+ * Analyze all review threads in parallel using LLM
+ */
+export declare function analyzeAllThreads(threads: ReviewThread[], fileChanges: PRFileChange[], config: EdsgerConfig, verbose?: boolean): Promise<Array<{
+    thread: ReviewThread;
+    analysis: ThreadAnalysisResult;
+}>>;

package/dist/phases/code-refine-verification/analysis/llm-analyzer.js

@@ -0,0 +1,134 @@
+/**
+ * LLM-based analysis for code review comment verification
+ * Uses Claude to intelligently determine if feedback has been addressed
+ */
+import { query } from '@anthropic-ai/claude-code';
+import { logInfo, logError } from '../../../utils/logger.js';
+import { createThreadAnalysisPrompt } from '../prompts.js';
+/**
+ * Analyze whether a review thread has been addressed by examining code changes
+ * Uses LLM to intelligently determine if the feedback was addressed
+ */
+export 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',
+        };
+    }
+}
+/**
+ * Analyze all review threads in parallel using LLM
+ */
+export async function analyzeAllThreads(threads, fileChanges, config, verbose) {
+    if (verbose && threads.length > 0) {
+        logInfo(`🔍 Analyzing ${threads.length} unresolved threads with LLM...`);
+    }
+    const results = await Promise.all(threads.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,
+        };
+    }));
+    if (verbose) {
+        const addressedCount = results.filter((r) => r.analysis.isAddressed).length;
+        const unresolvedCount = results.length - addressedCount;
+        logInfo(`📊 LLM Analysis: ${addressedCount} threads addressed, ${unresolvedCount} still need attention`);
+    }
+    return results;
+}

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

@@ -0,0 +1,47 @@
+/**
+ * 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 { EdsgerConfig } from '../../types/index.js';
+export interface CodeRefineVerificationOptions {
+    featureId: string;
+    githubToken: string;
+    config: EdsgerConfig;
+    verbose?: boolean;
+}
+export interface CodeRefineVerificationData {
+    featureId: string;
+    totalReviews: number;
+    unresolvedReviews: number;
+    totalComments: number;
+    resolvedComments: number;
+    unresolvedComments: number;
+    commentsMarkedResolved?: number;
+    suggestions?: string[];
+    unresolvedReviewDetails?: Array<{
+        reviewId: number;
+        author: string;
+        state: string;
+        body: string | null;
+        submittedAt: string | null;
+    }>;
+    unresolvedCommentDetails?: Array<{
+        commentId: string;
+        author: string;
+        file: string;
+        line: number | null;
+        body: string;
+        failureReason: string;
+        url: string;
+    }>;
+}
+export interface CodeRefineVerificationResult {
+    status: 'success' | 'error';
+    message: string;
+    data: CodeRefineVerificationData;
+}
+/**
+ * Verify and resolve PR review comments using GraphQL API and LLM analysis
+ */
+export declare function verifyAndResolveComments(options: CodeRefineVerificationOptions): Promise<CodeRefineVerificationResult>;