edsger 0.41.0 → 0.41.2

package/dist/phases/code-review/analyzer.js

@@ -0,0 +1,363 @@
+/**
+ * Code Review Analyzer
+ * Reviews GitHub PR code and creates review comments with REQUEST_CHANGES
+ */
+import { query } from '@anthropic-ai/claude-code';
+import { logInfo, logError } from '../../utils/logger.js';
+import { Octokit } from '@octokit/rest';
+import { fetchCodeReviewContext, formatContextForPrompt, } from './context-fetcher.js';
+import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
+function userMessage(content) {
+    return {
+        type: 'user',
+        message: { role: 'user', content: content },
+    };
+}
+async function* prompt(reviewPrompt) {
+    yield userMessage(reviewPrompt);
+    await new Promise((res) => setTimeout(res, 10000));
+}
+/**
+ * Main code review function
+ */
+export const reviewPullRequest = async (options, config) => {
+    const { featureId, githubToken, verbose } = options;
+    if (verbose) {
+        logInfo(`Starting code review for feature ID: ${featureId}`);
+    }
+    try {
+        // Fetch code review context (PR data, files, commits)
+        if (verbose) {
+            logInfo('Fetching code review context from GitHub PR...');
+        }
+        const context = await fetchCodeReviewContext(featureId, githubToken, verbose);
+        // Check if there are any files to review
+        if (context.files.length === 0) {
+            if (verbose) {
+                logInfo('✅ No files to review in the PR.');
+            }
+            return {
+                featureId,
+                status: 'success',
+                message: 'No files to review',
+                summary: 'No changed files found in the PR',
+            };
+        }
+        if (verbose) {
+            logInfo(`📋 Found ${context.files.length} files to review across ${context.commits.length} commits`);
+        }
+        // Fetch additional feedbacks for code-review phase
+        let feedbacksInfo;
+        try {
+            const feedbacksContext = await getFeedbacksForPhase({ featureId, verbose }, 'code_review');
+            if (feedbacksContext.feedbacks.length > 0) {
+                feedbacksInfo = formatFeedbacksForContext(feedbacksContext);
+                if (verbose) {
+                    logInfo(`Added ${feedbacksContext.feedbacks.length} human feedbacks to code review context`);
+                }
+            }
+        }
+        catch (error) {
+            if (verbose) {
+                logInfo(`Note: Could not fetch feedbacks (${error instanceof Error ? error.message : String(error)})`);
+            }
+        }
+        // Create prompt for code review
+        const systemPrompt = createSystemPrompt(config);
+        const reviewPrompt = createCodeReviewPrompt(featureId, context, feedbacksInfo);
+        let lastAssistantResponse = '';
+        let structuredReviewResult = null;
+        if (verbose) {
+            logInfo('Starting Claude analysis for code review...');
+        }
+        // Use Claude to analyze the code (not using Claude Code SDK for actual implementation)
+        // This is a simplified approach - just analyze the code
+        for await (const message of query({
+            prompt: prompt(reviewPrompt),
+            options: {
+                appendSystemPrompt: systemPrompt,
+                model: config.claude.model || 'sonnet',
+                maxTurns: 50, // Limited turns since this is just analysis
+                permissionMode: 'bypassPermissions',
+            },
+        })) {
+            if (verbose) {
+                logInfo(`Received message type: ${message.type}`);
+            }
+            // Stream the code review process
+            if (message.type === 'assistant' && message.message?.content) {
+                for (const content of message.message.content) {
+                    if (content.type === 'text') {
+                        lastAssistantResponse += content.text + '\n';
+                        if (verbose) {
+                            console.log(`\n🔍 ${content.text}`);
+                        }
+                    }
+                }
+            }
+            else if (message.type === 'result') {
+                if (message.subtype === 'success') {
+                    logInfo('\n🛠️ Code review analysis completed, parsing results...');
+                    try {
+                        const responseText = message.result || lastAssistantResponse;
+                        let jsonResult = null;
+                        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+                        if (jsonBlockMatch) {
+                            jsonResult = JSON.parse(jsonBlockMatch[1]);
+                        }
+                        else {
+                            jsonResult = JSON.parse(responseText);
+                        }
+                        if (jsonResult && jsonResult.review_result) {
+                            structuredReviewResult = jsonResult.review_result;
+                        }
+                        else {
+                            throw new Error('Invalid JSON structure');
+                        }
+                    }
+                    catch (error) {
+                        logError(`Failed to parse structured review result: ${error}`);
+                        structuredReviewResult = parseCodeReviewResponse(message.result || lastAssistantResponse);
+                    }
+                }
+                else {
+                    logError(`\n⚠️  Code review incomplete: ${message.subtype}`);
+                    if (message.subtype === 'error_max_turns') {
+                        logError('💡 Try simplifying the review scope');
+                    }
+                    if (lastAssistantResponse) {
+                        try {
+                            const responseText = lastAssistantResponse;
+                            let jsonResult = null;
+                            const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+                            if (jsonBlockMatch) {
+                                jsonResult = JSON.parse(jsonBlockMatch[1]);
+                                if (jsonResult && jsonResult.review_result) {
+                                    structuredReviewResult = jsonResult.review_result;
+                                }
+                            }
+                            else {
+                                structuredReviewResult = parseCodeReviewResponse(lastAssistantResponse);
+                            }
+                        }
+                        catch (error) {
+                            logError(`Failed to parse assistant response: ${error}`);
+                        }
+                    }
+                }
+            }
+        }
+        // Create GitHub review with comments
+        if (structuredReviewResult) {
+            const { summary, comments, overall_assessment } = structuredReviewResult;
+            // Initialize Octokit
+            const octokit = new Octokit({ auth: githubToken });
+            if (!comments || comments.length === 0) {
+                if (verbose) {
+                    logInfo('✅ No issues found. PR looks good!');
+                }
+                // Create an approval review if no issues found
+                const review = await octokit.pulls.createReview({
+                    owner: context.owner,
+                    repo: context.repo,
+                    pull_number: context.pullRequestNumber,
+                    event: 'APPROVE',
+                    body: summary ||
+                        overall_assessment ||
+                        'Code review completed. No issues found.',
+                });
+                return {
+                    featureId,
+                    status: 'success',
+                    message: 'Code review completed - no issues found',
+                    reviewId: review.data.id,
+                    reviewUrl: review.data.html_url,
+                    commentsCount: 0,
+                    summary: summary || 'No issues found',
+                };
+            }
+            if (verbose) {
+                logInfo(`Creating GitHub review with ${comments.length} comments...`);
+            }
+            // Create review with inline comments
+            const reviewComments = comments.map((comment) => ({
+                path: comment.file || comment.path,
+                line: comment.line,
+                body: comment.comment || comment.body,
+            }));
+            const review = await octokit.pulls.createReview({
+                owner: context.owner,
+                repo: context.repo,
+                pull_number: context.pullRequestNumber,
+                event: 'COMMENT',
+                body: summary ||
+                    overall_assessment ||
+                    'Please address the following review comments.',
+                comments: reviewComments,
+            });
+            if (verbose) {
+                logInfo(`✅ GitHub review created: ${review.data.html_url}`);
+                logInfo(`Review ID: ${review.data.id}`);
+                logInfo(`Comments posted: ${comments.length}`);
+            }
+            return {
+                featureId,
+                status: 'success',
+                message: 'Code review completed and posted to GitHub',
+                reviewId: review.data.id,
+                reviewUrl: review.data.html_url,
+                commentsCount: comments.length,
+                summary: summary || 'Code review completed',
+            };
+        }
+        else {
+            return {
+                featureId,
+                status: 'error',
+                message: 'Code review analysis failed or incomplete',
+            };
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Code review failed: ${errorMessage}`);
+        return {
+            featureId,
+            status: 'error',
+            message: `Code review failed: ${errorMessage}`,
+        };
+    }
+};
+function createSystemPrompt(_config) {
+    return `You are an expert code reviewer specializing in thorough, constructive code reviews. Your goal is to analyze pull request code and identify issues, potential bugs, code quality concerns, and areas for improvement.
+
+**Your Role**: Review pull request code and provide detailed, actionable feedback.
+
+**Review Focus Areas**:
+1. **Code Quality**: Clean code principles, readability, maintainability
+2. **Best Practices**: Language-specific conventions, design patterns
+3. **Potential Bugs**: Logic errors, edge cases, error handling
+4. **Security**: Security vulnerabilities, input validation
+5. **Performance**: Performance issues, optimization opportunities
+6. **Testing**: Test coverage, test quality
+7. **Documentation**: Code comments, documentation completeness
+8. **Architecture**: Design decisions, coupling, cohesion
+
+**Important Guidelines**:
+- Be thorough but focus on significant issues
+- Provide constructive, actionable feedback
+- Suggest specific improvements
+- Consider the technical design and requirements
+- Be respectful and professional
+- Focus on issues that truly matter, not nitpicks
+- If code looks good overall, provide positive feedback
+
+**CRITICAL - Result Format**:
+You MUST end your response with a JSON object containing the review results in this EXACT format:
+
+\`\`\`json
+{
+  "review_result": {
+    "feature_id": "FEATURE_ID_PLACEHOLDER",
+    "summary": "Overall review summary and assessment",
+    "overall_assessment": "APPROVE | REQUEST_CHANGES | COMMENT",
+    "comments": [
+      {
+        "file": "path/to/file.ts",
+        "line": 42,
+        "comment": "Detailed comment about the issue and suggested fix"
+      }
+    ],
+    "issues_found": {
+      "critical": 0,
+      "major": 0,
+      "minor": 0
+    }
+  }
+}
+\`\`\`
+
+**Comment Guidelines**:
+- Each comment should reference a specific file and line number
+- Be specific about what the issue is
+- Provide a suggested fix or improvement
+- Use a constructive, helpful tone
+
+**Assessment Options**:
+- **APPROVE**: Code looks good, no significant issues
+- **REQUEST_CHANGES**: Issues found that should be addressed
+- **COMMENT**: Minor suggestions or questions, not blocking
+
+Focus on providing valuable, actionable code review feedback.`;
+}
+function createCodeReviewPrompt(featureId, context, feedbacksInfo) {
+    let contextInfo = formatContextForPrompt(context);
+    if (feedbacksInfo) {
+        contextInfo = contextInfo + '\n\n' + feedbacksInfo;
+    }
+    return `Review the pull request code for feature: ${featureId}
+
+${contextInfo}
+
+## Code Review Instructions
+
+Follow this systematic approach:
+
+1. **Understand the Context**: Review the feature description, technical design, user stories, and test cases to understand what the code should accomplish.
+
+2. **Analyze Each File**: For each changed file:
+   - Review the code changes in the diff
+   - Look for code quality issues
+   - Check for potential bugs or logic errors
+   - Verify error handling
+   - Consider security implications
+   - Evaluate performance considerations
+   - Check test coverage
+
+3. **Check Against Requirements**:
+   - Does the code implement the technical design correctly?
+   - Are all user stories addressed?
+   - Are test cases covered?
+
+4. **Identify Issues**: Categorize issues by severity:
+   - **Critical**: Security vulnerabilities, data loss risks, major bugs
+   - **Major**: Logic errors, incorrect implementations, missing error handling
+   - **Minor**: Code quality improvements, style issues, optimization suggestions
+
+5. **Provide Actionable Feedback**: For each issue:
+   - Reference the specific file and line number
+   - Explain what the issue is
+   - Suggest how to fix it
+   - Be constructive and helpful
+
+6. **Generate Review Result**: Create a structured JSON response with:
+   - Overall summary
+   - Assessment (APPROVE/REQUEST_CHANGES/COMMENT)
+   - List of comments with file, line, and comment text
+   - Count of issues by severity
+
+## Important Notes
+- Be thorough but focus on meaningful issues
+- Provide specific, actionable suggestions
+- Consider the context and requirements
+- Be professional and constructive
+- If code is good, say so!
+
+Begin by analyzing the changed files and identifying any issues or improvements.`;
+}
+function parseCodeReviewResponse(response) {
+    const summaryMatch = response.match(/## Review Summary\n([\s\S]*?)(?=\n##|\n\n|$)/);
+    const summary = summaryMatch
+        ? summaryMatch[1].trim()
+        : 'Code review completed';
+    return {
+        summary,
+        comments: [],
+        overall_assessment: 'COMMENT',
+        issues_found: {
+            critical: 0,
+            major: 0,
+            minor: 0,
+        },
+    };
+}

package/dist/phases/code-review/context-fetcher.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Context fetcher for code review phase
+ * Fetches GitHub PR data including files, diffs, and commits for review
+ */
+import { Octokit } from '@octokit/rest';
+export interface PRFile {
+    filename: string;
+    status: string;
+    additions: number;
+    deletions: number;
+    changes: number;
+    patch?: string;
+    blob_url: string;
+}
+export interface PRCommit {
+    sha: string;
+    commit: {
+        message: string;
+        author: {
+            name: string;
+            date: string;
+        };
+    };
+}
+export interface PRData {
+    number: number;
+    title: string;
+    body: string | null;
+    state: string;
+    head: {
+        ref: string;
+        sha: string;
+    };
+    base: {
+        ref: string;
+        sha: string;
+    };
+    user: {
+        login: string;
+    };
+}
+export interface CodeReviewContext {
+    featureId: string;
+    featureName: string;
+    featureDescription: string | null;
+    pullRequestUrl: string;
+    pullRequestNumber: number;
+    owner: string;
+    repo: string;
+    prData: PRData;
+    files: PRFile[];
+    commits: PRCommit[];
+    technicalDesign?: string;
+    userStories?: any[];
+    testCases?: any[];
+}
+/**
+ * Extract owner, repo, and PR number from GitHub PR URL
+ */
+export declare function parsePullRequestUrl(pullRequestUrl: string): {
+    owner: string;
+    repo: string;
+    prNumber: number;
+} | null;
+/**
+ * Fetch PR details
+ */
+export declare function fetchPRDetails(octokit: Octokit, owner: string, repo: string, prNumber: number, verbose?: boolean): Promise<PRData>;
+/**
+ * Fetch PR files (changed files with diffs)
+ */
+export declare function fetchPRFiles(octokit: Octokit, owner: string, repo: string, prNumber: number, verbose?: boolean): Promise<PRFile[]>;
+/**
+ * Fetch PR commits
+ */
+export declare function fetchPRCommits(octokit: Octokit, owner: string, repo: string, prNumber: number, verbose?: boolean): Promise<PRCommit[]>;
+/**
+ * Fetch user stories via MCP
+ */
+export declare function fetchUserStories(featureId: string, verbose?: boolean): Promise<any[]>;
+/**
+ * Fetch test cases via MCP
+ */
+export declare function fetchTestCases(featureId: string, verbose?: boolean): Promise<any[]>;
+/**
+ * Fetch complete code review context
+ */
+export declare function fetchCodeReviewContext(featureId: string, githubToken: string, verbose?: boolean): Promise<CodeReviewContext>;
+/**
+ * Format code review context for prompt
+ */
+export declare function formatContextForPrompt(context: CodeReviewContext): string;