edsger 0.77.0 → 0.78.0

package/dist/phases/functional-testing/analyzer.js

@@ -1,622 +0,0 @@
-/* eslint-disable max-lines -- orchestration module with test execution, result processing, and report generation */
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { setPhaseState } from '../../api/issues/index.js';
-import { getMcpServerUrl, getMcpToken } from '../../auth/auth-store.js';
-import { DEFAULT_MODEL } from '../../constants.js';
-// 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;
-}
-import { getReadyForReviewBranch, } from '../../services/branches.js';
-import { formatChecklistsForContext, } from '../../services/checklist.js';
-import { formatFeedbacksForContext, getFeedbacksForPhase, } from '../../services/feedbacks.js';
-import { prepareCustomBranchGitEnvironment, preparePhaseGitEnvironment, } from '../../utils/git-branch-manager.js';
-import { logDebug, logError, logInfo } from '../../utils/logger.js';
-import { fetchFunctionalTestingContext, formatContextForPrompt, } from './context-fetcher.js';
-import { saveFunctionalTestResultsWithRetry } from './http-fallback.js';
-import { createTestReport, } from './test-report-creator.js';
-function userMessage(content) {
-    return {
-        type: 'user',
-        message: { role: 'user', content },
-    };
-}
-async function* prompt(testingPrompt) {
-    yield userMessage(testingPrompt);
-    await new Promise((res) => {
-        setTimeout(res, 10000);
-    });
-}
-/**
- * Extract JSON from a response using multiple strategies:
- * 1. Markdown code block
- * 2. Search for JSON object by key
- * 3. Parse entire response
- */
-function extractJsonFromResponse(responseText, searchKeys) {
-    // Strategy 1: markdown code block
-    const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-    if (jsonBlockMatch) {
-        return JSON.parse(jsonBlockMatch[1]);
-    }
-    // Strategy 2: find JSON by searching for key patterns in lines
-    const jsonResult = findJsonByLineSearch(responseText, searchKeys);
-    if (jsonResult) {
-        return jsonResult;
-    }
-    // Strategy 3: parse entire response
-    return JSON.parse(responseText);
-}
-/**
- * Search response lines for JSON objects containing specific keys
- */
-function findJsonByLineSearch(responseText, searchKeys) {
-    const lines = responseText.split('\n');
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i].trim();
-        const hasMatchingKey = line.includes('{') && searchKeys.some((key) => line.includes(key));
-        if (!hasMatchingKey) {
-            continue;
-        }
-        const result = tryExtractJsonFromLines(lines, i);
-        if (result) {
-            return result;
-        }
-    }
-    return null;
-}
-/**
- * Try to extract a complete JSON object starting from a given line index
- */
-function tryExtractJsonFromLines(lines, startLine) {
-    let braceCount = 0;
-    let jsonStr = '';
-    let inString = false;
-    let escapeNext = false;
-    for (let j = startLine; j < lines.length; j++) {
-        const currentLine = lines[j];
-        for (const char of currentLine) {
-            if (escapeNext) {
-                escapeNext = false;
-                jsonStr += char;
-                continue;
-            }
-            if (char === '\\') {
-                escapeNext = true;
-                jsonStr += char;
-                continue;
-            }
-            if (char === '"' && !escapeNext) {
-                inString = !inString;
-            }
-            if (!inString) {
-                if (char === '{') {
-                    braceCount++;
-                }
-                if (char === '}') {
-                    braceCount--;
-                }
-            }
-            jsonStr += char;
-            if (braceCount === 0 && jsonStr.includes('{')) {
-                try {
-                    return JSON.parse(jsonStr);
-                }
-                catch {
-                    // Continue searching
-                }
-            }
-        }
-        if (j > startLine) {
-            jsonStr += '\n';
-        }
-    }
-    return null;
-}
-/**
- * Build a StructuredTestResult from a parsed JSON result
- */
-function buildStructuredTestResult(testData, responseText) {
-    return {
-        status: testData.status || 'testing_failed',
-        title: testData.title || 'Functional Test Report',
-        summary: testData.summary || 'Test execution completed',
-        total_test_cases: testData.total_test_cases || 0,
-        passed_test_cases: testData.passed_test_cases || 0,
-        failed_test_cases: testData.failed_test_cases || 0,
-        test_cases: testData.test_cases || [],
-        execution_details: testData.execution_details || responseText,
-        timestamp: testData.timestamp || new Date().toISOString(),
-        checklist_item_results: testData.checklist_item_results ||
-            [],
-    };
-}
-/**
- * Parse test result from agent response text
- */
-function parseTestResult(responseText) {
-    try {
-        const jsonResult = extractJsonFromResponse(responseText, [
-            '"test_result"',
-            '"status"',
-            '"checklist_item_results"',
-        ]);
-        if (jsonResult?.test_result) {
-            const testData = jsonResult.test_result;
-            const structured = buildStructuredTestResult(testData, responseText);
-            return { testResult: structured, testStatus: structured.status };
-        }
-        if (jsonResult && typeof jsonResult === 'object' && jsonResult.status) {
-            const structured = buildStructuredTestResult(jsonResult, responseText);
-            return { testResult: structured, testStatus: structured.status };
-        }
-        throw new Error('Invalid JSON structure');
-    }
-    catch (error) {
-        logError(`Failed to parse structured test result: ${error}`);
-        return null;
-    }
-}
-/**
- * Resolve the branch to use for testing
- */
-async function resolveTestBranch(issueId, verbose) {
-    let branchName = `dev/${issueId}`;
-    let currentBranch = null;
-    try {
-        currentBranch = await getReadyForReviewBranch({ issueId, verbose });
-        if (currentBranch?.branch_name) {
-            branchName = currentBranch.branch_name;
-            if (verbose) {
-                logInfo(`📋 Found ready_for_review branch: ${currentBranch.name}`);
-                logInfo(`   Using dev branch: ${branchName}`);
-            }
-        }
-        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`);
-        }
-    }
-    return { branchName, currentBranch };
-}
-/**
- * Fetch feedbacks for testing context
- */
-async function fetchTestingFeedbacks(issueId, currentBranch, verbose) {
-    try {
-        const feedbacksContext = await getFeedbacksForPhase({ issueId, verbose }, 'functional_testing', currentBranch?.id);
-        if (feedbacksContext.feedbacks.length > 0) {
-            const info = await formatFeedbacksForContext(feedbacksContext);
-            if (verbose) {
-                logInfo(`Added ${feedbacksContext.feedbacks.length} human feedbacks to testing context${currentBranch ? ` (including branch-specific for "${currentBranch.name}")` : ''}`);
-            }
-            return info;
-        }
-    }
-    catch (error) {
-        if (verbose) {
-            logInfo(`Note: Could not fetch feedbacks (${error instanceof Error ? error.message : String(error)})`);
-        }
-    }
-    return undefined;
-}
-/**
- * Map test results to existing test cases by name matching
- */
-async function mapTestResultsToTestCases(structuredTestResult, issueId, verbose) {
-    if (!structuredTestResult.test_cases?.length) {
-        return undefined;
-    }
-    try {
-        const mcpServerUrl = getMcpServerUrl();
-        const mcpToken = getMcpToken();
-        const testCasesResponse = await fetch(`${mcpServerUrl}/mcp`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${mcpToken}`,
-            },
-            body: JSON.stringify({
-                jsonrpc: '2.0',
-                method: 'test_cases/list',
-                params: { issue_id: issueId },
-                id: Math.random().toString(36).substring(7),
-            }),
-        });
-        if (!testCasesResponse.ok) {
-            return undefined;
-        }
-        const testCasesData = (await testCasesResponse.json());
-        if (testCasesData.error || !testCasesData.result) {
-            return undefined;
-        }
-        const resultObj = testCasesData.result;
-        const existingTestCases = (resultObj.test_cases || []);
-        const testResults = structuredTestResult.test_cases
-            .map((testCase) => {
-            const matchingTestCase = existingTestCases.find((existing) => existing.name.toLowerCase().includes(testCase.name.toLowerCase()) ||
-                testCase.name.toLowerCase().includes(existing.name.toLowerCase()));
-            if (!matchingTestCase) {
-                return null;
-            }
-            return {
-                test_case_id: matchingTestCase.id,
-                result: testCase.status,
-                notes: testCase.error_message || testCase.description || undefined,
-            };
-        })
-            .filter((r) => r !== null);
-        if (verbose && testResults.length > 0) {
-            logInfo(`Mapped ${testResults.length} test results to existing test cases`);
-        }
-        return testResults.length > 0 ? testResults : undefined;
-    }
-    catch (error) {
-        if (verbose) {
-            logError(`Failed to fetch test cases for mapping: ${error}`);
-        }
-        return undefined;
-    }
-}
-/**
- * Save test status and create test report
- */
-async function saveTestResults(issueId, testStatus, structuredTestResult, lastAssistantResponse, verbose) {
-    if (verbose) {
-        logInfo('Saving test results...');
-    }
-    // testStatus is 'testing_passed' | 'testing_failed'. Under the 2D model
-    // both map to a single phase-state update on functional_testing —
-    // 'completed' for passed, 'failed' for failed. issues.status stays
-    // 'in_progress'; humans decide when to ship.
-    const phaseState = testStatus === 'testing_passed' ? 'completed' : 'failed';
-    let statusSaved = true;
-    try {
-        await setPhaseState(issueId, 'functional_testing', phaseState, verbose);
-    }
-    catch (err) {
-        statusSaved = false;
-        if (verbose) {
-            logError(`Direct setPhaseState failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    if (!statusSaved) {
-        if (verbose) {
-            logInfo('Direct status update failed, trying HTTP fallback...');
-        }
-        const fallbackSaved = await saveFunctionalTestResultsWithRetry({
-            issueId,
-            testStatus,
-            testResults: structuredTestResult?.execution_details || lastAssistantResponse,
-            verbose,
-        });
-        if (!fallbackSaved && verbose) {
-            logError('⚠️  Both direct update and HTTP fallback failed');
-        }
-    }
-    if (!structuredTestResult) {
-        return undefined;
-    }
-    if (verbose) {
-        logInfo('Creating test report...');
-    }
-    const testReportData = {
-        title: structuredTestResult.title ||
-            `Functional Test Report - ${new Date().toLocaleString()}`,
-        summary: structuredTestResult.summary,
-        testResults: structuredTestResult.execution_details || lastAssistantResponse,
-        status: testStatus,
-    };
-    const testResults = await mapTestResultsToTestCases(structuredTestResult, issueId, verbose);
-    const testReportResult = await createTestReport({
-        issueId,
-        testReportData,
-        testResults,
-        verbose,
-    });
-    if (testReportResult.success && verbose) {
-        logInfo(`✅ Test report created: ${testReportResult.testReportUrl}`);
-    }
-    else if (!testReportResult.success && verbose) {
-        logError(`⚠️  Test report creation failed: ${testReportResult.error}`);
-    }
-    return testReportResult;
-}
-export const runFunctionalTesting = async (options, config, checklistContext) => {
-    const { issueId, verbose } = options;
-    if (verbose) {
-        logInfo(`Starting functional testing for issue ID: ${issueId}`);
-    }
-    const { branchName, currentBranch } = await resolveTestBranch(issueId, verbose);
-    const cleanupGit = currentBranch
-        ? prepareCustomBranchGitEnvironment(branchName, 'main', verbose)
-        : preparePhaseGitEnvironment(issueId, 'main', verbose);
-    try {
-        if (verbose) {
-            logInfo('Fetching issue testing context via MCP endpoints...');
-        }
-        const context = await fetchFunctionalTestingContext(issueId, verbose);
-        const feedbacksInfo = await fetchTestingFeedbacks(issueId, currentBranch, verbose);
-        const systemPrompt = createSystemPrompt(config, issueId);
-        const testingPrompt = createTestingPromptWithContext(issueId, context, checklistContext, verbose, feedbacksInfo);
-        let lastAssistantResponse = '';
-        let structuredTestResult = null;
-        let testStatus = 'testing_failed';
-        if (verbose) {
-            logInfo('Starting Claude Code query with pre-fetched information...');
-        }
-        for await (const message of query({
-            prompt: prompt(testingPrompt),
-            options: {
-                systemPrompt: {
-                    type: 'preset',
-                    preset: 'claude_code',
-                    append: systemPrompt,
-                },
-                model: DEFAULT_MODEL,
-                maxTurns: 1000,
-                permissionMode: 'bypassPermissions',
-            },
-        })) {
-            if (verbose) {
-                logInfo(`Received message type: ${message.type}`);
-            }
-            if (message.type === 'assistant') {
-                lastAssistantResponse += processAssistantContent(message.message?.content ?? [], verbose);
-            }
-            if (message.type !== 'result') {
-                continue;
-            }
-            if (message.subtype === 'success') {
-                logInfo('\n🎭 Functional testing completed, parsing results...');
-                const responseText = message.result || lastAssistantResponse;
-                const parsed = parseTestResult(responseText);
-                if (parsed) {
-                    structuredTestResult = parsed.testResult;
-                    ({ testStatus } = parsed);
-                }
-                else {
-                    structuredTestResult = {
-                        status: 'testing_failed',
-                        title: 'Test Result Parse Error',
-                        summary: 'Failed to parse structured test results from Claude Code response',
-                        total_test_cases: 0,
-                        passed_test_cases: 0,
-                        failed_test_cases: 1,
-                        execution_details: message.result || lastAssistantResponse,
-                        timestamp: new Date().toISOString(),
-                        checklist_item_results: [],
-                    };
-                    testStatus = 'testing_failed';
-                }
-            }
-            else {
-                logError(`\n⚠️  Functional testing incomplete: ${message.subtype}`);
-                if (message.subtype === 'error_max_turns') {
-                    logError('💡 Try simplifying the test cases or reducing test scope');
-                }
-            }
-        }
-        const testReportResult = await saveTestResults(issueId, testStatus, structuredTestResult, lastAssistantResponse, verbose);
-        if (structuredTestResult) {
-            return {
-                issueId,
-                testStatus,
-                structuredTestResult,
-                testReport: testReportResult,
-                status: 'success',
-                message: `Functional testing completed with status: ${testStatus}`,
-                data: {
-                    checklist_item_results: structuredTestResult.checklist_item_results,
-                },
-            };
-        }
-        return {
-            issueId,
-            testStatus: 'testing_failed',
-            structuredTestResult: null,
-            testReport: testReportResult,
-            status: 'error',
-            message: 'Functional testing failed or incomplete',
-        };
-    }
-    catch (error) {
-        logError(`Functional testing failed: ${error instanceof Error ? error.message : String(error)}`);
-        try {
-            await setPhaseState(issueId, 'functional_testing', 'failed', verbose);
-        }
-        catch (rpcErr) {
-            if (verbose) {
-                logError(`Direct setPhaseState failed (${rpcErr instanceof Error ? rpcErr.message : String(rpcErr)}); trying HTTP fallback...`);
-            }
-            try {
-                await saveFunctionalTestResultsWithRetry({
-                    issueId,
-                    testStatus: 'testing_failed',
-                    testResults: `Testing failed: ${error instanceof Error ? error.message : String(error)}`,
-                    verbose,
-                });
-            }
-            catch (fallbackError) {
-                if (verbose) {
-                    logError(`❌ Failed to save error status: ${fallbackError}`);
-                }
-            }
-        }
-        return {
-            issueId,
-            testStatus: 'testing_failed',
-            structuredTestResult: null,
-            status: 'error',
-            message: `Functional testing failed: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-    finally {
-        cleanupGit();
-    }
-};
-const createSystemPrompt = (_config, mcpServerUrl, mcpToken, issueId) => {
-    let mcpInstructions = '';
-    if (mcpServerUrl && mcpToken && issueId) {
-        mcpInstructions = `
-
-**MANDATORY Checklist Compliance**:
-If you are provided with checklists in the context, you MUST satisfy ALL of them during your testing work. Checklists are mandatory requirements that define quality standards and cannot be ignored or skipped.
-
-- Review each checklist carefully and ensure your testing addresses every requirement
-- You MUST include ALL provided checklist item IDs in the "checklist_item_results" field of your JSON response (use the exact UUID from "ID:" field in items list)
-- 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 checklist items have been addressed - missing items will cause the pipeline to fail
-
-CRITICAL: Checklists are not optional suggestions - they are mandatory quality gates that must be satisfied.`;
-    }
-    return `You are a professional QA automation engineer performing comprehensive functional testing using headless Playwright MCP.
-
-**Your Role**: Execute end-to-end functional tests for implemented issues using headless browser automation.
-
-**Available Tools**:
-- Headless Playwright MCP: Full headless browser automation capabilities for testing
-- Bash: Command line tools for starting servers and running commands
-
-**Testing Process**:
-1. **Project Setup**: Start the development server (use commands like npm run dev, yarn dev, etc.)
-2. **Test Execution**: Use headless Playwright MCP to:
-   - Launch headless browser with appropriate settings for CI/CD environments
-   - Configure browser for headless operation (no GUI, faster execution)
-   - Navigate to the application (typically http://localhost:3000 or similar)
-   - Authenticate with provided credentials (username/password)
-   - Execute test cases based on user stories and technical specifications
-   - Verify functionality works as expected
-3. **Results Reporting**: Provide detailed test results with specific pass/fail information
-
-**Testing Guidelines**:
-- Start the development server before testing
-- ALWAYS configure browser in headless mode for CI/CD compatibility
-- Use appropriate timeouts for headless browser operations
-- Test ALL critical functionality described in user stories
-- Verify both positive and negative test scenarios
-- Test data validation and error handling
-- Ensure proper authentication flows
-- Validate UI elements and user interactions
-- Be thorough but efficient in your testing approach
-- Optimize for performance in headless environments
-
-**Important Notes**:
-- The issue has already been implemented - you're testing existing functionality
-- All issue information, user stories, test cases, and credentials are provided in the prompt
-- You need to start the development server yourself (npm run dev, etc.)
-- Use the provided login credentials for authentication
-- ALWAYS configure browser in HEADLESS mode for better performance and CI/CD compatibility
-- Configure appropriate timeouts and settings for headless browser operations
-- Mark as 'passed' ONLY if ALL critical tests pass
-- Mark as 'failed' if ANY critical functionality is broken
-- Provide specific details about what passed/failed in your results
-
-**CRITICAL - Result Format**:
-You MUST end your response with a JSON object containing the test results in this EXACT format:
-
-\`\`\`json
-{
-  "test_result": {
-    "status": "testing_passed" | "testing_failed",
-    "title": "Descriptive test report title",
-    "summary": "Brief summary of what was tested and results",
-    "total_test_cases": number,
-    "passed_test_cases": number,
-    "failed_test_cases": number,
-    "test_cases": [
-      {
-        "name": "Test case name",
-        "status": "passed" | "failed" | "skipped",
-        "description": "What this test validates",
-        "error_message": "Error details if failed (optional)"
-      }
-    ],
-    "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"
-      }
-    ],
-    "execution_details": "Detailed execution log and findings",
-    "timestamp": "ISO timestamp"
-  }
-}
-\`\`\`
-
-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.
-
-Focus on systematic testing based on the provided context information.${mcpInstructions}`;
-};
-const createTestingPromptWithContext = (issueId, context, checklistContext, verbose, feedbacksInfo) => {
-    const contextInfo = formatContextForPrompt(context);
-    let finalContextInfo = contextInfo;
-    // Add feedbacks context to the testing prompt
-    if (feedbacksInfo) {
-        finalContextInfo = `${finalContextInfo}\n\n${feedbacksInfo}`;
-    }
-    // Add checklist context to the testing prompt
-    if (checklistContext && checklistContext.checklists.length > 0) {
-        const checklistInfo = formatChecklistsForContext(checklistContext);
-        finalContextInfo = `${finalContextInfo}\n\n${checklistInfo}`;
-        if (verbose) {
-            logInfo(`Added ${checklistContext.checklists.length} checklists to testing context`);
-        }
-    }
-    return `Please perform comprehensive functional testing for issue ID: ${issueId}
-
-${finalContextInfo}
-
-## Testing Instructions
-
-Follow this systematic approach:
-
-1. **Start Development Server**: Start the development server (npm run dev, yarn dev, etc.)
-
-2. **Execute Functional Tests**: Use headless Playwright MCP to:
-   - Launch browser in HEADLESS mode with appropriate settings
-   - Configure browser for optimal headless performance
-   - Navigate to the application (typically http://localhost:3000)
-   - Log in using the provided credentials from the environment configuration
-   - Test each user story requirement systematically
-   - Execute all test cases, especially the CRITICAL ones
-   - Verify the issue works according to the technical design
-   - Test error handling and edge cases
-
-3. **Report Results**: Provide detailed test results including:
-   - Summary of what was tested
-   - Which user stories were validated
-   - Which test cases passed/failed
-   - Overall status: 'passed' if ALL critical functionality works correctly, 'failed' if ANY critical functionality is broken
-   - Specific details about any failures or issues found
-
-## Important Notes
-- Focus on the critical test cases marked as [CRITICAL]
-- Ensure all user stories are properly validated
-- Test both positive and negative scenarios
-- The issue should already be implemented - you're validating existing functionality
-- Use the login credentials provided in the environment configuration
-- Be thorough but efficient in your testing approach
-
-Start the development server and begin systematic testing based on the above context.`;
-};

package/dist/phases/functional-testing/context-fetcher.d.ts

@@ -1,16 +0,0 @@
-import { type ProductInfo } from '../../api/products.js';
-import type { IssueInfo, TestCase, UserStory } from '../../types/issues.js';
-export interface FunctionalTestingContext {
-    issue: IssueInfo;
-    product: ProductInfo;
-    user_stories: UserStory[];
-    test_cases: TestCase[];
-}
-/**
- * Fetch all functional testing context information via MCP endpoints
- */
-export declare function fetchFunctionalTestingContext(issueId: string, verbose?: boolean): Promise<FunctionalTestingContext>;
-/**
- * Format the context into a readable string for Claude Code
- */
-export declare function formatContextForPrompt(context: FunctionalTestingContext): string;