edsger 0.41.1 → 0.41.2

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

@@ -0,0 +1,561 @@
+/**
+ * Code Refine Analyzer
+ * Processes GitHub PR review feedback and refines code accordingly
+ */
+import { query } from '@anthropic-ai/claude-code';
+import { logInfo, logError } from '../../utils/logger.js';
+import { execSync } from 'child_process';
+import { fetchCodeRefineContext, 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(refinePrompt) {
+    yield userMessage(refinePrompt);
+    await new Promise((res) => setTimeout(res, 10000));
+}
+/**
+ * Get current Git branch name
+ */
+const getCurrentBranch = () => {
+    try {
+        return execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
+    }
+    catch (error) {
+        throw new Error(`Failed to get current branch: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+/**
+ * Check if there are uncommitted changes in the working directory
+ */
+const hasUncommittedChanges = () => {
+    try {
+        const status = execSync('git status --porcelain', { encoding: 'utf-8' });
+        return status.trim().length > 0;
+    }
+    catch (error) {
+        throw new Error(`Failed to check git status: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+/**
+ * Get list of uncommitted files
+ */
+const getUncommittedFiles = () => {
+    try {
+        const status = execSync('git status --porcelain', { encoding: 'utf-8' });
+        return status
+            .trim()
+            .split('\n')
+            .filter((line) => line.length > 0)
+            .map((line) => line.trim());
+    }
+    catch (error) {
+        throw new Error(`Failed to get uncommitted files: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+/**
+ * Reset uncommitted changes in the working directory
+ */
+const resetUncommittedChanges = (verbose) => {
+    try {
+        if (verbose) {
+            logInfo(`🔄 Resetting uncommitted changes...`);
+        }
+        execSync('git reset --hard HEAD', { encoding: 'utf-8' });
+        execSync('git clean -fd', { encoding: 'utf-8' });
+        if (verbose) {
+            logInfo(`✅ Reset working directory to clean state`);
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to reset uncommitted changes: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+/**
+ * Switch to a specific Git branch
+ */
+const switchToBranch = (branch, verbose) => {
+    try {
+        if (verbose) {
+            logInfo(`🔄 Switching to branch ${branch}...`);
+        }
+        execSync(`git checkout ${branch}`, { encoding: 'utf-8' });
+        if (verbose) {
+            logInfo(`✅ Switched to ${branch} branch`);
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to switch to ${branch} branch: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+/**
+ * Pull latest changes from remote
+ */
+const pullLatestChanges = (verbose) => {
+    try {
+        // Check for uncommitted changes and reset if found
+        if (hasUncommittedChanges()) {
+            if (verbose) {
+                logInfo(`⚠️  Found uncommitted changes from previous attempt. Resetting to clean state...`);
+            }
+            resetUncommittedChanges(verbose);
+        }
+        if (verbose) {
+            logInfo(`📥 Pulling latest changes from remote...`);
+        }
+        execSync('git pull origin $(git branch --show-current) --rebase', {
+            encoding: 'utf-8',
+        });
+        if (verbose) {
+            logInfo(`✅ Successfully pulled latest changes`);
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to pull latest changes: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+/**
+ * Push changes to remote branch
+ */
+const pushChanges = (verbose) => {
+    try {
+        if (verbose) {
+            logInfo(`📤 Pushing changes to remote...`);
+        }
+        execSync('git push origin $(git branch --show-current)', {
+            encoding: 'utf-8',
+        });
+        if (verbose) {
+            logInfo(`✅ Successfully pushed changes`);
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to push changes: ${error instanceof Error ? error.message : String(error)}`);
+    }
+};
+/**
+ * Main code refine function
+ */
+export const refineCodeFromPRFeedback = async (options, config) => {
+    const { featureId, githubToken, verbose } = options;
+    if (verbose) {
+        logInfo(`Starting code refine for feature ID: ${featureId}`);
+    }
+    try {
+        // Fetch code refine context (PR reviews and comments)
+        if (verbose) {
+            logInfo('Fetching code refine context from GitHub PR...');
+        }
+        const context = await fetchCodeRefineContext(featureId, githubToken, verbose);
+        // Check if there are any reviews or comments to address
+        if (context.reviews.length === 0 && context.reviewComments.length === 0) {
+            if (verbose) {
+                logInfo('✅ No review comments or change requests found. Nothing to refine.');
+            }
+            return {
+                featureId,
+                status: 'success',
+                message: 'No review feedback to address',
+                summary: 'No change requests or review comments found on the PR',
+            };
+        }
+        if (verbose) {
+            logInfo(`📋 Found ${context.reviews.length} reviews and ${context.reviewComments.length} comments to address`);
+        }
+        // Fetch additional feedbacks for code-refine phase
+        let feedbacksInfo;
+        try {
+            const feedbacksContext = await getFeedbacksForPhase({ featureId, verbose }, 'code_refine');
+            if (feedbacksContext.feedbacks.length > 0) {
+                feedbacksInfo = formatFeedbacksForContext(feedbacksContext);
+                if (verbose) {
+                    logInfo(`Added ${feedbacksContext.feedbacks.length} human feedbacks to code refine context`);
+                }
+            }
+        }
+        catch (error) {
+            if (verbose) {
+                logInfo(`Note: Could not fetch feedbacks (${error instanceof Error ? error.message : String(error)})`);
+            }
+        }
+        // Get current branch and switch to dev/feature-id if needed
+        const currentBranch = getCurrentBranch();
+        const targetBranch = `dev/${featureId}`;
+        if (currentBranch !== targetBranch) {
+            if (verbose) {
+                logInfo(`Current branch is ${currentBranch}, switching to ${targetBranch}...`);
+            }
+            switchToBranch(targetBranch, verbose);
+        }
+        // Pull latest changes
+        pullLatestChanges(verbose);
+        // Create prompt for code refine
+        const systemPrompt = createSystemPrompt(config);
+        const refinePrompt = createCodeRefinePrompt(featureId, context, feedbacksInfo, options.verificationFailureContext);
+        let lastAssistantResponse = '';
+        let structuredRefineResult = null;
+        if (verbose) {
+            logInfo('Starting Claude Code query for code refine...');
+        }
+        // Use Claude Code SDK to refine the code
+        for await (const message of query({
+            prompt: prompt(refinePrompt),
+            options: {
+                appendSystemPrompt: systemPrompt,
+                model: config.claude.model || 'sonnet',
+                maxTurns: 2000,
+                permissionMode: 'bypassPermissions',
+            },
+        })) {
+            if (verbose) {
+                logInfo(`Received message type: ${message.type}`);
+            }
+            // Stream the code refine 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 (content.type === 'tool_use') {
+                        if (verbose) {
+                            console.log(`\n🛠️ ${content.name}: ${content.input.description || 'Running...'}`);
+                        }
+                    }
+                }
+            }
+            else if (message.type === 'result') {
+                if (message.subtype === 'success') {
+                    logInfo('\n🛠️ Code refine 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.refine_result) {
+                            structuredRefineResult = jsonResult.refine_result;
+                        }
+                        else {
+                            throw new Error('Invalid JSON structure');
+                        }
+                    }
+                    catch (error) {
+                        logError(`Failed to parse structured refine result: ${error}`);
+                        structuredRefineResult = parseCodeRefineResponse(message.result || lastAssistantResponse);
+                    }
+                }
+                else {
+                    logError(`\n⚠️  Code refine incomplete: ${message.subtype}`);
+                    if (message.subtype === 'error_max_turns') {
+                        logError('💡 Try simplifying the changes or reducing 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.refine_result) {
+                                    structuredRefineResult = jsonResult.refine_result;
+                                }
+                            }
+                            else {
+                                structuredRefineResult = parseCodeRefineResponse(lastAssistantResponse);
+                            }
+                        }
+                        catch (error) {
+                            logError(`Failed to parse assistant response: ${error}`);
+                        }
+                    }
+                }
+            }
+        }
+        // Push changes to remote
+        if (structuredRefineResult) {
+            // Verify all changes are committed before pushing
+            if (hasUncommittedChanges()) {
+                const uncommittedFiles = getUncommittedFiles();
+                const errorMsg = `Code refine completed but there are uncommitted changes. All changes must be committed before verification.
+
+Uncommitted files:
+${uncommittedFiles.join('\n')}
+
+Please ensure Claude Code commits all changes before completing the refine phase.`;
+                logError(`❌ ${errorMsg}`);
+                return {
+                    featureId,
+                    status: 'error',
+                    message: errorMsg,
+                };
+            }
+            if (verbose) {
+                logInfo('✅ All changes committed. Pushing to remote...');
+            }
+            try {
+                pushChanges(verbose);
+                const { summary, files_modified, commits_created } = structuredRefineResult;
+                if (verbose) {
+                    logInfo(`Code refine completed for feature: ${featureId}`);
+                    if (files_modified?.length > 0) {
+                        logInfo(`Files modified: ${files_modified.join(', ')}`);
+                    }
+                    if (commits_created) {
+                        logInfo(`Commits created: ${commits_created}`);
+                    }
+                }
+                return {
+                    featureId,
+                    status: 'success',
+                    message: 'Code successfully refined based on PR feedback',
+                    summary: summary || 'Code refined based on PR review feedback',
+                    filesModified: files_modified || [],
+                    commitsCreated: commits_created || 1,
+                };
+            }
+            catch (pushError) {
+                logError(`Failed to push changes: ${pushError}`);
+                return {
+                    featureId,
+                    status: 'error',
+                    message: `Code refined but failed to push: ${pushError}`,
+                };
+            }
+        }
+        else {
+            return {
+                featureId,
+                status: 'error',
+                message: 'Code refine failed or incomplete',
+            };
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Code refine failed: ${errorMessage}`);
+        return {
+            featureId,
+            status: 'error',
+            message: `Code refine failed: ${errorMessage}`,
+        };
+    }
+};
+function createSystemPrompt(_config) {
+    return `You are an expert software engineer specializing in addressing code review feedback. Your goal is to carefully analyze review comments and refine the code to address all concerns raised by human reviewers.
+
+**Your Role**: Refine code based on PR review feedback while maintaining code quality and functionality.
+
+**Available Tools**:
+- Bash: Run commands, tests, and git operations
+- Glob: Find files and understand project structure
+- Read: Examine existing code and files
+- Edit: Modify existing files to address feedback
+- Write: Create new files if necessary
+- TodoWrite: Track code refine tasks (use proactively)
+
+**Code Refine Process**:
+1. **Analyze Feedback**: Carefully study all review comments and change requests
+2. **Understand Context**: Review the code, technical design, and related files
+3. **Plan Changes**: Create a systematic plan to address each review comment
+4. **Refine Code**: Make targeted, thoughtful changes that address the feedback
+5. **Test Changes**: Ensure your changes work and don't break functionality
+6. **Commit Changes**: Create clear, descriptive commits for your refinements
+7. **Final Check**: Before finishing, run \`git status\` and commit any remaining uncommitted changes
+8. **Document**: Explain what changes were made and why
+
+**Important Guidelines**:
+- Address ALL review comments and change requests
+- Maintain code quality and follow best practices
+- Preserve existing functionality
+- Write clear commit messages that reference the feedback
+- Test your changes thoroughly
+- Be respectful of the reviewer's time and expertise
+
+**CRITICAL - Commit Requirements**:
+- You MUST commit ALL your changes using git before finishing
+- DO NOT leave any uncommitted changes in the working directory
+- Verification will fail if there are uncommitted changes
+- Use clear, descriptive commit messages that explain what feedback was addressed
+
+**CRITICAL - Result Format**:
+You MUST end your response with a JSON object containing the code refine results in this EXACT format:
+
+\`\`\`json
+{
+  "refine_result": {
+    "feature_id": "FEATURE_ID_PLACEHOLDER",
+    "summary": "Brief description of changes made",
+    "files_modified": ["file1.ts", "file2.tsx"],
+    "commits_created": 1,
+    "feedback_addressed": [
+      {
+        "comment_id": "Comment reference or ID",
+        "issue": "Description of the reviewer's concern",
+        "resolution": "Description of how it was addressed",
+        "files": ["path/to/file.ts"]
+      }
+    ]
+  }
+}
+\`\`\`
+
+Focus on systematic code refinement based on the provided PR review feedback.`;
+}
+function createCodeRefinePrompt(featureId, context, feedbacksInfo, verificationFailureContext) {
+    let contextInfo = formatContextForPrompt(context);
+    if (feedbacksInfo) {
+        contextInfo = contextInfo + '\n\n' + feedbacksInfo;
+    }
+    // Add verification failure context if this is a retry
+    let verificationSection = '';
+    if (verificationFailureContext) {
+        verificationSection = `
+
+## ⚠️ PREVIOUS ATTEMPT FAILED VERIFICATION (Attempt ${verificationFailureContext.attempt})
+
+Your previous code refine attempt did NOT successfully address all the review feedback.
+The verification phase found the following unresolved issues:
+
+### Verification Failure Summary
+${verificationFailureContext.suggestions.map((s) => `- ${s}`).join('\n')}
+
+### Unresolved Comments Still Needing Attention
+${verificationFailureContext.unresolvedCommentDetails
+            .map((detail, idx) => `${idx + 1}. **${detail.file}${detail.line ? `:${detail.line}` : ''}** by @${detail.author}
+   Comment: ${detail.body}
+   **Failure Reason**: ${detail.failureReason}
+   URL: ${detail.url}`)
+            .join('\n\n')}
+
+${verificationFailureContext.unresolvedReviewDetails &&
+            verificationFailureContext.unresolvedReviewDetails.length > 0
+            ? `
+### Unresolved Reviews Still Requesting Changes
+${verificationFailureContext.unresolvedReviewDetails
+                .map((review, idx) => `${idx + 1}. Review by @${review.author} (${review.state})
+   ${review.body || 'No review body provided'}`)
+                .join('\n\n')}
+`
+            : ''}
+
+**CRITICAL**: You MUST address all the above issues in this iteration. Pay special attention to:
+1. Read each unresolved comment carefully and understand what change is being requested
+2. Locate the exact file and line mentioned
+3. Make the specific changes requested by the reviewer
+4. Test your changes to ensure they work correctly
+5. Do not skip or overlook any comments - address ALL of them
+`;
+    }
+    return `Refine code based on PR review feedback for feature: ${featureId}
+${verificationFailureContext ? '\n🔄 **This is a RETRY after verification failure**\n' : ''}
+${contextInfo}
+${verificationSection}
+
+## Code Refine Instructions
+
+Follow this systematic approach:
+
+1. **Analyze All Feedback**: Study all review comments and change requests above:
+   ${verificationFailureContext ? '   - **FOCUS ON THE UNRESOLVED COMMENTS listed in the verification failure section**' : ''}
+   - What specific concerns were raised?
+   - Which files and code sections need changes?
+   - What are the underlying issues?
+   - Are there any patterns in the feedback?
+
+2. **Examine Current Code**: Use Read and Glob tools to:
+   - Understand the current implementation
+   - Identify the code sections mentioned in reviews
+   - Review related files and dependencies
+   - Understand the broader context
+
+3. **Plan Your Changes**: Create a systematic plan:
+   - Address each review comment one by one
+   - Prioritize critical feedback
+   - Consider how changes relate to each other
+   - Ensure changes align with technical design
+
+4. **Refine the Code**: Make targeted improvements:
+   - Address each reviewer's concern thoughtfully
+   - Follow code quality best practices
+   - Maintain consistency with existing patterns
+   - Make code more maintainable and readable
+
+5. **Test Your Changes**: Verify everything works:
+   - Run relevant tests
+   - Check that functionality still works
+   - Ensure no regressions were introduced
+
+6. **Commit Your Changes**: Create clear commits:
+   - Write descriptive commit messages
+   - Reference the feedback being addressed
+   - Group related changes logically
+
+7. **Final Verification** - BEFORE generating the JSON result:
+   - Run \`git status\` to check for any uncommitted changes
+   - If there are ANY uncommitted files, commit them immediately
+   - Ensure working directory is completely clean (no output from \`git status --porcelain\`)
+   - Only after confirming everything is committed, generate the final JSON result
+
+## Important Notes
+- Be thorough - address ALL review comments
+- Be respectful - reviewers are trying to help improve the code
+- Be systematic - don't rush through the feedback
+- Test your changes - ensure nothing breaks
+- Communicate clearly in commit messages
+- **CRITICAL**: You MUST commit all changes before finishing - no uncommitted files allowed
+
+## ⚠️ CRITICAL - Pre-Completion Checklist
+BEFORE you generate the final JSON result, you MUST complete this checklist:
+
+1. **Run git status check**:
+   \`\`\`bash
+   git status --porcelain
+   \`\`\`
+   - If this command returns ANY output, you have uncommitted changes
+
+2. **If uncommitted changes exist**:
+   - Review what files are uncommitted
+   - Stage and commit ALL remaining changes with appropriate commit messages
+   - Run \`git status --porcelain\` again to verify it returns empty output
+
+3. **Only generate JSON result when**:
+   - \`git status --porcelain\` returns completely empty output
+   - All tests pass
+   - All review feedback has been addressed
+
+**FAILURE TO COMMIT ALL CHANGES WILL CAUSE THE PIPELINE TO FAIL**
+
+You are currently on the \`dev/${featureId}\` branch. Make your changes, commit them, and they will be pushed to the remote repository.
+
+Begin by analyzing all the review feedback and creating a plan to address each comment.`;
+}
+function parseCodeRefineResponse(response) {
+    const summaryMatch = response.match(/## Refine Summary\n([\s\S]*?)(?=\n##|\n\n|$)/);
+    const summary = summaryMatch
+        ? summaryMatch[1].trim()
+        : 'Code refined based on PR feedback';
+    const filesMatch = response.match(/## Files Modified\n([\s\S]*?)(?=\n##|\n\n|$)/);
+    let files_modified = [];
+    if (filesMatch) {
+        files_modified = filesMatch[1]
+            .split('\n')
+            .filter((line) => line.trim().startsWith('-'))
+            .map((line) => line.replace(/^-\s*/, '').trim());
+    }
+    return {
+        summary,
+        files_modified,
+        commits_created: 1,
+        feedback_addressed: [],
+    };
+}

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

@@ -0,0 +1,94 @@
+/**
+ * Context fetcher for code refine phase
+ * Fetches GitHub PR review comments and reviews using GraphQL API
+ */
+import { Octokit } from '@octokit/rest';
+export interface PRReviewComment {
+    id: number;
+    body: string;
+    path: string | null;
+    line: number | null;
+    user: {
+        login: string;
+    };
+    created_at: string;
+    position: number | null;
+    original_position: number | null;
+    diff_hunk: string | null;
+    in_reply_to_id?: number;
+    url?: string;
+}
+export interface PRReview {
+    id: number;
+    user: {
+        login: string;
+    };
+    body: string | null;
+    state: string;
+    submitted_at: string | null;
+}
+export interface PRReviewThread {
+    id: string;
+    isResolved: boolean;
+    isOutdated: boolean;
+    line: number | null;
+    originalLine: number | null;
+    startLine: number | null;
+    originalStartLine: number | null;
+    diffSide: string;
+    comments: PRReviewComment[];
+}
+export interface CodeRefineContext {
+    featureId: string;
+    featureName: string;
+    featureDescription: string | null;
+    pullRequestUrl: string;
+    pullRequestNumber: number;
+    owner: string;
+    repo: string;
+    reviews: PRReview[];
+    reviewComments: PRReviewComment[];
+    reviewThreads?: PRReviewThread[];
+    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 reviews that request changes
+ */
+export declare function fetchPRReviews(octokit: Octokit, owner: string, repo: string, prNumber: number, verbose?: boolean): Promise<PRReview[]>;
+/**
+ * Fetch PR review comments
+ */
+export declare function fetchPRReviewComments(octokit: Octokit, owner: string, repo: string, prNumber: number, verbose?: boolean): Promise<PRReviewComment[]>;
+/**
+ * Fetch PR data using GraphQL API including review threads and reviews
+ */
+export declare function fetchPRDataGraphQL(octokit: Octokit, owner: string, repo: string, prNumber: number, verbose?: boolean): Promise<{
+    reviewThreads: PRReviewThread[];
+    reviews: PRReview[];
+}>;
+/**
+ * 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 refine context
+ */
+export declare function fetchCodeRefineContext(featureId: string, githubToken: string, verbose?: boolean): Promise<CodeRefineContext>;
+/**
+ * Format code refine context for prompt
+ */
+export declare function formatContextForPrompt(context: CodeRefineContext): string;