edsger 0.41.1 → 0.41.2

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

@@ -0,0 +1,629 @@
+import { query } from '@anthropic-ai/claude-code';
+import { logInfo, logError } from '../../utils/logger.js';
+import { formatChecklistsForContext, } from '../../services/checklist.js';
+import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
+import { fetchCodeImplementationContext, formatContextForPrompt, } from './context-fetcher.js';
+import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
+import { performVerificationCycle, buildImplementationResult, buildVerificationFailureResult, buildNoResultsError, } from './analyzer-helpers.js';
+function userMessage(content) {
+    return {
+        type: 'user',
+        message: { role: 'user', content: content },
+    };
+}
+async function* prompt(implementationPrompt) {
+    yield userMessage(implementationPrompt);
+    await new Promise((res) => setTimeout(res, 10000));
+}
+export const implementFeatureCode = async (options, config, checklistContext) => {
+    const { featureId, verbose, baseBranch = 'main' } = options;
+    if (verbose) {
+        logInfo(`Starting code implementation for feature ID: ${featureId}`);
+        logInfo(`Base branch: ${baseBranch}`);
+    }
+    try {
+        // Fetch all required context information via MCP endpoints
+        if (verbose) {
+            logInfo('Fetching code implementation context via MCP endpoints...');
+        }
+        const context = await fetchCodeImplementationContext(featureId, verbose);
+        // Fetch feedbacks for code implementation phase
+        let feedbacksInfo;
+        try {
+            const feedbacksContext = await getFeedbacksForPhase({ featureId, verbose }, 'code_implementation');
+            if (feedbacksContext.feedbacks.length > 0) {
+                feedbacksInfo = formatFeedbacksForContext(feedbacksContext);
+                if (verbose) {
+                    logInfo(`Added ${feedbacksContext.feedbacks.length} human feedbacks to implementation context`);
+                }
+            }
+        }
+        catch (error) {
+            // Don't fail if feedbacks fetch fails - just log and continue
+            if (verbose) {
+                logInfo(`Note: Could not fetch feedbacks (${error instanceof Error ? error.message : String(error)})`);
+            }
+        }
+        const systemPrompt = createSystemPrompt(config, baseBranch, featureId);
+        const initialImplementationPrompt = createImplementationPromptWithContext(featureId, context, baseBranch, checklistContext, verbose, feedbacksInfo);
+        const maxIterations = options.maxVerificationIterations || 10;
+        let currentIteration = 0;
+        let currentPrompt = initialImplementationPrompt;
+        let structuredImplementationResult = null;
+        let verificationResult = null;
+        const branchName = `dev/${featureId}`;
+        if (verbose) {
+            logInfo('Starting Claude Code query with pre-fetched information...');
+        }
+        // Iterative improvement loop: implement → verify → improve → re-implement
+        while (currentIteration < maxIterations) {
+            currentIteration++;
+            if (verbose && currentIteration > 1) {
+                logInfo(`\n🔄 Iteration ${currentIteration}/${maxIterations}: Improving implementation based on code review feedback...`);
+            }
+            // Log iteration start (for iterations after the first)
+            if (currentIteration > 1) {
+                await logFeaturePhaseEvent({
+                    featureId,
+                    eventType: 'phase_started',
+                    phase: 'code_implementation',
+                    result: 'info',
+                    metadata: {
+                        iteration: currentIteration,
+                        max_iterations: maxIterations,
+                        re_implementation: true,
+                        timestamp: new Date().toISOString(),
+                    },
+                }, verbose);
+            }
+            let lastAssistantResponse = '';
+            let newImplementationResult = null;
+            // DEBUG: Log checklist context before query
+            console.log('=== DEBUG: Checklist Context Before Claude Query ===');
+            console.log('Has checklistContext:', !!checklistContext);
+            if (checklistContext) {
+                console.log('Number of checklists:', checklistContext.checklists.length);
+                const totalItems = checklistContext.checklists.reduce((sum, checklist) => sum + (checklist.items?.length || 0), 0);
+                console.log('Total checklist items:', totalItems);
+            }
+            console.log('Implementation prompt includes checklist:', currentPrompt.includes('checklist'));
+            console.log('System prompt includes checklist:', systemPrompt.includes('checklist'));
+            // Execute implementation query
+            for await (const message of query({
+                prompt: prompt(currentPrompt),
+                options: {
+                    appendSystemPrompt: systemPrompt,
+                    model: config.claude.model || 'sonnet',
+                    maxTurns: 3000,
+                    permissionMode: 'bypassPermissions',
+                },
+            })) {
+                if (verbose) {
+                    logInfo(`Received message type: ${message.type}`);
+                }
+                // Stream the implementation 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...'}`);
+                            }
+                        }
+                    }
+                }
+                if (message.type === 'result') {
+                    if (message.subtype === 'success') {
+                        logInfo('\n💻 Code implementation completed, parsing results...');
+                        try {
+                            // Try to extract JSON from markdown code block or parse directly
+                            const responseText = message.result || lastAssistantResponse;
+                            let jsonResult = null;
+                            // DEBUG: Log response text details and checklist content
+                            console.log('=== DEBUG: Code Implementation Response Analysis ===');
+                            console.log('message.result exists:', !!message.result);
+                            console.log('lastAssistantResponse exists:', !!lastAssistantResponse);
+                            console.log('responseText length:', responseText.length);
+                            console.log('responseText first 200 chars:', JSON.stringify(responseText.substring(0, 200)));
+                            console.log('responseText last 200 chars:', JSON.stringify(responseText.substring(responseText.length - 200)));
+                            console.log('Contains ```json:', responseText.includes('```json'));
+                            console.log('Contains implementation_result:', responseText.includes('"implementation_result"'));
+                            console.log('=== DEBUG: Checklist Content in Response ===');
+                            console.log('Contains "checklist":', responseText.toLowerCase().includes('checklist'));
+                            console.log('Contains "checklist_item_results":', responseText.includes('checklist_item_results'));
+                            console.log('Contains checklist_item_id:', responseText.includes('checklist_item_id'));
+                            console.log('Contains is_passed:', responseText.includes('is_passed'));
+                            // Count checklist-related occurrences
+                            const checklistMatches = responseText.match(/checklist/gi) || [];
+                            const checklistItemMatches = responseText.match(/checklist_item/gi) || [];
+                            console.log('Total "checklist" mentions:', checklistMatches.length);
+                            console.log('Total "checklist_item" mentions:', checklistItemMatches.length);
+                            // First try to extract JSON from markdown code block
+                            const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+                            console.log('=== DEBUG: Markdown Block Match ===');
+                            console.log('jsonBlockMatch found:', !!jsonBlockMatch);
+                            if (jsonBlockMatch) {
+                                console.log('Matched JSON length:', jsonBlockMatch[1].length);
+                                console.log('Matched JSON first 100 chars:', JSON.stringify(jsonBlockMatch[1].substring(0, 100)));
+                                jsonResult = JSON.parse(jsonBlockMatch[1]);
+                            }
+                            else {
+                                console.log('=== DEBUG: Trying direct JSON parse ===');
+                                // Try to parse the entire response as JSON
+                                jsonResult = JSON.parse(responseText);
+                            }
+                            console.log('=== DEBUG: Final Result Processing ===');
+                            console.log('jsonResult exists:', !!jsonResult);
+                            console.log('jsonResult has implementation_result:', !!(jsonResult && jsonResult.implementation_result));
+                            if (jsonResult && jsonResult.implementation_result) {
+                                const implResult = jsonResult.implementation_result;
+                                console.log('=== DEBUG: Implementation Result Structure ===');
+                                console.log('Keys in implementation_result:', Object.keys(implResult));
+                                console.log('Has checklist_item_results field:', 'checklist_item_results' in implResult);
+                                console.log('checklist_item_results value type:', typeof implResult.checklist_item_results);
+                                console.log('checklist_item_results is array:', Array.isArray(implResult.checklist_item_results));
+                                if (implResult.checklist_item_results) {
+                                    console.log('checklist_item_results length:', implResult.checklist_item_results.length);
+                                    if (implResult.checklist_item_results.length > 0) {
+                                        console.log('First checklist item keys:', Object.keys(implResult.checklist_item_results[0]));
+                                        console.log('First checklist item sample:', JSON.stringify(implResult.checklist_item_results[0], null, 2));
+                                    }
+                                }
+                                else {
+                                    console.log('checklist_item_results is null/undefined/empty');
+                                }
+                                newImplementationResult = jsonResult.implementation_result;
+                                console.log('Successfully extracted implementation_result');
+                            }
+                            else {
+                                console.log('ERROR: Invalid JSON structure - missing implementation_result');
+                                throw new Error('Invalid JSON structure');
+                            }
+                        }
+                        catch (error) {
+                            console.log('=== DEBUG: JSON Parsing Failed ===');
+                            console.log('Error type:', error instanceof SyntaxError
+                                ? 'SyntaxError'
+                                : error instanceof Error
+                                    ? error.constructor.name
+                                    : 'Unknown');
+                            console.log('Error message:', error instanceof Error ? error.message : String(error));
+                            logError(`Failed to parse structured implementation result: ${error}`);
+                            console.log('=== DEBUG: Using Fallback Parsing ===');
+                            // Fallback parsing
+                            const parsedResult = parseImplementationResponse(message.result || lastAssistantResponse, featureId);
+                            console.log('Fallback parsed result:', {
+                                branchName: parsedResult.branchName,
+                                filesModifiedCount: parsedResult.filesModified?.length || 0,
+                                hasSummary: !!parsedResult.summary,
+                                commitHash: parsedResult.commitHash,
+                            });
+                            newImplementationResult = {
+                                branch_name: parsedResult.branchName,
+                                files_modified: parsedResult.filesModified,
+                                commit_hash: parsedResult.commitHash,
+                                summary: parsedResult.summary || 'Implementation completed',
+                                tests_passed: true,
+                                pre_commit_passed: true,
+                                checklist_item_results: parsedResult.checklist_item_results || [],
+                            };
+                        }
+                    }
+                    else {
+                        logError(`\n⚠️  Code implementation incomplete: ${message.subtype}`);
+                        if (message.subtype === 'error_max_turns') {
+                            logError('💡 Try breaking down the feature into smaller tasks');
+                        }
+                        // Try to parse results from the last assistant response
+                        if (lastAssistantResponse) {
+                            console.log('=== DEBUG: Fallback for incomplete result ===');
+                            console.log('message.subtype:', message.subtype);
+                            try {
+                                const responseText = lastAssistantResponse;
+                                let jsonResult = null;
+                                console.log('lastAssistantResponse length:', responseText.length);
+                                console.log('lastAssistantResponse first 200 chars:', JSON.stringify(responseText.substring(0, 200)));
+                                const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+                                console.log('jsonBlockMatch in fallback found:', !!jsonBlockMatch);
+                                if (jsonBlockMatch) {
+                                    jsonResult = JSON.parse(jsonBlockMatch[1]);
+                                    if (jsonResult && jsonResult.implementation_result) {
+                                        newImplementationResult = jsonResult.implementation_result;
+                                    }
+                                }
+                            }
+                            catch (error) {
+                                logError(`Failed to parse assistant response: ${error}`);
+                            }
+                        }
+                    }
+                }
+            }
+            // Check if implementation produced results
+            if (!newImplementationResult) {
+                if (verbose) {
+                    logError('⚠️  Implementation failed in this iteration');
+                }
+                break;
+            }
+            // Update with new implementation result
+            structuredImplementationResult = newImplementationResult;
+            // Log implementation completion for this iteration
+            await logFeaturePhaseEvent({
+                featureId,
+                eventType: 'phase_completed',
+                phase: 'code_implementation',
+                result: 'success',
+                metadata: {
+                    iteration: currentIteration,
+                    max_iterations: maxIterations,
+                    implementation_step: 'completed',
+                    branch_name: structuredImplementationResult.branch_name,
+                    files_modified: structuredImplementationResult.files_modified || [],
+                    commit_hash: structuredImplementationResult.commit_hash || '',
+                    timestamp: new Date().toISOString(),
+                },
+            }, verbose);
+            // Push code to remote after commit
+            if (verbose) {
+                logInfo(`📤 Pushing code to remote repository...`);
+            }
+            const pushResult = await pushToRemote(structuredImplementationResult.branch_name || branchName, verbose);
+            if (!pushResult.success && verbose) {
+                logError(`⚠️  Failed to push to remote: ${pushResult.error}`);
+                logInfo('   Code is committed locally and will be reviewed. Manual push may be needed.');
+            }
+            else if (verbose) {
+                logInfo('✅ Code pushed to remote successfully');
+            }
+            // Perform verification cycle
+            const verificationCycle = await performVerificationCycle(structuredImplementationResult.branch_name || branchName, baseBranch, checklistContext || null, featureId, context.feature.name, context.feature.description, config, currentIteration, maxIterations, verbose);
+            verificationResult = verificationCycle.verificationResult;
+            // If verification passed, exit
+            if (verificationCycle.passed) {
+                if (verbose) {
+                    logInfo('✅ Verification passed! Code implementation complete.');
+                }
+                break;
+            }
+            // Verification failed
+            if (currentIteration < maxIterations && verificationCycle.nextPrompt) {
+                // We have more iterations - retry with improvement prompt
+                if (verbose) {
+                    logInfo(`🔄 Will improve implementation in next iteration (${maxIterations - currentIteration} attempts remaining)`);
+                }
+                currentPrompt = verificationCycle.nextPrompt;
+            }
+            else {
+                // Max iterations reached or no next prompt - exit loop
+                if (verbose) {
+                    logInfo('⚠️  Max iterations reached. Last implementation committed.');
+                }
+                break;
+            }
+        }
+        // Handle results
+        if (!structuredImplementationResult) {
+            return buildNoResultsError(featureId, branchName);
+        }
+        const { branch_name, files_modified, commit_hash, summary, checklist_results, checklist_item_results, } = structuredImplementationResult;
+        // Check if verification failed after all iterations
+        if (verificationResult &&
+            verificationResult.rejected_count > 0 &&
+            checklistContext &&
+            checklistContext.checklists.length > 0) {
+            logError(`❌ Final result: Code verification FAILED after ${currentIteration} iterations`);
+            logError(`   Code committed for manual review`);
+            return buildVerificationFailureResult(featureId, branch_name || branchName, summary || 'Implementation completed with verification failures', files_modified || [], commit_hash || '', verificationResult, currentIteration);
+        }
+        // Return success result
+        return buildImplementationResult(featureId, branch_name || branchName, summary || 'Implementation completed successfully', files_modified || [], commit_hash || '', currentIteration, checklist_results, checklist_item_results);
+    }
+    catch (error) {
+        logError(`Code implementation failed: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            featureId,
+            branchName: `dev/${featureId}`,
+            implementationSummary: null,
+            status: 'error',
+            message: `Implementation failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+};
+const createSystemPrompt = (_config, baseBranch, mcpServerUrl, mcpToken, featureId) => {
+    let mcpInstructions = '';
+    if (mcpServerUrl && mcpToken && featureId) {
+        mcpInstructions = `
+
+**MANDATORY Checklist Compliance**:
+If you are provided with checklists in the context, you MUST satisfy ALL of them during your implementation work. Checklists are mandatory requirements that define quality standards and cannot be ignored or skipped.
+
+- Review each checklist carefully and ensure your implementation addresses every requirement
+- You MUST include ALL provided checklist item IDs in the "checklist_item_results" field of your JSON response
+- CRITICAL: Use the exact UUID from the "ID:" field in each checklist ITEM, NOT the item title or description
+- Set "is_passed": true for each checklist item you have completed successfully
+- Provide appropriate "value" based on the item type (boolean: true/false, text: descriptive text, number: numeric value)
+- If you cannot satisfy a checklist item requirement, set "is_passed": false and explain why in the "notes" field
+- The system will validate that all checklists have been addressed - missing checklists will cause the pipeline to fail
+
+CRITICAL: Checklists are not optional suggestions - they are mandatory quality gates that must be satisfied.`;
+    }
+    return `You are an expert full-stack developer implementing features based on specifications. Your task is to implement complete, production-ready code based on feature requirements, user stories, test cases, and technical design.
+
+**Your Role**: Implement complete, working features based on provided specifications and requirements.
+
+**Available Tools**:
+- Bash: Git operations, running commands, tests, and builds
+- Glob: Find files and understand project structure
+- Read: Examine existing code, configuration, and documentation files
+- Edit: Modify existing files
+- Write: Create new files
+- TodoWrite: Track implementation tasks (use proactively)${mcpInstructions}
+
+**CRITICAL WORKFLOW - YOU MUST FOLLOW THESE STEPS IN ORDER**:
+
+1. **GIT PULL REBASE**: First, ensure main branch is up to date with remote:
+   - git checkout ${baseBranch}
+   - git pull origin ${baseBranch} --rebase
+2. **CREATE BRANCH**: Create a new feature branch from ${baseBranch}
+3. **ANALYZE CODEBASE**: Use Glob and Read to understand the existing code structure
+4. **IMPLEMENT CODE**: Write the actual implementation using Edit/Write tools
+5. **FIX ISSUES**: Address any lint or build failures
+6. **COMMIT**: Commit your changes with a descriptive message
+7. **HANDLE PRE-COMMIT**: This project has strict pre-commit hooks - handle them properly:
+   - If lint-staged fails: Fix formatting and linting issues, then retry commit
+   - If AI code review fails: Either fix code quality issues or use SKIP_REVIEW=1
+   - If other issues persist: Only use --no-verify as last resort after confirming code quality
+
+**Important Rules**:
+1. **Git Workflow**:
+   - ALWAYS pull latest changes from main before creating branch: git pull origin ${baseBranch} --rebase
+   - ALWAYS create a new branch before making changes: git checkout -b dev/<feature-id>
+   - Use descriptive commit messages that explain what and why
+   - Handle pre-commit checks properly: fix issues first, use workarounds only when necessary
+
+2. **Code Quality**:
+   - Follow existing code patterns and conventions in the repository
+   - Ensure proper TypeScript types and interfaces
+   - Add appropriate error handling and validation
+   - Write clean, maintainable code with proper comments where necessary
+
+3. **Pre-commit Handling**:
+   - This project has strict pre-commit hooks including lint-staged, linting, and AI code review
+   - When pre-commit hooks fail, READ the error messages carefully
+   - Fix ALL issues reported (lint errors, type errors, formatting, code quality)
+   - Re-run the commit after fixing issues
+   - If you encounter persistent issues with AI code review or non-critical pre-commit failures:
+     * First attempt to fix the actual issues
+     * Only use --no-verify as a last resort if you are 100% confident your code is correct
+     * When using --no-verify, add a comment explaining why it was necessary
+   - IMPORTANT: AI code review can be skipped with SKIP_REVIEW=1 environment variable if needed
+
+5. **File Modification**:
+   - Prefer modifying existing files over creating new ones
+   - Follow the existing file structure and naming conventions
+   - Use the appropriate tools (Edit for existing files, Write for new files)
+
+**CRITICAL - Result Format**:
+You MUST end your response with a JSON object containing the implementation results in this EXACT format:
+
+\`\`\`json
+{
+  "implementation_result": {
+    "feature_id": "FEATURE_ID_PLACEHOLDER",
+    "branch_name": "dev/FEATURE_ID",
+    "files_modified": ["file1.ts", "file2.tsx"],
+    "commit_hash": "abc123...",
+    "summary": "Brief description of what was implemented",
+    "tests_passed": true,
+    "pre_commit_passed": true,
+    "checklist_item_results": [
+      {
+        "checklist_item_id": "EXACT_CHECKLIST_ITEM_UUID_FROM_ID_FIELD",
+        "is_passed": true,
+        "value": "Result value based on item type (boolean, text, number, etc.)",
+        "notes": "Optional notes about this specific checklist item"
+      }
+    ]
+  }
+}
+\`\`\`
+
+MANDATORY: If checklists are provided in the context, you MUST include checklist_item_results for ALL checklist items. Every checklist item ID must be addressed - either passed or with explanation in notes why it cannot be satisfied. Missing any checklist item will cause the pipeline to fail.
+
+IMPORTANT: In the checklist context, look for lines that say "ID: [UUID]" in the items list - use these exact UUIDs as checklist_item_id values. Do NOT use the item title or description as the checklist_item_id.
+
+Remember: Quality over speed. It's better to implement correctly than to rush and create bugs.`;
+};
+const createImplementationPromptWithContext = (featureId, context, baseBranch, checklistContext, verbose, feedbacksInfo) => {
+    const contextInfo = formatContextForPrompt(context);
+    let finalContextInfo = contextInfo;
+    // Add feedbacks context to the implementation prompt
+    if (feedbacksInfo) {
+        finalContextInfo = finalContextInfo + '\n\n' + feedbacksInfo;
+    }
+    // Add checklist context to the implementation prompt
+    let checklistInstructions = '';
+    if (checklistContext && checklistContext.checklists.length > 0) {
+        const checklistInfo = formatChecklistsForContext(checklistContext);
+        finalContextInfo = finalContextInfo + '\n\n' + checklistInfo;
+        // DEBUG: Log checklist context details
+        console.log('=== DEBUG: Checklist Context for Code Implementation ===');
+        console.log('Number of checklists:', checklistContext.checklists.length);
+        console.log('Checklist info length:', checklistInfo.length);
+        console.log('Checklist info preview:', checklistInfo.substring(0, 300));
+        checklistContext.checklists.forEach((checklist, index) => {
+            console.log(`Checklist ${index + 1}:`, {
+                id: checklist.id,
+                name: checklist.name,
+                phase: checklist.phase,
+                role: checklist.role,
+                itemCount: checklist.items?.length || 0,
+            });
+            if (checklist.items) {
+                checklist.items.forEach((item, itemIndex) => {
+                    console.log(`  Item ${itemIndex + 1}:`, {
+                        id: item.id,
+                        title: item.title?.substring(0, 50) || 'No title',
+                        description: item.description?.substring(0, 50) || 'No description',
+                    });
+                });
+            }
+        });
+        // Add specific instructions for creating checklist results
+        checklistInstructions = `
+
+## MANDATORY Checklist Compliance
+
+**CRITICAL**: You MUST address ALL checklists provided in the context above. Checklists are mandatory quality requirements that cannot be ignored.
+
+- Review each checklist carefully during your implementation
+- Ensure your code and processes satisfy every checklist requirement
+- Include ALL checklist item IDs in your final JSON response under "checklist_item_results" (use the exact UUID from "ID:" field in items list)
+- Set "is_passed": true for completed checklist items, or explain in "notes" why a requirement cannot be met
+- Missing any checklist will cause the entire pipeline to fail
+
+Remember: Checklists are not suggestions - they are mandatory quality gates.`;
+        if (verbose) {
+            logInfo(`Added ${checklistContext.checklists.length} checklists to implementation context`);
+        }
+    }
+    return `Implement the complete feature for feature ID: ${featureId}
+
+${finalContextInfo}
+
+## Implementation Instructions
+
+Follow this systematic approach:
+
+1. **GIT PULL REBASE**: First ensure ${baseBranch} is up to date:
+   \`git checkout ${baseBranch}\`
+   \`git pull origin ${baseBranch} --rebase\`
+
+2. **CREATE BRANCH**: Create a new git branch from ${baseBranch}:
+   \`git checkout -b dev/${featureId}\`
+
+2. **ANALYZE CODEBASE**: Study the existing codebase structure to understand:
+   - Technology stack and architecture
+   - Existing patterns and conventions
+   - Where to place new components/files
+   - How to integrate with existing systems
+
+3. **IMPLEMENT FEATURE**: Based on the context above, implement the feature by:
+   - Following the technical design (if available)
+   - Satisfying all user stories
+   - Creating components, services, APIs, database changes as needed
+   - Following existing code patterns and conventions
+   - Adding proper error handling and validation
+
+4. **COMMIT CHANGES**: Commit your work with a descriptive message
+   - This project has strict pre-commit hooks (lint-staged, linting, AI code review)
+   - If hooks fail, try these approaches in order:
+     1. Fix the reported issues (preferred)
+     2. For AI code review issues: SKIP_REVIEW=1 git commit -m "message"
+     3. Last resort only: git commit --no-verify -m "message" (explain why in commit message)
+
+## Important Notes
+- Focus on implementing ALL user stories completely
+- Follow the technical design if provided, or create your own approach
+- Maintain existing code quality and patterns
+- Never skip pre-commit checks - always fix the issues
+- Focus on implementation only - automated tests will be written in a separate phase
+
+${checklistInstructions}
+
+Begin by creating a feature branch and analyzing the codebase structure.`;
+};
+const parseImplementationResponse = (response, featureId) => {
+    console.log('Parsing implementation response...');
+    try {
+        // Try to find JSON in the response
+        const jsonMatch = response.match(/```json\s*([\s\S]*?)\s*```/) ||
+            response.match(/\{[\s\S]*"implementation_result"[\s\S]*\}/);
+        if (jsonMatch) {
+            const jsonStr = jsonMatch[1] || jsonMatch[0];
+            const parsed = JSON.parse(jsonStr);
+            if (parsed.implementation_result) {
+                const result = parsed.implementation_result;
+                return {
+                    branchName: result.branch_name || `dev/${featureId}`,
+                    filesModified: result.files_modified || [],
+                    commitHash: result.commit_hash || '',
+                    summary: result.summary || '',
+                    checklist_item_results: result.checklist_item_results || [],
+                };
+            }
+        }
+        // Fallback: try to extract information from the text
+        const branchMatch = response.match(/branch[:\s]+(\S+)/i);
+        const filesMatch = response.match(/files?[:\s]+([^\n]+)/i);
+        const commitMatch = response.match(/commit[:\s]+([a-f0-9]{7,})/i);
+        return {
+            branchName: branchMatch?.[1] || `dev/${featureId}`,
+            filesModified: filesMatch
+                ? filesMatch[1].split(/[,\s]+/).filter((f) => f)
+                : [],
+            commitHash: commitMatch?.[1] || '',
+            summary: 'Implementation completed',
+        };
+    }
+    catch (error) {
+        console.log('Response parsing failed:', error);
+        return {
+            branchName: `dev/${featureId}`,
+            filesModified: [],
+            commitHash: '',
+            summary: 'Implementation completed',
+        };
+    }
+};
+/**
+ * Push branch to remote repository
+ */
+async function pushToRemote(branchName, verbose) {
+    try {
+        // Import exec from child_process
+        const { execSync } = await import('child_process');
+        if (verbose) {
+            logInfo(`Pushing branch ${branchName} to remote...`);
+        }
+        // Try to push with -u flag (sets upstream if not already set)
+        try {
+            execSync(`git push -u origin ${branchName}`, {
+                encoding: 'utf-8',
+                stdio: verbose ? 'inherit' : 'pipe',
+            });
+            return { success: true };
+        }
+        catch (error) {
+            // If push fails, it might be because branch already has upstream
+            // Try without -u flag
+            try {
+                execSync(`git push origin ${branchName}`, {
+                    encoding: 'utf-8',
+                    stdio: verbose ? 'inherit' : 'pipe',
+                });
+                return { success: true };
+            }
+            catch (retryError) {
+                const errorMessage = retryError instanceof Error ? retryError.message : String(retryError);
+                return {
+                    success: false,
+                    error: errorMessage,
+                };
+            }
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            success: false,
+            error: errorMessage,
+        };
+    }
+}

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

@@ -0,0 +1,17 @@
+import type { FeatureInfo, UserStory, TestCase } from '../../types/features.js';
+import { type ProductInfo } from '../../api/products.js';
+export interface CodeImplementationContext {
+    feature: FeatureInfo;
+    product: ProductInfo;
+    user_stories: UserStory[];
+    test_cases: TestCase[];
+    technical_design?: string;
+}
+/**
+ * Fetch all code implementation context information via MCP endpoints
+ */
+export declare function fetchCodeImplementationContext(featureId: string, verbose?: boolean): Promise<CodeImplementationContext>;
+/**
+ * Format the context into a readable string for Claude Code
+ */
+export declare function formatContextForPrompt(context: CodeImplementationContext): string;