edsger 0.2.3 → 0.2.5

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

@@ -2,6 +2,8 @@ import { query } from '@anthropic-ai/claude-code';
 import { logInfo, logError } from '../../utils/logger.js';
 import { formatChecklistsForContext, } from '../../services/checklist.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',
@@ -26,204 +28,284 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
         }
         const context = await fetchCodeImplementationContext(mcpServerUrl, mcpToken, featureId, verbose);
         const systemPrompt = createSystemPrompt(config, baseBranch, mcpServerUrl, mcpToken, featureId);
-        const implementationPrompt = createImplementationPromptWithContext(featureId, context, baseBranch, checklistContext, verbose);
-        let lastAssistantResponse = '';
+        const initialImplementationPrompt = createImplementationPromptWithContext(featureId, context, baseBranch, checklistContext, verbose);
+        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...');
         }
-        // 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:', implementationPrompt.includes('checklist'));
-        console.log('System prompt includes checklist:', systemPrompt.includes('checklist'));
-        // Use Claude Code SDK without MCP servers - all info is pre-fetched
-        for await (const message of query({
-            prompt: prompt(implementationPrompt),
-            options: {
-                appendSystemPrompt: systemPrompt,
-                model: config.claude.model || 'sonnet',
-                maxTurns: 3000,
-                permissionMode: 'bypassPermissions',
-            },
-        })) {
-            if (verbose) {
-                logInfo(`Received message type: ${message.type}`);
+        // 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...`);
             }
-            // 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...'}`);
-                        }
-                    }
-                }
+            // Log iteration start (for iterations after the first)
+            if (currentIteration > 1) {
+                await logFeaturePhaseEvent(mcpServerUrl, mcpToken, {
+                    featureId,
+                    eventType: 'phase_started',
+                    phase: 'code_implementation',
+                    result: 'info',
+                    metadata: {
+                        iteration: currentIteration,
+                        max_iterations: maxIterations,
+                        re_implementation: true,
+                        timestamp: new Date().toISOString(),
+                    },
+                }, verbose);
             }
-            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');
+            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}`);
                             }
-                            structuredImplementationResult = 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');
+                        else if (content.type === 'tool_use') {
+                            if (verbose) {
+                                console.log(`\n🔧 ${content.name}: ${content.input.description || 'Running...'}`);
+                            }
                         }
                     }
-                    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,
-                        });
-                        structuredImplementationResult = {
-                            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);
+                if (message.type === 'result') {
+                    if (message.subtype === 'success') {
+                        logInfo('\n💻 Code implementation completed, parsing results...');
                         try {
-                            const responseText = lastAssistantResponse;
+                            // Try to extract JSON from markdown code block or parse directly
+                            const responseText = message.result || lastAssistantResponse;
                             let jsonResult = null;
-                            console.log('lastAssistantResponse length:', responseText.length);
-                            console.log('lastAssistantResponse first 200 chars:', JSON.stringify(responseText.substring(0, 200)));
+                            // 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('jsonBlockMatch in fallback found:', !!jsonBlockMatch);
+                            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]);
-                                if (jsonResult && jsonResult.implementation_result) {
-                                    structuredImplementationResult =
-                                        jsonResult.implementation_result;
+                            }
+                            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) {
-                            logError(`Failed to parse assistant response: ${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}`);
+                            }
                         }
                     }
                 }
             }
-        }
-        if (structuredImplementationResult) {
-            const { branch_name, files_modified, commit_hash, summary, checklist_results, checklist_item_results, } = structuredImplementationResult;
-            return {
+            // 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(mcpServerUrl, mcpToken, {
                 featureId,
-                branchName: branch_name || `dev/${featureId}`,
-                implementationSummary: summary || 'Implementation completed',
-                status: 'success',
-                message: 'Code implementation completed successfully',
-                filesModified: files_modified || [],
-                commitHash: commit_hash || '',
-                data: {
-                    checklist_results,
-                    checklist_item_results,
+                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, mcpServerUrl, mcpToken, 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;
+            }
         }
-        else {
-            return {
-                featureId,
-                branchName: `dev/${featureId}`,
-                implementationSummary: null,
-                status: 'error',
-                message: 'Code implementation failed or incomplete',
-            };
+        // 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)}`);
@@ -273,11 +355,11 @@ CRITICAL: Checklists are not optional suggestions - they are mandatory quality g
    - 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
-3. **IMPLEMENT CODE**: Write the actual implementation using Edit/Write tools
-4. **TEST**: Run tests to ensure everything works
-5. **FIX ISSUES**: Address any lint or test failures
-6. **COMMIT**: Commit your changes with a descriptive message
-7. **HANDLE PRE-COMMIT**: This project has strict pre-commit hooks - handle them properly:
+4. **IMPLEMENT CODE**: Write the actual implementation using Edit/Write tools
+5. **TEST**: Run tests to ensure everything works
+6. **FIX ISSUES**: Address any lint or test failures
+7. **COMMIT**: Commit your changes with a descriptive message
+8. **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
@@ -490,6 +572,53 @@ const parseImplementationResponse = (response, featureId) => {
         };
     }
 };
+/**
+ * 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,
+        };
+    }
+}
 export const checkCodeImplementationRequirements = async () => {
     try {
         // Check if Claude Code SDK is available

package/dist/phases/code-implementation-verification/index.d.ts

@@ -0,0 +1 @@
+export { verifyCodeImplementationCompliance, type ChecklistItemVerificationResult, type ChecklistVerificationResult, type VerifyCodeImplementationOptions, } from './verifier.js';

package/dist/phases/code-implementation-verification/index.js

@@ -0,0 +1 @@
+export { verifyCodeImplementationCompliance, } from './verifier.js';

package/dist/phases/code-implementation-verification/verifier.d.ts

@@ -0,0 +1,31 @@
+import { EdsgerConfig } from '../../types/index.js';
+export interface ChecklistItemVerificationResult {
+    checklist_item_id: string;
+    is_satisfied: boolean;
+    verification_status: 'confirmed' | 'rejected' | 'uncertain';
+    verification_reason: string;
+    concerns?: string[];
+    improvement_suggestions?: string[];
+}
+export interface ChecklistVerificationResult {
+    overall_status: 'passed' | 'failed' | 'partial';
+    summary: string;
+    confirmed_count: number;
+    rejected_count: number;
+    uncertain_count: number;
+    item_verifications: ChecklistItemVerificationResult[];
+    overall_suggestions?: string[];
+}
+export interface VerifyCodeImplementationOptions {
+    featureId: string;
+    branchName: string;
+    baseBranch: string;
+    featureName: string;
+    featureDescription?: string;
+    checklistContext: string;
+    verbose?: boolean;
+}
+/**
+ * Verify code implementation against checklist requirements by reviewing git diff
+ */
+export declare function verifyCodeImplementationCompliance(options: VerifyCodeImplementationOptions, config: EdsgerConfig): Promise<ChecklistVerificationResult>;