edsger 0.77.0 → 0.78.0

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

@@ -1,627 +0,0 @@
-/* eslint-disable max-lines -- orchestration module with inline prompt generation and review processing */
-/**
- * Code Review Analyzer
- * Reviews GitHub PR code and creates review comments with REQUEST_CHANGES
- */
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { Octokit } from '@octokit/rest';
-import { getGitHubConfig } from '../../api/github.js';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { getBaseBranchInfo, getBranches, updateBranch, } from '../../services/branches.js';
-import { formatChecklistsForContext, } from '../../services/checklist.js';
-import { formatFeedbacksForContext, getFeedbacksForPhase, } from '../../services/feedbacks.js';
-import { getDefaultBranchForIssue } from '../../services/repo-config.js';
-import { prepareCustomBranchGitEnvironmentAsync, preparePhaseGitEnvironmentAsync, syncFeatBranchWithMain, } from '../../utils/git-branch-manager.js';
-import { logError, logInfo } from '../../utils/logger.js';
-import { createPromptGenerator, extractTextFromContent, tryExtractResult, } from '../pr-shared/agent-utils.js';
-import { fetchCodeReviewContext, formatContextForPrompt, } from './context.js';
-import { buildLineToPositionMap, findClosestPosition } from './diff-utils.js';
-/**
- * Process a query result message and extract the structured review result
- */
-function parseQueryResultMessage(message, lastAssistantResponse) {
-    if (message.subtype === 'success') {
-        logInfo('\n Code review analysis completed, parsing results...');
-        const responseText = message.result || lastAssistantResponse;
-        const result = tryExtractResult(responseText, 'review_result');
-        if (result) {
-            return result;
-        }
-        logError('Failed to parse structured review result');
-        return parseCodeReviewResponse(responseText);
-    }
-    logError(`\n Code review incomplete: ${message.subtype}`);
-    if (message.subtype === 'error_max_turns') {
-        logError('Try simplifying the review scope');
-    }
-    if (!lastAssistantResponse) {
-        return null;
-    }
-    const result = tryExtractResult(lastAssistantResponse, 'review_result');
-    if (result) {
-        return result;
-    }
-    return parseCodeReviewResponse(lastAssistantResponse);
-}
-/**
- * Log base branch rebase info for verbose mode
- */
-function logBaseBranchRebaseInfo(currentBranch, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-baseBranchInfo, baseBranchForRebase, originalBaseBranchForRebase, verbose) {
-    if (!verbose) {
-        return;
-    }
-    if (!currentBranch.base_branch_id) {
-        // No base branch - first branch in chain
-    }
-    else if (baseBranchInfo.baseBranchMerged) {
-        logInfo(`   Base branch is merged, will rebase from feat branch: ${baseBranchForRebase}`);
-        if (originalBaseBranchForRebase) {
-            logInfo(`   Using --onto from original base: ${originalBaseBranchForRebase}`);
-        }
-    }
-    else {
-        logInfo(`   Will rebase from base branch: ${baseBranchForRebase}`);
-    }
-}
-/**
- * Main code review function
- */
-export const reviewPullRequest = async (options, config, checklistContext) => {
-    const { issueId, githubToken, verbose } = options;
-    if (verbose) {
-        logInfo(`Starting code review for issue ID: ${issueId}`);
-    }
-    // Resolve the repo's default branch (handles forks where default is master, etc.)
-    const defaultBranch = await getDefaultBranchForIssue(issueId, verbose);
-    // For multi-branch issues, find the branch that is ready for review
-    // and use its branch_name for review (branch_name is stored as dev/...)
-    let branchName = `dev/${issueId}`; // Default for single-branch issues
-    let currentBranch = null;
-    let allBranches = [];
-    let baseBranchForRebase = defaultBranch; // Default base branch for rebase
-    let rebaseTargetBranchForRebase; // Target for --onto rebase (e.g., main)
-    let originalBaseBranchForRebase; // For --onto when base was squash-merged
-    let baseBranchCompletedForRebase = false;
-    try {
-        // Get all branches to determine base branch info
-        allBranches = await getBranches({ issueId, verbose });
-        currentBranch =
-            allBranches.find((b) => b.status === 'ready_for_review') || null;
-        if (currentBranch && currentBranch.branch_name) {
-            // Use branch_name directly (already stored as dev/...)
-            branchName = currentBranch.branch_name;
-            if (verbose) {
-                logInfo(`📋 Found ready_for_review branch: ${currentBranch.name}`);
-                logInfo(`   Using dev branch: ${branchName}`);
-            }
-            // Determine the correct base branch for rebase using base_branch_id
-            const baseBranchInfo = getBaseBranchInfo(currentBranch, allBranches, defaultBranch);
-            // Always use the baseBranch from getBaseBranchInfo - it handles all cases:
-            // - No base branch: returns 'main'
-            // - Base branch merged: returns feat branch (new branches created from feat/xxx)
-            // - Base branch completed: returns main
-            // - Base branch not merged: returns dev branch
-            baseBranchForRebase = baseBranchInfo.baseBranch;
-            // When base branch is merged, rebaseTargetBranch is 'main' (target for --onto)
-            rebaseTargetBranchForRebase = baseBranchInfo.rebaseTargetBranch;
-            // When base branch is merged (squash merge), we need originalBaseBranch for --onto
-            originalBaseBranchForRebase = baseBranchInfo.originalBaseBranch;
-            baseBranchCompletedForRebase = baseBranchInfo.baseBranchCompleted || false;
-            logBaseBranchRebaseInfo(currentBranch, baseBranchInfo, baseBranchForRebase, originalBaseBranchForRebase, verbose);
-        }
-        else if (verbose) {
-            logInfo(`ℹ️ No ready_for_review branch found, using default: ${branchName}`);
-        }
-    }
-    catch (_error) {
-        if (verbose) {
-            logInfo(`Note: Could not fetch issue branches, using default branch`);
-        }
-    }
-    // Get PR URL from branch
-    let pullRequestUrl = null;
-    if (currentBranch && currentBranch.pull_request_url) {
-        pullRequestUrl = currentBranch.pull_request_url;
-        if (verbose) {
-            logInfo(`📝 Using PR URL from branch: ${pullRequestUrl}`);
-        }
-    }
-    else if (verbose) {
-        logInfo(`Note: No PR URL found on branch`);
-    }
-    // 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;
-    if (branchName.startsWith('dev/')) {
-        try {
-            const githubConfig = await getGitHubConfig(issueId, verbose);
-            if (githubConfig.configured &&
-                githubConfig.token &&
-                githubConfig.owner &&
-                githubConfig.repo) {
-                const featBranchName = branchName.replace(/^dev\//, 'feat/');
-                if (verbose) {
-                    logInfo(`📥 Syncing ${featBranchName} with ${defaultBranch} before rebase...`);
-                }
-                featSyncedToMain = await syncFeatBranchWithMain({
-                    featBranch: featBranchName,
-                    githubToken: githubConfig.token,
-                    owner: githubConfig.owner,
-                    repo: githubConfig.repo,
-                    baseBranch: defaultBranch,
-                    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)}`);
-            }
-        }
-    }
-    // Prepare git environment: switch to the appropriate branch and rebase from correct base
-    // Use async version with automatic conflict resolution
-    const gitEnvResult = currentBranch
-        ? await prepareCustomBranchGitEnvironmentAsync({
-            issueBranch: branchName,
-            baseBranch: baseBranchForRebase,
-            rebaseTargetBranch: rebaseTargetBranchForRebase,
-            originalBaseBranch: originalBaseBranchForRebase,
-            verbose,
-            resolveConflicts: true,
-            conflictResolverConfig: {
-                model: DEFAULT_MODEL,
-            },
-            forcePushAfterRebase: featSyncedToMain,
-            baseBranchCompleted: baseBranchCompletedForRebase,
-            githubToken,
-        })
-        : await preparePhaseGitEnvironmentAsync(issueId, defaultBranch, verbose, true, {
-            model: DEFAULT_MODEL,
-        });
-    const cleanupGit = gitEnvResult.cleanup;
-    // Log if conflicts were automatically resolved
-    if (gitEnvResult.conflictsResolved && verbose) {
-        logInfo(`🔧 Automatically resolved ${gitEnvResult.resolvedFiles?.length || 0} conflict(s) during rebase`);
-    }
-    try {
-        // Fetch code review context (PR data, files, commits)
-        if (verbose) {
-            logInfo('Fetching code review context from GitHub PR...');
-        }
-        const context = await fetchCodeReviewContext(issueId, githubToken, verbose, pullRequestUrl || undefined);
-        // Check if there are any files to review
-        if (context.files.length === 0) {
-            if (verbose) {
-                logInfo('✅ No files to review in the PR.');
-            }
-            return {
-                issueId,
-                status: 'success',
-                message: 'No files to review',
-                summary: 'No changed files found in the PR',
-            };
-        }
-        if (verbose) {
-            logInfo(`📋 Found ${context.files.length} files to review across ${context.commits.length} commits`);
-        }
-        // Fetch additional feedbacks for code-review 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_review', 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 code review context${currentBranch ? ` (including branch-specific for "${currentBranch.name}")` : ''}`);
-                }
-            }
-        }
-        catch (error) {
-            if (verbose) {
-                logInfo(`Note: Could not fetch feedbacks (${error instanceof Error ? error.message : String(error)})`);
-            }
-        }
-        // Create prompt for code review
-        const systemPrompt = createSystemPrompt(config, checklistContext);
-        const reviewPrompt = createCodeReviewPrompt(issueId, context, feedbacksInfo, checklistContext);
-        let lastAssistantResponse = '';
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let structuredReviewResult = null;
-        let executionSessionId = '';
-        if (verbose) {
-            logInfo('Starting Claude analysis for code review...');
-        }
-        // Use Claude to analyze the code (not using Claude Code SDK for actual implementation)
-        // This is a simplified approach - just analyze the code
-        for await (const message of query({
-            prompt: createPromptGenerator(reviewPrompt),
-            options: {
-                systemPrompt: {
-                    type: 'preset',
-                    preset: 'claude_code',
-                    append: systemPrompt,
-                },
-                model: DEFAULT_MODEL,
-                maxTurns: 50, // Limited turns since this is just analysis
-                permissionMode: 'bypassPermissions',
-            },
-        })) {
-            if (verbose) {
-                logInfo(`Received message type: ${message.type}`);
-            }
-            // Stream the code review process
-            if (message.type === 'assistant') {
-                lastAssistantResponse += extractTextFromContent(message.message?.content ?? [], verbose);
-                continue;
-            }
-            if (message.type !== 'result') {
-                continue;
-            }
-            executionSessionId = message.session_id || executionSessionId;
-            structuredReviewResult = parseQueryResultMessage(message, lastAssistantResponse);
-        }
-        // Create GitHub review with comments
-        if (structuredReviewResult) {
-            const { summary, comments, overall_assessment, checklist_item_results } = structuredReviewResult;
-            // Initialize Octokit
-            const octokit = new Octokit({ auth: githubToken });
-            if (!comments || comments.length === 0) {
-                if (verbose) {
-                    logInfo('✅ No issues found. PR looks good!');
-                }
-                // Create a comment review if no issues found
-                // Note: We use COMMENT instead of APPROVE because:
-                // 1. Automated reviews should not approve PRs
-                // 2. GitHub doesn't allow approving your own PR
-                const review = await octokit.pulls.createReview({
-                    owner: context.owner,
-                    repo: context.repo,
-                    pull_number: context.pullRequestNumber,
-                    event: 'COMMENT',
-                    body: summary ||
-                        overall_assessment ||
-                        'Code review completed. No issues found.',
-                });
-                // Update branch status to 'reviewed' for multi-branch issues
-                if (currentBranch) {
-                    await updateBranch(currentBranch.id, { status: 'reviewed' }, verbose);
-                    if (verbose) {
-                        logInfo(`✅ Branch "${currentBranch.name}" status updated to 'reviewed'`);
-                    }
-                }
-                return {
-                    issueId,
-                    status: 'success',
-                    message: 'Code review completed - no issues found',
-                    reviewId: review.data.id,
-                    reviewUrl: review.data.html_url,
-                    commentsCount: 0,
-                    summary: summary || 'No issues found',
-                    data: {
-                        checklist_item_results,
-                        execution_session_id: executionSessionId || undefined,
-                    },
-                };
-            }
-            if (verbose) {
-                logInfo(`Creating GitHub review with ${comments.length} comments...`);
-            }
-            // Build a map of file paths to their line-to-position mappings
-            const fileLineToPosition = new Map();
-            for (const file of context.files) {
-                if (file.patch) {
-                    fileLineToPosition.set(file.filename, buildLineToPositionMap(file.patch));
-                }
-            }
-            // Get the latest commit SHA from the PR for the review
-            const commitId = context.prData.head.sha;
-            // Create review with inline comments using unified diff positions
-            const reviewComments = [];
-            for (const comment of comments) {
-                const filePath = comment.file || comment.path;
-                const requestedLine = comment.line;
-                const lineToPosition = fileLineToPosition.get(filePath);
-                if (!lineToPosition) {
-                    if (verbose) {
-                        logInfo(`⚠️  Skipping comment for ${filePath}:${requestedLine} - file has no diff`);
-                    }
-                    continue;
-                }
-                // Find the diff position for this line number
-                const positionResult = findClosestPosition(requestedLine, lineToPosition);
-                if (positionResult === null) {
-                    if (verbose) {
-                        logInfo(`⚠️  Skipping comment for ${filePath}:${requestedLine} - line not in diff range`);
-                    }
-                    continue;
-                }
-                let commentBody = comment.comment || comment.body;
-                // If we had to adjust the line number, add a note
-                if (positionResult.actualLine !== requestedLine) {
-                    commentBody = `**Note**: Comment originally for line ${requestedLine}, adjusted to line ${positionResult.actualLine} (nearest line in diff).\n\n${commentBody}`;
-                    if (verbose) {
-                        logInfo(`  Adjusted ${filePath}:${requestedLine} → line ${positionResult.actualLine} (position ${positionResult.position})`);
-                    }
-                }
-                reviewComments.push({
-                    path: filePath,
-                    position: positionResult.position,
-                    body: commentBody,
-                });
-            }
-            // If all comments were filtered out, just create a review with the summary
-            if (reviewComments.length === 0) {
-                if (verbose) {
-                    logInfo(`⚠️  All ${comments.length} comments were filtered out (invalid line numbers)`);
-                    logInfo('Creating review with summary only...');
-                }
-                const review = await octokit.pulls.createReview({
-                    owner: context.owner,
-                    repo: context.repo,
-                    pull_number: context.pullRequestNumber,
-                    event: 'COMMENT',
-                    body: `${summary || overall_assessment || 'Code review completed.'}\n\n**Note**: Some review comments could not be posted because they referenced lines not present in the diff.`,
-                });
-                // Update branch status to 'reviewed' for multi-branch issues
-                if (currentBranch) {
-                    await updateBranch(currentBranch.id, { status: 'reviewed' }, verbose);
-                    if (verbose) {
-                        logInfo(`✅ Branch "${currentBranch.name}" status updated to 'reviewed'`);
-                    }
-                }
-                return {
-                    issueId,
-                    status: 'success',
-                    message: 'Code review completed - comments filtered due to invalid line numbers',
-                    reviewId: review.data.id,
-                    reviewUrl: review.data.html_url,
-                    commentsCount: 0,
-                    summary: summary || 'Code review completed (comments filtered)',
-                    data: {
-                        checklist_item_results,
-                        execution_session_id: executionSessionId || undefined,
-                    },
-                };
-            }
-            if (verbose) {
-                logInfo(`📝 Posting ${reviewComments.length} validated comments (${comments.length - reviewComments.length} filtered out)`);
-            }
-            const review = await octokit.pulls.createReview({
-                owner: context.owner,
-                repo: context.repo,
-                pull_number: context.pullRequestNumber,
-                commit_id: commitId, // Required for position-based comments
-                event: 'COMMENT',
-                body: summary ||
-                    overall_assessment ||
-                    'Please address the following review comments.',
-                comments: reviewComments,
-            });
-            if (verbose) {
-                logInfo(`✅ GitHub review created: ${review.data.html_url}`);
-                logInfo(`Review ID: ${review.data.id}`);
-                logInfo(`Comments posted: ${comments.length}`);
-            }
-            // Update branch status to 'reviewed' for multi-branch issues
-            if (currentBranch) {
-                await updateBranch(currentBranch.id, { status: 'reviewed' }, verbose);
-                if (verbose) {
-                    logInfo(`✅ Branch "${currentBranch.name}" status updated to 'reviewed'`);
-                }
-            }
-            return {
-                issueId,
-                status: 'success',
-                message: 'Code review completed and posted to GitHub',
-                reviewId: review.data.id,
-                reviewUrl: review.data.html_url,
-                commentsCount: comments.length,
-                summary: summary || 'Code review completed',
-                data: {
-                    checklist_item_results,
-                    execution_session_id: executionSessionId || undefined,
-                },
-            };
-        }
-        return {
-            issueId,
-            status: 'error',
-            message: 'Code review analysis failed or incomplete',
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Code review failed: ${errorMessage}`);
-        return {
-            issueId,
-            status: 'error',
-            message: `Code review failed: ${errorMessage}`,
-        };
-    }
-    finally {
-        // Always return to main branch after phase completion
-        cleanupGit();
-    }
-};
-function createSystemPrompt(_config, checklistContext) {
-    const checklistInstructions = checklistContext &&
-        checklistContext.checklists &&
-        checklistContext.checklists.length > 0
-        ? `
-
-**MANDATORY Checklist Compliance**:
-If you are provided with checklists in the context, you MUST evaluate ALL of them during your code review. Checklists are mandatory requirements that define quality standards and cannot be ignored or skipped.
-
-- Review each checklist carefully and evaluate whether the code satisfies 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 the code satisfies
-- Provide appropriate "value" based on the item type (boolean: true/false, text: descriptive text, number: numeric value)
-- If the code does not 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`
-        : '';
-    const checklistJsonField = checklistContext &&
-        checklistContext.checklists &&
-        checklistContext.checklists.length > 0
-        ? `,
-    "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"
-      }
-    ]`
-        : '';
-    return `You are an expert code reviewer specializing in thorough, constructive code reviews. Your goal is to analyze pull request code and identify issues, potential bugs, code quality concerns, and areas for improvement.
-
-**Your Role**: Review pull request code and provide detailed, actionable feedback.
-
-**Review Focus Areas**:
-1. **Code Quality**: Clean code principles, readability, maintainability
-2. **Best Practices**: Language-specific conventions, design patterns
-3. **Potential Bugs**: Logic errors, edge cases, error handling
-4. **Security**: Security vulnerabilities, input validation
-5. **Performance**: Performance issues, optimization opportunities
-6. **Testing**: Test coverage, test quality
-7. **Documentation**: Code comments, documentation completeness
-8. **Architecture**: Design decisions, coupling, cohesion
-
-**Important Guidelines**:
-- Be thorough but focus on significant issues
-- Provide constructive, actionable feedback
-- Suggest specific improvements
-- Consider the technical design and requirements
-- Be respectful and professional
-- Focus on issues that truly matter, not nitpicks
-- If code looks good overall, provide positive feedback
-${checklistInstructions}
-
-**CRITICAL - Result Format**:
-You MUST end your response with a JSON object containing the review results in this EXACT format:
-
-\`\`\`json
-{
-  "review_result": {
-    "issue_id": "ISSUE_ID_PLACEHOLDER",
-    "summary": "Overall review summary and assessment",
-    "overall_assessment": "APPROVE | REQUEST_CHANGES | COMMENT",
-    "comments": [
-      {
-        "file": "path/to/file.ts",
-        "line": 42,
-        "comment": "Detailed comment about the issue and suggested fix"
-      }
-    ],
-    "issues_found": {
-      "critical": 0,
-      "major": 0,
-      "minor": 0
-    }${checklistJsonField}
-  }
-}
-\`\`\`
-
-**Comment Guidelines**:
-- Each comment should reference a specific file and line number
-- Be specific about what the issue is
-- Provide a suggested fix or improvement
-- Use a constructive, helpful tone
-
-**Assessment Options**:
-- **APPROVE**: Code looks good, no significant issues
-- **REQUEST_CHANGES**: Issues found that should be addressed
-- **COMMENT**: Minor suggestions or questions, not blocking
-
-Focus on providing valuable, actionable code review feedback.`;
-}
-function createCodeReviewPrompt(issueId, context, feedbacksInfo, checklistContext) {
-    let contextInfo = formatContextForPrompt(context);
-    if (feedbacksInfo) {
-        contextInfo = `${contextInfo}\n\n${feedbacksInfo}`;
-    }
-    if (checklistContext && checklistContext.checklists.length > 0) {
-        const checklistInfo = formatChecklistsForContext(checklistContext);
-        contextInfo = `${contextInfo}\n\n${checklistInfo}`;
-    }
-    return `Review the pull request code for issue: ${issueId}
-
-${contextInfo}
-
-## Code Review Instructions
-
-Follow this systematic approach:
-
-1. **Understand the Context**: Review the issue description, technical design, user stories, and test cases to understand what the code should accomplish.
-
-2. **Analyze Each File**: For each changed file:
-   - Review the code changes in the diff
-   - Look for code quality issues
-   - Check for potential bugs or logic errors
-   - Verify error handling
-   - Consider security implications
-   - Evaluate performance considerations
-   - Check test coverage
-
-3. **Check Against Requirements**:
-   - Does the code implement the technical design correctly?
-   - Are all user stories addressed?
-   - Are test cases covered?
-
-4. **Identify Issues**: Categorize issues by severity:
-   - **Critical**: Security vulnerabilities, data loss risks, major bugs
-   - **Major**: Logic errors, incorrect implementations, missing error handling
-   - **Minor**: Code quality improvements, style issues, optimization suggestions
-
-5. **Provide Actionable Feedback**: For each issue:
-   - Reference the specific file and line number
-   - Explain what the issue is
-   - Suggest how to fix it
-   - Be constructive and helpful
-
-6. **Generate Review Result**: Create a structured JSON response with:
-   - Overall summary
-   - Assessment (APPROVE/REQUEST_CHANGES/COMMENT)
-   - List of comments with file, line, and comment text
-   - Count of issues by severity
-
-## Important Notes
-- Be thorough but focus on meaningful issues
-- Provide specific, actionable suggestions
-- Consider the context and requirements
-- Be professional and constructive
-- If code is good, say so!
-${checklistContext && checklistContext.checklists.length > 0
-        ? `
-## MANDATORY - Checklist Compliance
-You MUST evaluate ALL checklist items provided in the context and include results in your JSON response.
-- Use the exact UUID from each checklist item's "ID:" field as the "checklist_item_id"
-- Evaluate whether the code satisfies each checklist requirement
-- Set "is_passed" to true if the requirement is met, false otherwise
-- Provide detailed "notes" for any items that are not passed
-- ALL checklist items must be included - missing items will cause pipeline failure
-`
-        : ''}
-Begin by analyzing the changed files and identifying any issues or improvements.`;
-}
-function parseCodeReviewResponse(response) {
-    const summaryMatch = response.match(/## Review Summary\n([\s\S]*?)(?=\n##|\n\n|$)/);
-    const summary = summaryMatch
-        ? summaryMatch[1].trim()
-        : 'Code review completed';
-    return {
-        summary,
-        comments: [],
-        overall_assessment: 'COMMENT',
-        issues_found: {
-            critical: 0,
-            major: 0,
-            minor: 0,
-        },
-    };
-}

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

@@ -1,19 +0,0 @@
-import { type EdsgerConfig, type WithExecutionSessionId } from '../../types/index.js';
-export interface CodeTestingOptions {
-    issueId: string;
-    verbose?: boolean;
-}
-export interface CodeTestingResult extends WithExecutionSessionId {
-    issueId: string;
-    branchName: string;
-    testSummary: string | null;
-    status: 'success' | 'error';
-    message: string;
-    testFilesCreated?: string[];
-    testFilesModified?: string[];
-    commitHash?: string;
-    totalTestsWritten?: number;
-    testsPassing?: boolean;
-    testCoverage?: string;
-}
-export declare const writeCodeTests: (options: CodeTestingOptions, config: EdsgerConfig) => Promise<CodeTestingResult>;