edsger 0.2.13 → 0.3.0

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

@@ -0,0 +1,25 @@
+/**
+ * Code Refine Analyzer
+ * Processes GitHub PR review feedback and refines code accordingly
+ */
+import { EdsgerConfig } from '../../types/index.js';
+export interface CodeRefineOptions {
+    featureId: string;
+    mcpServerUrl: string;
+    mcpToken: string;
+    githubToken: string;
+    verbose?: boolean;
+}
+export interface CodeRefineResult {
+    featureId: string;
+    status: 'success' | 'error';
+    message: string;
+    summary?: string;
+    filesModified?: string[];
+    commitsCreated?: number;
+}
+/**
+ * Main code refine function
+ */
+export declare const refineCodeFromPRFeedback: (options: CodeRefineOptions, config: EdsgerConfig) => Promise<CodeRefineResult>;
+export declare function checkCodeRefineRequirements(): Promise<boolean>;

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

@@ -0,0 +1,425 @@
+/**
+ * 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)}`);
+    }
+};
+/**
+ * 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 {
+        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, mcpServerUrl, mcpToken, githubToken, verbose } = options;
+    if (verbose) {
+        logInfo(`Starting code refine for feature ID: ${featureId}`);
+        logInfo(`Using MCP server: ${mcpServerUrl}`);
+    }
+    try {
+        // Fetch code refine context (PR reviews and comments)
+        if (verbose) {
+            logInfo('Fetching code refine context from GitHub PR...');
+        }
+        const context = await fetchCodeRefineContext(mcpServerUrl, mcpToken, 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, mcpServerUrl, mcpToken, 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);
+        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) {
+            if (verbose) {
+                logInfo('📤 Pushing refined code 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. **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 - 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) {
+    let contextInfo = formatContextForPrompt(context);
+    if (feedbacksInfo) {
+        contextInfo = contextInfo + '\n\n' + feedbacksInfo;
+    }
+    return `Refine code based on PR review feedback for feature: ${featureId}
+
+${contextInfo}
+
+## Code Refine Instructions
+
+Follow this systematic approach:
+
+1. **Analyze All Feedback**: Study all review comments and change requests above:
+   - 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
+
+## 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
+
+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: [],
+    };
+}
+export function checkCodeRefineRequirements() {
+    try {
+        require.resolve('@anthropic-ai/claude-code');
+        return Promise.resolve(true);
+    }
+    catch {
+        return Promise.resolve(false);
+    }
+}

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

@@ -0,0 +1,78 @@
+/**
+ * Context fetcher for code refine phase
+ * Fetches GitHub PR review comments that request changes
+ */
+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;
+}
+export interface PRReview {
+    id: number;
+    user: {
+        login: string;
+    };
+    body: string | null;
+    state: string;
+    submitted_at: string | null;
+}
+export interface CodeRefineContext {
+    featureId: string;
+    featureName: string;
+    featureDescription: string | null;
+    pullRequestUrl: string;
+    pullRequestNumber: number;
+    owner: string;
+    repo: string;
+    reviews: PRReview[];
+    reviewComments: PRReviewComment[];
+    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 technical design via MCP
+ */
+export declare function fetchTechnicalDesign(mcpServerUrl: string, mcpToken: string, featureId: string, verbose?: boolean): Promise<string | undefined>;
+/**
+ * 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 refine context
+ */
+export declare function fetchCodeRefineContext(mcpServerUrl: string, mcpToken: string, featureId: string, githubToken: string, verbose?: boolean): Promise<CodeRefineContext>;
+/**
+ * Format code refine context for prompt
+ */
+export declare function formatContextForPrompt(context: CodeRefineContext): string;