edsger 0.77.0 → 0.79.0

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

@@ -1,926 +0,0 @@
-/* eslint-disable max-lines -- orchestration module with inline prompt generation and agent execution */
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { getGitHubConfig } from '../../api/github.js';
-import { getIssue } from '../../api/issues/index.js';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { logIssuePhaseEvent } from '../../services/audit-logs.js';
-import { createBranches, getBaseBranchInfo, getBranches, getCurrentBranch, updateBranch, } from '../../services/branches.js';
-import { formatChecklistsForContext, } from '../../services/checklist.js';
-import { extractChecklistItems, runPhaseCoaching, } from '../../services/coaching/index.js';
-import { formatFeedbacksForContext, getFeedbacksForPhase, } from '../../services/feedbacks.js';
-import { getDefaultBranchForIssue } from '../../services/repo-config.js';
-import { prepareCustomBranchGitEnvironmentAsync, syncFeatBranchWithMain, } from '../../utils/git-branch-manager.js';
-import { gitPush } from '../../utils/git-push.js';
-import { extractJsonFromResponse } from '../../utils/json-extractor.js';
-import { logDebug, logError, logInfo } from '../../utils/logger.js';
-import { performVerificationCycle } from '../code-implementation-verification/index.js';
-import { createBranchPullRequest, } from './branch-pr-creator.js';
-import { fetchCodeImplementationContext, formatContextForPrompt, } from './context.js';
-import { buildImplementationResult, buildNoResultsError, buildVerificationFailureResult, } from './outcome.js';
-/**
- * Truncate text to a maximum length, adding ellipsis if truncated
- */
-function truncateText(text, maxLength) {
-    if (text.length <= maxLength) {
-        return text;
-    }
-    return `${text.slice(0, maxLength - 3)}...`;
-}
-function userMessage(content) {
-    return {
-        type: 'user',
-        message: { role: 'user', content },
-    };
-}
-async function* prompt(implementationPrompt) {
-    yield userMessage(implementationPrompt);
-    await new Promise((res) => {
-        setTimeout(res, 10000);
-    });
-}
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function processAssistantContent(content, verbose) {
-    let text = '';
-    for (const item of content) {
-        if (item.type === 'text') {
-            text += `${item.text}\n`;
-            logDebug(`🤖 ${item.text}`, verbose);
-        }
-        else if (item.type === 'tool_use') {
-            logDebug(`🔧 ${item.name}: ${item.input.description || 'Running...'}`, verbose);
-        }
-    }
-    return text;
-}
-/**
- * Log debug details about the response text for checklist analysis
- */
-function logResponseDebugInfo(responseText, hasMessageResult, hasAssistantResponse, verbose) {
-    logDebug('Code Implementation Response Analysis', verbose);
-    logDebug(`message.result exists: ${hasMessageResult}`, verbose);
-    logDebug(`lastAssistantResponse exists: ${hasAssistantResponse}`, verbose);
-    logDebug(`responseText length: ${responseText.length}`, verbose);
-    logDebug(`responseText first 200 chars: ${JSON.stringify(responseText.substring(0, 200))}`, verbose);
-    logDebug(`responseText last 200 chars: ${JSON.stringify(responseText.substring(responseText.length - 200))}`, verbose);
-    logDebug(`Contains \`\`\`json: ${responseText.includes('```json')}`, verbose);
-    logDebug(`Contains implementation_result: ${responseText.includes('"implementation_result"')}`, verbose);
-    logDebug('Checklist Content in Response', verbose);
-    logDebug(`Contains "checklist": ${responseText.toLowerCase().includes('checklist')}`, verbose);
-    logDebug(`Contains "checklist_item_results": ${responseText.includes('checklist_item_results')}`, verbose);
-    logDebug(`Contains checklist_item_id: ${responseText.includes('checklist_item_id')}`, verbose);
-    logDebug(`Contains is_passed: ${responseText.includes('is_passed')}`, verbose);
-    const checklistMatches = responseText.match(/checklist/gi) || [];
-    const checklistItemMatches = responseText.match(/checklist_item/gi) || [];
-    logDebug(`Total "checklist" mentions: ${checklistMatches.length}`, verbose);
-    logDebug(`Total "checklist_item" mentions: ${checklistItemMatches.length}`, verbose);
-}
-/**
- * Log debug details about checklist items in the implementation result
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function logChecklistDebugInfo(implResult, verbose) {
-    logDebug(`Keys in implementation_result: ${Object.keys(implResult)}`, verbose);
-    logDebug(`Has checklist_item_results field: ${'checklist_item_results' in implResult}`, verbose);
-    logDebug(`checklist_item_results value type: ${typeof implResult.checklist_item_results}`, verbose);
-    logDebug(`checklist_item_results is array: ${Array.isArray(implResult.checklist_item_results)}`, verbose);
-    if (implResult.checklist_item_results) {
-        logDebug(`checklist_item_results length: ${implResult.checklist_item_results.length}`, verbose);
-        if (implResult.checklist_item_results.length > 0) {
-            logDebug(`First checklist item keys: ${Object.keys(implResult.checklist_item_results[0])}`, verbose);
-            logDebug(`First checklist item sample: ${JSON.stringify(implResult.checklist_item_results[0], null, 2)}`, verbose);
-        }
-    }
-    else {
-        logDebug('checklist_item_results is null/undefined/empty', verbose);
-    }
-}
-/**
- * Parse and extract the implementation result from a successful query response
- */
-function parseSuccessResponse(responseText, hasMessageResult, hasAssistantResponse, issueId, verbose
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-) {
-    logResponseDebugInfo(responseText, hasMessageResult, hasAssistantResponse, verbose);
-    try {
-        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-        logDebug(`jsonBlockMatch found: ${!!jsonBlockMatch}`, verbose);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let jsonResult = null;
-        if (jsonBlockMatch) {
-            logDebug(`Matched JSON length: ${jsonBlockMatch[1].length}`, verbose);
-            logDebug(`Matched JSON first 100 chars: ${JSON.stringify(jsonBlockMatch[1].substring(0, 100))}`, verbose);
-            jsonResult = JSON.parse(jsonBlockMatch[1]);
-        }
-        else {
-            logDebug('Trying direct JSON parse', verbose);
-            jsonResult = JSON.parse(responseText);
-        }
-        logDebug(`jsonResult exists: ${!!jsonResult}`, verbose);
-        logDebug(`jsonResult has implementation_result: ${!!(jsonResult && jsonResult.implementation_result)}`, verbose);
-        if (jsonResult && jsonResult.implementation_result) {
-            logChecklistDebugInfo(jsonResult.implementation_result, verbose);
-            logDebug('Successfully extracted implementation_result', verbose);
-            return jsonResult.implementation_result;
-        }
-        logDebug('Invalid JSON structure - missing implementation_result', verbose);
-        throw new Error('Invalid JSON structure');
-    }
-    catch (error) {
-        const nonSyntaxErrorType = error instanceof Error ? error.constructor.name : 'Unknown';
-        const errorType = error instanceof SyntaxError ? 'SyntaxError' : nonSyntaxErrorType;
-        const errorMsg = error instanceof Error ? error.message : String(error);
-        logDebug(`JSON Parsing Failed - ${errorType}: ${errorMsg}`, verbose);
-        logError(`Failed to parse structured implementation result: ${error}`);
-        logDebug('Using Fallback Parsing', verbose);
-        const parsedResult = parseImplementationResponse(responseText, issueId, verbose);
-        logDebug(`Fallback parsed result: branchName=${parsedResult.branchName}, filesModified=${parsedResult.filesModified?.length || 0}, hasSummary=${!!parsedResult.summary}, commitHash=${parsedResult.commitHash}`, verbose);
-        return {
-            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 || [],
-        };
-    }
-}
-/**
- * Process the query result message and extract implementation result
- */
-function processQueryResult(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-message, lastAssistantResponse, issueId, verbose
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-) {
-    if (message.subtype === 'success') {
-        logInfo('\n💻 Code implementation completed, parsing results...');
-        const responseText = message.result || lastAssistantResponse;
-        return parseSuccessResponse(responseText, !!message.result, !!lastAssistantResponse, issueId, verbose);
-    }
-    logError(`\n⚠️  Code implementation incomplete: ${message.subtype}`);
-    if (message.subtype === 'error_max_turns') {
-        logError('💡 Try breaking down the issue into smaller tasks');
-    }
-    if (lastAssistantResponse) {
-        logDebug(`Fallback for incomplete result, subtype: ${message.subtype}`, verbose);
-        const fallbackJson = extractJsonFromResponse(lastAssistantResponse, '"implementation_result"');
-        if (fallbackJson?.implementation_result) {
-            return fallbackJson.implementation_result;
-        }
-    }
-    return null;
-}
-export const implementIssueCode = async (options, config, checklistContext) => {
-    const { issueId, verbose } = options;
-    // Resolve the repo's default branch (handles forks where default is master, etc.).
-    // Caller may override via options.baseBranch (e.g. branch-chained PR base).
-    const baseBranch = options.baseBranch ?? (await getDefaultBranchForIssue(issueId, verbose));
-    if (verbose) {
-        logInfo(`Starting code implementation for issue ID: ${issueId}`);
-        logInfo(`Base branch: ${baseBranch}`);
-    }
-    // Check for issue branches - use current branch if available
-    // If no branches exist (no branch planning), create a default branch record
-    let currentBranch = null;
-    try {
-        currentBranch = await getCurrentBranch({ issueId, verbose });
-        if (currentBranch && verbose) {
-            logInfo(`📋 Using issue branch: ${currentBranch.name}`);
-            logInfo(`   Branch name: ${currentBranch.branch_name || 'To be created'}`);
-            logInfo(`   Status: ${currentBranch.status}`);
-            logInfo(`   Description: ${currentBranch.description || 'No description'}`);
-        }
-    }
-    catch (_error) {
-        // Issue branches not available or error - continue with default behavior
-        if (verbose) {
-            logInfo('No issue branches found, using default branch naming');
-        }
-    }
-    // If no branch exists (no branch planning phase), create a default branch record
-    if (!currentBranch) {
-        try {
-            if (verbose) {
-                logInfo(`📋 Creating default branch record for issue: ${issueId}`);
-            }
-            // Fetch issue info to get the issue name for branch naming
-            let issueName = 'Issue Implementation';
-            try {
-                const issueInfo = await getIssue(issueId, verbose);
-                if (issueInfo?.name) {
-                    // Truncate issue name for branch display (max 100 chars)
-                    issueName = truncateText(issueInfo.name, 100);
-                }
-            }
-            catch (error) {
-                if (verbose) {
-                    logInfo(`Could not fetch issue name, using default: ${error}`);
-                }
-            }
-            const defaultBranchName = `dev/${issueId}`;
-            const createdBranches = await createBranches({ issueId, verbose }, [
-                {
-                    name: issueName,
-                    description: `Implementation branch for: ${issueName}`,
-                    branch_name: defaultBranchName,
-                    status: 'pending',
-                },
-            ]);
-            if (createdBranches.length > 0) {
-                currentBranch = createdBranches[0];
-                if (verbose) {
-                    logInfo(`✅ Created default branch: ${currentBranch.branch_name}`);
-                }
-            }
-        }
-        catch (error) {
-            if (verbose) {
-                logError(`Failed to create default branch record: ${error}`);
-                logInfo('Continuing without branch record...');
-            }
-        }
-    }
-    // Update issue branch status to in_progress if we have one
-    if (currentBranch && currentBranch.status === 'pending') {
-        try {
-            await updateBranch(currentBranch.id, { status: 'in_progress' }, verbose);
-            if (verbose) {
-                logInfo(`✅ Updated issue branch status to in_progress`);
-            }
-        }
-        catch (error) {
-            if (verbose) {
-                logError(`Failed to update issue branch status: ${error}`);
-            }
-        }
-    }
-    // Determine the actual base branch for branch chaining
-    // If the current issue branch depends on another branch, use that as the base
-    let actualBaseBranch = baseBranch;
-    let rebaseTargetBranch;
-    let originalBaseBranch;
-    let baseBranchCompleted = false;
-    if (currentBranch && currentBranch.base_branch_id) {
-        try {
-            const allBranches = await getBranches({
-                issueId,
-                verbose: false,
-            });
-            const baseBranchInfo = getBaseBranchInfo(currentBranch, allBranches, baseBranch);
-            actualBaseBranch = baseBranchInfo.baseBranch;
-            ({ rebaseTargetBranch, originalBaseBranch } = baseBranchInfo);
-            baseBranchCompleted = baseBranchInfo.baseBranchCompleted || false;
-            if (verbose) {
-                logInfo(`🔗 Branch chaining detected:`);
-                logInfo(`   Current branch: ${currentBranch.name}`);
-                logInfo(`   Base branch (for new branches): ${actualBaseBranch}`);
-                if (rebaseTargetBranch) {
-                    logInfo(`   Rebase target: ${rebaseTargetBranch}`);
-                }
-                if (originalBaseBranch) {
-                    logInfo(`   Original base branch: ${originalBaseBranch} (for --onto rebase)`);
-                }
-                if (baseBranchInfo.baseBranchMerged) {
-                    logInfo(`   Parent branch merged: yes`);
-                }
-                else {
-                    logInfo(`   Parent branch merged: no (using parent branch)`);
-                }
-            }
-        }
-        catch (error) {
-            if (verbose) {
-                logError(`Failed to compute base branch info: ${error}`);
-                logInfo(`   Falling back to default base branch: ${baseBranch}`);
-            }
-        }
-    }
-    // Prepare git environment: switch to issue branch and rebase with base
-    // Branch names are stored as dev/... (development branch)
-    // PR will be created from dev/... to feat/... after implementation
-    const devBranchName = currentBranch?.branch_name || `dev/${issueId}`;
-    if (verbose && currentBranch) {
-        logInfo(`🔄 Using dev branch for development: ${devBranchName}`);
-    }
-    // Sync feat branch to main before rebase to ensure it's up to date
-    // This prevents the PR (dev → feat) from showing extra commits
-    let featSyncedToMain = false;
-    let githubTokenForPush;
-    if (devBranchName.startsWith('dev/')) {
-        try {
-            const githubConfig = await getGitHubConfig(issueId, verbose);
-            if (githubConfig.configured &&
-                githubConfig.token &&
-                githubConfig.owner &&
-                githubConfig.repo) {
-                githubTokenForPush = githubConfig.token;
-                const { devBranchToFeatBranch } = await import('./branch-pr-creator.js');
-                const featBranchName = devBranchToFeatBranch(devBranchName);
-                if (verbose) {
-                    logInfo(`📥 Syncing ${featBranchName} with main before rebase...`);
-                }
-                featSyncedToMain = await syncFeatBranchWithMain({
-                    featBranch: featBranchName,
-                    githubToken: githubConfig.token,
-                    owner: githubConfig.owner,
-                    repo: githubConfig.repo,
-                    baseBranch,
-                    verbose,
-                });
-            }
-        }
-        catch (error) {
-            // Don't fail the phase if sync fails
-            if (verbose) {
-                logInfo(`⚠️  Could not sync feat branch: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-    }
-    // Use async version to support --onto rebase for branch chaining
-    // This correctly handles cases where base branch was squash-merged
-    const { cleanup: cleanupGit } = await prepareCustomBranchGitEnvironmentAsync({
-        issueBranch: devBranchName,
-        baseBranch: actualBaseBranch,
-        rebaseTargetBranch, // For --onto rebase target (e.g., main) when base branch is merged
-        originalBaseBranch, // For --onto rebase starting point when base branch was squash-merged
-        verbose,
-        resolveConflicts: true,
-        conflictResolverConfig: {
-            model: DEFAULT_MODEL,
-        },
-        forcePushAfterRebase: featSyncedToMain, // Trigger GitHub to recalculate PR diff
-        baseBranchCompleted, // Tell conflict resolver to use --theirs for all conflicts
-        githubToken: githubTokenForPush,
-    });
-    try {
-        // Fetch all required context information via MCP endpoints
-        if (verbose) {
-            logInfo('Fetching code implementation context via MCP endpoints...');
-        }
-        const context = await fetchCodeImplementationContext(issueId, verbose);
-        // Fetch feedbacks for code implementation phase
-        // For multi-branch issues, filter by the current branch to get branch-specific feedbacks
-        let feedbacksInfo;
-        try {
-            const feedbacksContext = await getFeedbacksForPhase({ issueId, verbose }, 'code_implementation', currentBranch?.id // Pass branch_id if we have a current branch
-            );
-            if (feedbacksContext.feedbacks.length > 0) {
-                feedbacksInfo = await formatFeedbacksForContext(feedbacksContext);
-                if (verbose) {
-                    logInfo(`Added ${feedbacksContext.feedbacks.length} human feedbacks to implementation context${currentBranch ? ` (including branch-specific for "${currentBranch.name}")` : ''}`);
-                }
-            }
-        }
-        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)})`);
-            }
-        }
-        // Use the dev branch name for development (already computed above)
-        const branchName = devBranchName;
-        const systemPrompt = createSystemPrompt(config, actualBaseBranch, // Use computed base branch for branch chaining
-        issueId, branchName);
-        const initialImplementationPrompt = createImplementationPromptWithContext({
-            issueId,
-            context,
-            baseBranch: actualBaseBranch, // Use computed base branch for branch chaining
-            checklistContext,
-            verbose,
-            feedbacksInfo,
-            issueBranch: currentBranch,
-        });
-        const maxIterations = options.maxVerificationIterations || 10;
-        let currentIteration = 0;
-        let currentPrompt = initialImplementationPrompt;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let structuredImplementationResult = null;
-        let verificationResult = null;
-        if (verbose) {
-            logInfo('Starting Claude Code query with pre-fetched information...');
-        }
-        let executionSessionId = '';
-        // 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 logIssuePhaseEvent({
-                    issueId,
-                    eventType: 'phase_started',
-                    phase: 'code_implementation',
-                    result: 'info',
-                    metadata: {
-                        iteration: currentIteration,
-                        max_iterations: maxIterations,
-                        re_implementation: true,
-                        timestamp: new Date().toISOString(),
-                    },
-                }, verbose);
-            }
-            let lastAssistantResponse = '';
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            let newImplementationResult = null;
-            // Log checklist context before query
-            logDebug('Checklist Context Before Claude Query', verbose);
-            logDebug(`Has checklistContext: ${!!checklistContext}`, verbose);
-            if (checklistContext) {
-                logDebug(`Number of checklists: ${checklistContext.checklists.length}`, verbose);
-                const totalItems = checklistContext.checklists.reduce((sum, checklist) => sum + (checklist.items?.length || 0), 0);
-                logDebug(`Total checklist items: ${totalItems}`, verbose);
-            }
-            logDebug(`Implementation prompt includes checklist: ${currentPrompt.includes('checklist')}`, verbose);
-            logDebug(`System prompt includes checklist: ${systemPrompt.includes('checklist')}`, verbose);
-            // Execute implementation query
-            for await (const message of query({
-                prompt: prompt(currentPrompt),
-                options: {
-                    systemPrompt: {
-                        type: 'preset',
-                        preset: 'claude_code',
-                        append: systemPrompt,
-                    },
-                    model: DEFAULT_MODEL,
-                    maxTurns: 3000,
-                    permissionMode: 'bypassPermissions',
-                },
-            })) {
-                if (verbose) {
-                    logInfo(`Received message type: ${message.type}`);
-                }
-                // Stream the implementation process
-                if (message.type === 'assistant') {
-                    lastAssistantResponse += processAssistantContent(message.message?.content ?? [], verbose);
-                    continue;
-                }
-                if (message.type !== 'result') {
-                    continue;
-                }
-                // Capture session ID for coaching loop
-                executionSessionId = message.session_id || executionSessionId;
-                newImplementationResult = processQueryResult(message, lastAssistantResponse, issueId, verbose);
-            }
-            // 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 logIssuePhaseEvent({
-                issueId,
-                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);
-            // Coaching loop: self-rate → coach → improve → repeat (between execute and verify)
-            // Runs before push so any improvements are committed and pushed together
-            const coaching = await runPhaseCoaching({
-                issueId,
-                phase: 'code_implementation',
-                phaseResult: { execution_session_id: executionSessionId },
-                checklistItems: extractChecklistItems(checklistContext),
-                verbose,
-            });
-            executionSessionId = coaching.executionSessionId || executionSessionId;
-            // Push code to remote after commit + coaching improvements
-            if (verbose) {
-                logInfo(`📤 Pushing code to remote repository...`);
-            }
-            const pushResult = gitPush({
-                branchName: structuredImplementationResult.branch_name || branchName,
-                token: githubTokenForPush,
-                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({
-                branchName: structuredImplementationResult.branch_name || branchName,
-                baseBranch: actualBaseBranch, // Use computed base branch for branch chaining
-                checklistContext: checklistContext || null,
-                issueId,
-                issueName: context.issue.name,
-                issueDescription: context.issue.description,
-                config,
-                currentIteration,
-                maxIterations,
-                verbose,
-            });
-            ({ verificationResult } = verificationCycle);
-            // 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(issueId, 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({
-                issueId,
-                branchName: branch_name || branchName,
-                implementationSummary: summary || 'Implementation completed with verification failures',
-                filesModified: files_modified || [],
-                commitHash: commit_hash || '',
-                verificationResult,
-                iterations: currentIteration,
-            });
-        }
-        // Create pull request from dev/ branch to feat/ branch if this is a multi-branch issue
-        let pullRequestUrl = null;
-        let pullRequestNumber = null;
-        if (currentBranch && devBranchName.startsWith('dev/')) {
-            // Get GitHub configuration from developer settings via MCP
-            const githubConfig = await getGitHubConfig(issueId, verbose);
-            if (githubConfig.configured &&
-                githubConfig.token &&
-                githubConfig.owner &&
-                githubConfig.repo) {
-                const prConfig = {
-                    githubToken: githubConfig.token,
-                    owner: githubConfig.owner,
-                    repo: githubConfig.repo,
-                    verbose,
-                };
-                // Derive feat/ branch name from dev/ branch name for PR target
-                const { devBranchToFeatBranch } = await import('./branch-pr-creator.js');
-                const featBranchName = devBranchToFeatBranch(devBranchName);
-                if (verbose) {
-                    logInfo(`📝 Creating pull request from ${devBranchName} to ${featBranchName}...`);
-                }
-                const prResult = await createBranchPullRequest(prConfig, devBranchName, currentBranch.name, currentBranch.description || 'Issue branch implementation', baseBranch);
-                if (prResult.success) {
-                    pullRequestUrl = prResult.pullRequestUrl || null;
-                    pullRequestNumber = prResult.pullRequestNumber || null;
-                    if (verbose) {
-                        logInfo(`✅ Pull request created: ${pullRequestUrl}`);
-                    }
-                }
-                else if (verbose) {
-                    logError(`⚠️ Failed to create pull request: ${prResult.error}`);
-                    logInfo('   Implementation is complete, but PR was not created.');
-                }
-            }
-            else if (verbose) {
-                logInfo('⚠️ GitHub configuration not available, skipping PR creation');
-                logInfo(`   ${githubConfig.message || 'Please configure GitHub App in product developer settings.'}`);
-            }
-        }
-        // Update issue branch status to ready_for_review if we have one
-        if (currentBranch) {
-            try {
-                // Note: branch_name is stored as dev/... and used directly by all phases.
-                // The feat/ branch name is derived at runtime using devBranchToFeatBranch() for PR targets.
-                await updateBranch(currentBranch.id, {
-                    status: 'ready_for_review',
-                    pull_request_url: pullRequestUrl,
-                    pull_request_number: pullRequestNumber,
-                }, verbose);
-                if (verbose) {
-                    logInfo(`✅ Updated issue branch status to ready_for_review`);
-                }
-            }
-            catch (error) {
-                if (verbose) {
-                    logError(`Failed to update issue branch status: ${error}`);
-                }
-            }
-        }
-        // Return success result with session ID for coaching
-        const implResult = buildImplementationResult({
-            issueId,
-            branchName: branch_name || branchName,
-            implementationSummary: summary || 'Implementation completed successfully',
-            filesModified: files_modified || [],
-            commitHash: commit_hash || '',
-            iterations: currentIteration,
-            checklistResults: checklist_results,
-            checklistItemResults: checklist_item_results,
-        });
-        return {
-            ...implResult,
-            data: {
-                ...implResult.data,
-                execution_session_id: executionSessionId || undefined,
-            },
-        };
-    }
-    catch (error) {
-        logError(`Code implementation failed: ${error instanceof Error ? error.message : String(error)}`);
-        return {
-            issueId,
-            branchName: `dev/${issueId}`,
-            implementationSummary: null,
-            status: 'error',
-            message: `Implementation failed: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-    finally {
-        // Always return to main branch after phase completion
-        cleanupGit();
-    }
-};
-const createSystemPrompt = (_config, baseBranch, issueId, branchName) => {
-    const 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 issues based on specifications. Your task is to implement complete, production-ready code based on issue requirements, user stories, test cases, and technical design.
-
-**Your Role**: Implement complete, working issues 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 issue branch \`${branchName}\` 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 branch \`${branchName}\` before making changes: git checkout -b ${branchName}
-   - 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": {
-    "issue_id": "ISSUE_ID_PLACEHOLDER",
-    "branch_name": "dev/ISSUE_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 = (opts) => {
-    const { issueId, context, baseBranch, checklistContext, verbose, feedbacksInfo, issueBranch, } = opts;
-    const contextInfo = formatContextForPrompt(context);
-    let finalContextInfo = contextInfo;
-    // Add issue branch context if available
-    if (issueBranch) {
-        const branchContext = `
-## Current Issue Branch
-
-This is a **multi-branch issue** - the issue has been split into multiple branches for incremental development.
-
-**Current Branch Information:**
-- **Name**: ${issueBranch.name}
-- **Branch**: ${issueBranch.branch_name || 'To be created'}
-- **Description**: ${issueBranch.description || 'No description'}
-
-**Important**: Focus ONLY on implementing the scope defined for this specific branch. Do not implement functionality that belongs to other branches.
-`;
-        finalContextInfo = `${branchContext}\n${finalContextInfo}`;
-    }
-    // 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}`;
-        // Log checklist context details
-        logDebug('Checklist Context for Code Implementation', verbose);
-        logDebug(`Number of checklists: ${checklistContext.checklists.length}`, verbose);
-        logDebug(`Checklist info length: ${checklistInfo.length}`, verbose);
-        logDebug(`Checklist info preview: ${checklistInfo.substring(0, 300)}`, verbose);
-        checklistContext.checklists.forEach((checklist, index) => {
-            logDebug(`Checklist ${index + 1}: id=${checklist.id}, name=${checklist.name}, phases=${checklist.phases?.join(',')}, role=${checklist.role}, itemCount=${checklist.items?.length || 0}`, verbose);
-            if (checklist.items) {
-                checklist.items.forEach((item, itemIndex) => {
-                    logDebug(`  Item ${itemIndex + 1}: id=${item.id}, title=${item.title?.substring(0, 50) || 'No title'}, description=${item.description?.substring(0, 50) || 'No description'}`, verbose);
-                });
-            }
-        });
-        // 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`);
-        }
-    }
-    // Determine branch name
-    const branchName = issueBranch?.branch_name || `dev/${issueId}`;
-    const branchDescription = issueBranch
-        ? `\n\n**Note**: This is a multi-branch issue. Focus only on the scope defined for this branch.`
-        : '';
-    return `Implement the ${issueBranch ? `"${issueBranch.name}" branch of` : 'complete'} issue for issue ID: ${issueId}${branchDescription}
-
-${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 git branch from ${baseBranch}:
-   \`git checkout -b ${branchName}\`
-
-3. **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
-
-4. **IMPLEMENT ISSUE**: Based on the context above, implement the issue by:
-   - Following the technical design (if available)
-   - Satisfying all user stories${issueBranch ? ' relevant to this branch' : ''}
-   - Creating components, services, APIs, database changes as needed
-   - Following existing code patterns and conventions
-   - Adding proper error handling and validation
-
-5. **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
-${issueBranch ? `- Focus ONLY on implementing the scope for this branch: "${issueBranch.name}"` : '- 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 the issue branch and analyzing the codebase structure.`;
-};
-const parseImplementationResponse = (response, issueId, verbose) => {
-    logDebug('Parsing implementation response...', verbose);
-    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/${issueId}`,
-                    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/${issueId}`,
-            filesModified: filesMatch
-                ? filesMatch[1].split(/[,\s]+/).filter((f) => f)
-                : [],
-            commitHash: commitMatch?.[1] || '',
-            summary: 'Implementation completed',
-        };
-    }
-    catch (error) {
-        logError(`Response parsing failed: ${error}`);
-        return {
-            branchName: `dev/${issueId}`,
-            filesModified: [],
-            commitHash: '',
-            summary: 'Implementation completed',
-        };
-    }
-};