edsger 0.4.11 → 0.5.1

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

@@ -0,0 +1,32 @@
+/**
+ * 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;
+    mcpServerUrl: string;
+    mcpToken: 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>;
+export declare function checkCodeReviewRequirements(): Promise<boolean>;

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

@@ -0,0 +1,369 @@
+/**
+ * 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, mcpServerUrl, mcpToken, githubToken, verbose } = options;
+    if (verbose) {
+        logInfo(`Starting code review for feature ID: ${featureId}`);
+        logInfo(`Using MCP server: ${mcpServerUrl}`);
+    }
+    try {
+        // Fetch code review context (PR data, files, commits)
+        if (verbose) {
+            logInfo('Fetching code review context from GitHub PR...');
+        }
+        const context = await fetchCodeReviewContext(mcpServerUrl, mcpToken, 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, mcpServerUrl, mcpToken, 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,
+        },
+    };
+}
+export function checkCodeReviewRequirements() {
+    // Dependencies are declared in package.json and will be installed automatically
+    // No need to check for them here
+    return Promise.resolve(true);
+}

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(mcpServerUrl: string, mcpToken: string, featureId: string, verbose?: boolean): Promise<any[]>;
+/**
+ * Fetch test cases via MCP
+ */
+export declare function fetchTestCases(mcpServerUrl: string, mcpToken: string, featureId: string, verbose?: boolean): Promise<any[]>;
+/**
+ * Fetch complete code review context
+ */
+export declare function fetchCodeReviewContext(mcpServerUrl: string, mcpToken: string, featureId: string, githubToken: string, verbose?: boolean): Promise<CodeReviewContext>;
+/**
+ * Format code review context for prompt
+ */
+export declare function formatContextForPrompt(context: CodeReviewContext): string;

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

@@ -0,0 +1,292 @@
+/**
+ * Context fetcher for code review phase
+ * Fetches GitHub PR data including files, diffs, and commits for review
+ */
+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 details
+ */
+export async function fetchPRDetails(octokit, owner, repo, prNumber, verbose) {
+    if (verbose) {
+        console.log(`📋 Fetching PR details for ${owner}/${repo}#${prNumber}...`);
+    }
+    const { data } = await octokit.pulls.get({
+        owner,
+        repo,
+        pull_number: prNumber,
+    });
+    if (verbose) {
+        console.log(`✅ Fetched PR: ${data.title}`);
+    }
+    return data;
+}
+/**
+ * Fetch PR files (changed files with diffs)
+ */
+export async function fetchPRFiles(octokit, owner, repo, prNumber, verbose) {
+    if (verbose) {
+        console.log(`📂 Fetching PR files for ${owner}/${repo}#${prNumber}...`);
+    }
+    const { data: files } = await octokit.pulls.listFiles({
+        owner,
+        repo,
+        pull_number: prNumber,
+        per_page: 100,
+    });
+    if (verbose) {
+        console.log(`✅ Found ${files.length} changed files`);
+    }
+    return files;
+}
+/**
+ * Fetch PR commits
+ */
+export async function fetchPRCommits(octokit, owner, repo, prNumber, verbose) {
+    if (verbose) {
+        console.log(`💾 Fetching PR commits for ${owner}/${repo}#${prNumber}...`);
+    }
+    const { data: commits } = await octokit.pulls.listCommits({
+        owner,
+        repo,
+        pull_number: prNumber,
+        per_page: 100,
+    });
+    if (verbose) {
+        console.log(`✅ Found ${commits.length} commits`);
+    }
+    return commits;
+}
+/**
+ * Fetch user stories via MCP
+ */
+export async function fetchUserStories(mcpServerUrl, mcpToken, featureId, verbose) {
+    try {
+        if (verbose) {
+            console.log(`📖 Fetching user stories for ${featureId}...`);
+        }
+        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(mcpServerUrl, mcpToken, featureId, verbose) {
+    try {
+        if (verbose) {
+            console.log(`🧪 Fetching test cases for ${featureId}...`);
+        }
+        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 review context
+ */
+export async function fetchCodeReviewContext(mcpServerUrl, mcpToken, featureId, githubToken, verbose) {
+    // Fetch feature info using shared API
+    const feature = await getFeature(mcpServerUrl, mcpToken, featureId, verbose);
+    if (!feature.pull_request_url) {
+        throw new Error(`Feature ${featureId} does not have a pull request URL. Cannot perform code review.`);
+    }
+    // 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, files, commits, and additional context in parallel
+    const [prData, files, commits, userStories, testCases] = await Promise.all([
+        fetchPRDetails(octokit, owner, repo, prNumber, verbose),
+        fetchPRFiles(octokit, owner, repo, prNumber, verbose),
+        fetchPRCommits(octokit, owner, repo, prNumber, verbose),
+        fetchUserStories(mcpServerUrl, mcpToken, featureId, verbose),
+        fetchTestCases(mcpServerUrl, mcpToken, featureId, verbose),
+    ]);
+    if (verbose) {
+        console.log(`📊 Summary: ${files.length} files changed across ${commits.length} commits`);
+    }
+    return {
+        featureId,
+        featureName: feature.name,
+        featureDescription: feature.description ?? null,
+        pullRequestUrl: feature.pull_request_url,
+        pullRequestNumber: prNumber,
+        owner,
+        repo,
+        prData,
+        files,
+        commits,
+        technicalDesign: feature.technical_design,
+        userStories,
+        testCases,
+    };
+}
+/**
+ * Format code review 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('');
+    // PR details
+    sections.push(`## Pull Request Details`);
+    sections.push(`**Title**: ${context.prData.title}`);
+    sections.push(`**Author**: @${context.prData.user.login}`);
+    sections.push(`**Base Branch**: ${context.prData.base.ref}`);
+    sections.push(`**Head Branch**: ${context.prData.head.ref}`);
+    if (context.prData.body) {
+        sections.push(`**Description**:`);
+        sections.push(context.prData.body);
+    }
+    sections.push('');
+    // Commits
+    if (context.commits.length > 0) {
+        sections.push(`## Commits (${context.commits.length})`);
+        sections.push('');
+        context.commits.forEach((commit) => {
+            sections.push(`- **${commit.sha.substring(0, 7)}**: ${commit.commit.message}`);
+            sections.push(`  by ${commit.commit.author.name} on ${commit.commit.author.date}`);
+        });
+        sections.push('');
+    }
+    // Changed files
+    if (context.files.length > 0) {
+        sections.push(`## Changed Files (${context.files.length})`);
+        sections.push('');
+        context.files.forEach((file) => {
+            sections.push(`### ${file.filename}`);
+            sections.push(`**Status**: ${file.status}`);
+            sections.push(`**Changes**: +${file.additions} -${file.deletions}`);
+            if (file.patch) {
+                sections.push(`**Diff**:`);
+                sections.push('```diff');
+                sections.push(file.patch);
+                sections.push('```');
+            }
+            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-review/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Code Review Module
+ * Reviews pull request code and creates GitHub review comments
+ * Part of the automated development workflow
+ */
+export { reviewPullRequest, checkCodeReviewRequirements, type CodeReviewOptions, type CodeReviewResult, type ReviewComment, } from './analyzer.js';
+export { fetchCodeReviewContext, formatContextForPrompt, parsePullRequestUrl, type CodeReviewContext, type PRFile, type PRCommit, type PRData, } from './context-fetcher.js';

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

@@ -0,0 +1,7 @@
+/**
+ * Code Review Module
+ * Reviews pull request code and creates GitHub review comments
+ * Part of the automated development workflow
+ */
+export { reviewPullRequest, checkCodeReviewRequirements, } from './analyzer.js';
+export { fetchCodeReviewContext, formatContextForPrompt, parsePullRequestUrl, } from './context-fetcher.js';

package/dist/services/audit-logs.d.ts

@@ -5,7 +5,7 @@
 export interface LogPhaseEventParams {
     featureId: string;
     eventType: 'phase_started' | 'phase_completed' | 'phase_failed';
-    phase: 'feature_analysis' | 'technical_design' | 'code_implementation' | 'functional_testing' | 'code_refine' | 'code_refine_verification';
+    phase: 'feature_analysis' | 'technical_design' | 'code_implementation' | 'functional_testing' | 'code_refine' | 'code_refine_verification' | 'code_review';
     result?: 'success' | 'error' | 'warning' | 'info';
     metadata?: Record<string, any>;
     errorMessage?: string;
@@ -19,7 +19,7 @@ export interface LogChecklistEventParams {
 }
 export interface LogVerificationEventParams {
     featureId: string;
-    phase: 'feature_analysis' | 'technical_design' | 'code_implementation' | 'functional_testing' | 'code_refine' | 'code_refine_verification';
+    phase: 'feature_analysis' | 'technical_design' | 'code_implementation' | 'functional_testing' | 'code_refine' | 'code_refine_verification' | 'code_review';
     iteration: number;
     result: 'success' | 'error';
     verificationData: {

package/dist/types/pipeline.d.ts

@@ -3,7 +3,7 @@
  */
 import { EdsgerConfig } from './index.js';
 import { ChecklistPhaseContext } from '../services/checklist.js';
-export type ExecutionMode = 'full_pipeline' | 'only_feature_analysis' | 'only_technical_design' | 'only_code_implementation' | 'only_functional_testing' | 'only_code_refine' | 'from_feature_analysis' | 'from_technical_design' | 'from_code_implementation' | 'from_functional_testing';
+export type ExecutionMode = 'full_pipeline' | 'only_feature_analysis' | 'only_technical_design' | 'only_code_implementation' | 'only_functional_testing' | 'only_code_refine' | 'only_code_review' | 'from_feature_analysis' | 'from_technical_design' | 'from_code_implementation' | 'from_functional_testing' | 'from_code_review';
 export interface PipelinePhaseOptions {
     readonly featureId: string;
     readonly mcpServerUrl: string;

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

@@ -7,6 +7,7 @@ import { implementFeatureCode, checkCodeImplementationRequirements, } from '../.
 import { runFunctionalTesting, checkFunctionalTestingRequirements, } from '../../phases/functional-testing/analyzer.js';
 import { refineCodeFromPRFeedback, checkCodeRefineRequirements, } from '../../phases/code-refine/analyzer.js';
 import { verifyAndResolveComments, checkCodeRefineVerificationRequirements, } from '../../phases/code-refine-verification/verifier.js';
+import { reviewPullRequest, checkCodeReviewRequirements, } from '../../phases/code-review/analyzer.js';
 /**
  * Wrapper for code-refine phase to inject GitHub token
  */
@@ -46,6 +47,25 @@ const executeCodeRefineVerification = async (options, config) => {
         verbose: options.verbose,
     });
 };
+/**
+ * Wrapper for code-review phase to inject GitHub token
+ */
+const executeCodeReview = async (options, config) => {
+    const githubToken = process.env.GITHUB_TOKEN || process.env.GITHUB_ACCESS_TOKEN;
+    if (!githubToken) {
+        return {
+            status: 'error',
+            message: 'GitHub token not found. Set GITHUB_TOKEN or GITHUB_ACCESS_TOKEN environment variable.',
+        };
+    }
+    return reviewPullRequest({
+        featureId: options.featureId,
+        mcpServerUrl: options.mcpServerUrl,
+        mcpToken: options.mcpToken,
+        githubToken,
+        verbose: options.verbose,
+    }, config);
+};
 // Pipeline phase configurations
 export const phaseConfigs = [
     {
@@ -84,4 +104,10 @@ export const phaseConfigs = [
         execute: executeCodeRefineVerification,
         requirementsError: 'Code refine verification requirements not met. Install with: npm install @octokit/rest',
     },
+    {
+        name: 'code-review',
+        checkRequirements: checkCodeReviewRequirements,
+        execute: executeCodeReview,
+        requirementsError: 'Code review requirements not met. Install with: npm install @anthropic-ai/claude-code @octokit/rest',
+    },
 ];

package/dist/workflow-runner/executors/phase-executor.d.ts

@@ -4,5 +4,5 @@
 import { EdsgerConfig } from '../../types/index.js';
 import { PipelinePhaseOptions, PipelineResult, PhaseConfig } from '../../types/pipeline.js';
 export declare const createPhaseRunner: (phaseConfig: PhaseConfig) => (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
-declare const runFeatureAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTechnicalDesignPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeImplementationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runFunctionalTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefinePhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefineVerificationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
-export { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, };
+declare const runFeatureAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTechnicalDesignPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeImplementationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runFunctionalTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefinePhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefineVerificationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeReviewPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
+export { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, };

package/dist/workflow-runner/executors/phase-executor.js

@@ -243,6 +243,6 @@ export const createPhaseRunner = (phaseConfig) => async (options, config) => {
     }
 };
 // Create phase runners using the configuration
-const [runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase,] = phaseConfigs.map(createPhaseRunner);
+const [runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase,] = phaseConfigs.map(createPhaseRunner);
 // Export individual phase runners for granular control
-export { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, };
+export { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, };

package/dist/workflow-runner/feature-workflow-runner.js

@@ -83,10 +83,12 @@ export function getAvailableExecutionModes() {
         'only_code_implementation',
         'only_functional_testing',
         'only_code_refine',
+        'only_code_review',
         'from_feature_analysis',
         'from_technical_design',
         'from_code_implementation',
         'from_functional_testing',
+        'from_code_review',
     ];
 }
 /**
@@ -106,10 +108,12 @@ export function getExecutionModeDescription(mode) {
         only_code_implementation: 'Execute only: code implementation',
         only_functional_testing: 'Execute only: functional testing',
         only_code_refine: 'Execute only: code refine (address PR review feedback and verify resolution)',
+        only_code_review: 'Execute only: code review (review PR code and create review comments)',
         from_feature_analysis: 'Execute from feature analysis to end: analysis → design → implementation → testing',
         from_technical_design: 'Execute from technical design to end: design → implementation → testing',
         from_code_implementation: 'Execute from code implementation to end: implementation → testing',
         from_functional_testing: 'Execute from functional testing to end: testing',
+        from_code_review: 'Execute from code review to end: code-review → code-refine → code-refine-verification',
     };
     return descriptions[mode] || 'Unknown execution mode';
 }

package/dist/workflow-runner/pipeline-runner.js

@@ -4,7 +4,7 @@
  * Uses functional programming principles
  */
 import { updateFeatureStatusForPhase } from '../api/features/index.js';
-import { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, } from './executors/phase-executor.js';
+import { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeReviewPhase, } from './executors/phase-executor.js';
 import { logPipelineStart, logPhaseResult, logPipelineComplete, shouldContinuePipeline, } from '../utils/pipeline-logger.js';
 import { handleTestFailuresWithRetry } from '../phases/functional-testing/test-retry-handler.js';
 import { handleCodeRefineWithRetry } from '../phases/code-refine/retry-handler.js';
@@ -53,6 +53,11 @@ export const runPipelineByMode = async (options, config, executionMode) => {
         // Code Refine
         case 'only_code_refine':
             return await runOnlyCodeRefine(options, config);
+        // Code Review
+        case 'only_code_review':
+            return await runOnlyCodeReview(options, config);
+        case 'from_code_review':
+            return await runFromCodeReview(options, config);
         default:
             throw new Error(`Unsupported execution mode: ${executionMode}`);
     }
@@ -283,3 +288,37 @@ const runOnlyCodeRefine = async (options, config) => {
     });
     return logPipelineComplete(results, verbose);
 };
+/**
+ * Run only code review phase (review PR and create review comments)
+ */
+const runOnlyCodeReview = async (options, config) => {
+    const { featureId, verbose } = options;
+    logPipelineStart(featureId, verbose);
+    const results = [];
+    // Code Review - analyze PR and create review comments
+    const reviewResult = await runCodeReviewPhase(options, config);
+    results.push(logPhaseResult(reviewResult, verbose));
+    return logPipelineComplete(results, verbose);
+};
+/**
+ * Run from code review to end (code-review → code-refine → code-refine-verification)
+ */
+const runFromCodeReview = async (options, config) => {
+    const { featureId, verbose } = options;
+    logPipelineStart(featureId, verbose);
+    const results = [];
+    // 1. Code Review - analyze PR and create review comments
+    const reviewResult = await runCodeReviewPhase(options, config);
+    results.push(logPhaseResult(reviewResult, verbose));
+    if (!shouldContinuePipeline(results)) {
+        return logPipelineComplete(results, verbose);
+    }
+    // 2. Code Refine with automatic retry for verification failures
+    await handleCodeRefineWithRetry({
+        options,
+        config,
+        results,
+        verbose,
+    });
+    return logPipelineComplete(results, verbose);
+};

package/package.json

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