edsger 0.2.0 → 0.2.2

package/dist/{functional-testing → phases/functional-testing}/analyzer.js

@@ -1,7 +1,9 @@
 import { query } from '@anthropic-ai/claude-code';
-import { logInfo, logError } from '../logger.js';
+import { logInfo, logError } from '../../utils/logger.js';
+import { formatChecklistsForContext, } from '../../services/checklist.js';
 import { saveFunctionalTestResultsWithRetry } from './http-fallback.js';
-import { fetchFeatureTestingContext, updateFeatureTestStatus, formatContextForPrompt, } from './context-fetcher.js';
+import { fetchFunctionalTestingContext, formatContextForPrompt, } from './context-fetcher.js';
+import { updateFeatureStatus } from '../../api/features/index.js';
 import { createTestReport, } from './test-report-creator.js';
 function userMessage(content) {
     return {
@@ -13,7 +15,7 @@ async function* prompt(testingPrompt) {
     yield userMessage(testingPrompt);
     await new Promise((res) => setTimeout(res, 10000));
 }
-export const runFunctionalTesting = async (options, config) => {
+export const runFunctionalTesting = async (options, config, checklistContext) => {
     const { featureId, mcpServerUrl, mcpToken, verbose } = options;
     if (verbose) {
         logInfo(`Starting functional testing for feature ID: ${featureId}`);
@@ -24,9 +26,9 @@ export const runFunctionalTesting = async (options, config) => {
         if (verbose) {
             logInfo('Fetching feature testing context via MCP endpoints...');
         }
-        const context = await fetchFeatureTestingContext(mcpServerUrl, mcpToken, featureId, verbose);
-        const systemPrompt = createSystemPrompt(config);
-        const testingPrompt = createTestingPromptWithContext(featureId, context);
+        const context = await fetchFunctionalTestingContext(mcpServerUrl, mcpToken, featureId, verbose);
+        const systemPrompt = createSystemPrompt(config, mcpServerUrl, mcpToken, featureId);
+        const testingPrompt = createTestingPromptWithContext(featureId, context, checklistContext, verbose);
         let lastAssistantResponse = '';
         let structuredTestResult = null;
         let testStatus = 'testing_failed';
@@ -75,10 +77,89 @@ export const runFunctionalTesting = async (options, config) => {
                             jsonResult = JSON.parse(jsonBlockMatch[1]);
                         }
                         else {
-                            // Try to parse the entire response as JSON
-                            jsonResult = JSON.parse(responseText);
+                            // Search for JSON objects in the complete response
+                            const lines = responseText.split('\n');
+                            let foundJson = false;
+                            for (let i = 0; i < lines.length; i++) {
+                                const line = lines[i].trim();
+                                if (line.includes('{') &&
+                                    (line.includes('"test_result"') ||
+                                        line.includes('"status"') ||
+                                        line.includes('"checklist_item_results"'))) {
+                                    // Found a potential JSON line, extract complete JSON object
+                                    let braceCount = 0;
+                                    let jsonStr = '';
+                                    let inString = false;
+                                    let escapeNext = false;
+                                    for (let j = i; j < lines.length; j++) {
+                                        const currentLine = lines[j];
+                                        for (let k = 0; k < currentLine.length; k++) {
+                                            const char = currentLine[k];
+                                            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 {
+                                                    jsonResult = JSON.parse(jsonStr);
+                                                    foundJson = true;
+                                                    break;
+                                                }
+                                                catch {
+                                                    // Continue searching
+                                                }
+                                            }
+                                        }
+                                        if (foundJson)
+                                            break;
+                                        if (j > i)
+                                            jsonStr += '\n';
+                                    }
+                                    if (foundJson)
+                                        break;
+                                }
+                            }
+                            // Final fallback: Try to parse the entire response as JSON
+                            if (!foundJson) {
+                                jsonResult = JSON.parse(responseText);
+                            }
                         }
-                        if (jsonResult && typeof jsonResult === 'object') {
+                        if (jsonResult && jsonResult.test_result) {
+                            const testData = jsonResult.test_result;
+                            structuredTestResult = {
+                                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 || [],
+                            };
+                            testStatus = structuredTestResult.status;
+                        }
+                        else if (jsonResult &&
+                            typeof jsonResult === 'object' &&
+                            jsonResult.status) {
+                            // Fallback: handle flat structure for backward compatibility
                             structuredTestResult = {
                                 status: jsonResult.status || 'testing_failed',
                                 title: jsonResult.title || 'Functional Test Report',
@@ -89,6 +170,7 @@ export const runFunctionalTesting = async (options, config) => {
                                 test_cases: jsonResult.test_cases || [],
                                 execution_details: jsonResult.execution_details || responseText,
                                 timestamp: jsonResult.timestamp || new Date().toISOString(),
+                                checklist_item_results: jsonResult.checklist_item_results || [],
                             };
                             testStatus = structuredTestResult.status;
                         }
@@ -108,6 +190,7 @@ export const runFunctionalTesting = async (options, config) => {
                             failed_test_cases: 1,
                             execution_details: message.result || lastAssistantResponse,
                             timestamp: new Date().toISOString(),
+                            checklist_item_results: [],
                         };
                         testStatus = 'testing_failed';
                     }
@@ -124,7 +207,13 @@ export const runFunctionalTesting = async (options, config) => {
         if (verbose) {
             logInfo('Saving test results...');
         }
-        const statusSaved = await updateFeatureTestStatus(mcpServerUrl, mcpToken, featureId, testStatus, verbose);
+        const statusSaved = await updateFeatureStatus({
+            mcpServerUrl,
+            mcpToken,
+            featureId,
+            status: testStatus,
+            verbose,
+        });
         // Try HTTP fallback if direct update failed
         if (!statusSaved) {
             if (verbose) {
@@ -155,11 +244,68 @@ export const runFunctionalTesting = async (options, config) => {
                 testResults: structuredTestResult.execution_details || lastAssistantResponse,
                 status: testStatus,
             };
+            // Convert test cases to test results format for MCP
+            let testResults;
+            if (structuredTestResult.test_cases &&
+                structuredTestResult.test_cases.length > 0) {
+                // Fetch test cases for this feature to get proper test_case_ids
+                try {
+                    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: {
+                                feature_id: featureId,
+                            },
+                            id: Math.random().toString(36).substring(7),
+                        }),
+                    });
+                    if (testCasesResponse.ok) {
+                        const testCasesData = await testCasesResponse.json();
+                        if (!testCasesData.error && testCasesData.result) {
+                            const existingTestCases = testCasesData.result.test_cases || [];
+                            // Map structured test results to existing test cases by name
+                            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 {
+                                        test_case_id: matchingTestCase.id,
+                                        result: testCase.status,
+                                        notes: testCase.error_message || testCase.description || null,
+                                    };
+                                }
+                                return null;
+                            })
+                                .filter(Boolean);
+                            if (verbose && testResults.length > 0) {
+                                logInfo(`Mapped ${testResults.length} test results to existing test cases`);
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    if (verbose) {
+                        logError(`Failed to fetch test cases for mapping: ${error}`);
+                    }
+                }
+            }
             testReportResult = await createTestReport({
                 mcpServerUrl,
                 mcpToken,
                 featureId,
                 testReportData,
+                testResults,
                 verbose,
             });
             if (testReportResult.success && verbose) {
@@ -177,6 +323,9 @@ export const runFunctionalTesting = async (options, config) => {
                 testReport: testReportResult,
                 status: 'success',
                 message: `Functional testing completed with status: ${testStatus}`,
+                data: {
+                    checklist_item_results: structuredTestResult.checklist_item_results,
+                },
             };
         }
         else {
@@ -194,7 +343,13 @@ export const runFunctionalTesting = async (options, config) => {
         logError(`Functional testing failed: ${error instanceof Error ? error.message : String(error)}`);
         // Try to save error status
         try {
-            const errorSaved = await updateFeatureTestStatus(mcpServerUrl, mcpToken, featureId, 'testing_failed', verbose);
+            const errorSaved = await updateFeatureStatus({
+                mcpServerUrl,
+                mcpToken,
+                featureId,
+                status: 'testing_failed',
+                verbose,
+            });
             if (!errorSaved) {
                 // Try HTTP fallback
                 await saveFunctionalTestResultsWithRetry({
@@ -221,7 +376,23 @@ export const runFunctionalTesting = async (options, config) => {
         };
     }
 };
-const createSystemPrompt = (_config) => {
+const createSystemPrompt = (_config, mcpServerUrl, mcpToken, featureId) => {
+    let mcpInstructions = '';
+    if (mcpServerUrl && mcpToken && featureId) {
+        mcpInstructions = `
+
+**MANDATORY Checklist Compliance**:
+If you are provided with checklists in the context, you MUST satisfy ALL of them during your 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 features using headless browser automation.
@@ -269,32 +440,55 @@ You MUST end your response with a JSON object containing the test results in thi
 
 \`\`\`json
 {
-  "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)"
-    }
-  ],
-  "execution_details": "Detailed execution log and findings",
-  "timestamp": "ISO timestamp"
+  "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"
+  }
 }
 \`\`\`
 
-Focus on systematic testing based on the provided context information.`;
+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 = (featureId, context) => {
+const createTestingPromptWithContext = (featureId, context, checklistContext, verbose) => {
     const contextInfo = formatContextForPrompt(context);
+    // Add checklist context to the testing prompt
+    let finalContextInfo = contextInfo;
+    if (checklistContext && checklistContext.checklists.length > 0) {
+        const checklistInfo = formatChecklistsForContext(checklistContext);
+        finalContextInfo = contextInfo + '\n\n' + checklistInfo;
+        if (verbose) {
+            logInfo(`Added ${checklistContext.checklists.length} checklists to testing context`);
+        }
+    }
     return `Please perform comprehensive functional testing for feature ID: ${featureId}
 
-${contextInfo}
+${finalContextInfo}
 
 ## Testing Instructions
 

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

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

package/dist/phases/functional-testing/context-fetcher.js

@@ -0,0 +1,81 @@
+import { logInfo, logError } from '../../utils/logger.js';
+import { getFeature, getUserStories, getTestCases, } from '../../api/features/index.js';
+import { getProduct } from '../../api/products.js';
+/**
+ * Fetch all functional testing context information via MCP endpoints
+ */
+export async function fetchFunctionalTestingContext(mcpServerUrl, mcpToken, featureId, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Fetching complete functional testing context for feature: ${featureId}`);
+        }
+        // Fetch all required data in parallel for better performance
+        const [feature, user_stories, test_cases] = await Promise.all([
+            getFeature(mcpServerUrl, mcpToken, featureId, verbose),
+            getUserStories(mcpServerUrl, mcpToken, featureId, verbose),
+            getTestCases(mcpServerUrl, mcpToken, featureId, verbose),
+        ]);
+        const product = await getProduct(mcpServerUrl, mcpToken, feature.product_id, verbose);
+        if (verbose) {
+            logInfo(`✅ Functional testing context fetched successfully:`);
+            logInfo(`   Feature: ${feature.name}`);
+            logInfo(`   Product: ${product.name}`);
+            logInfo(`   User Stories: ${user_stories.length}`);
+            logInfo(`   Test Cases: ${test_cases.length}`);
+        }
+        return {
+            feature,
+            product,
+            user_stories,
+            test_cases,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to fetch functional testing context: ${errorMessage}`);
+        throw new Error(`Context fetch failed: ${errorMessage}`);
+    }
+}
+/**
+ * Format the context into a readable string for Claude Code
+ */
+export function formatContextForPrompt(context) {
+    const formatUserStories = (stories) => {
+        if (stories.length === 0)
+            return 'No user stories defined.';
+        return stories
+            .map((story, index) => `${index + 1}. **${story.title}** (Status: ${story.status})
+   ${story.description}`)
+            .join('\n\n');
+    };
+    const formatTestCases = (cases) => {
+        if (cases.length === 0)
+            return 'No test cases defined.';
+        return cases
+            .map((testCase, index) => `${index + 1}. **${testCase.name}** ${testCase.is_critical ? '[CRITICAL]' : '[OPTIONAL]'}
+   ${testCase.description}`)
+            .join('\n\n');
+    };
+    return `# Functional Testing Context
+
+## Feature Information
+- **ID**: ${context.feature.id}
+- **Name**: ${context.feature.name}
+- **Description**: ${context.feature.description || 'No description provided'}
+- **Current Status**: ${context.feature.status}
+
+## Product Information
+- **Product**: ${context.product.name}
+- **Product ID**: ${context.product.id}
+- **Description**: ${context.product.description || 'No product description'}
+
+## User Stories to Test (${context.user_stories.length})
+${formatUserStories(context.user_stories)}
+
+## Test Cases to Execute (${context.test_cases.length})
+${formatTestCases(context.test_cases)}
+
+---
+
+**Testing Instructions**: The feature has been implemented. Execute comprehensive functional testing using headless Playwright to verify all user stories work correctly and all test cases pass. Test both positive and negative scenarios.`;
+}

package/dist/{functional-testing → phases/functional-testing}/http-fallback.js

@@ -1,4 +1,4 @@
-import { logInfo, logError } from '../logger.js';
+import { logInfo, logError } from '../../utils/logger.js';
 export async function saveFunctionalTestResultsViaHttp(options) {
     const { mcpServerUrl, mcpToken, featureId, testStatus, testResults: _testResults, verbose, } = options;
     try {

package/dist/{functional-testing → phases/functional-testing}/index.d.ts

@@ -1,4 +1,4 @@
 export { runFunctionalTesting, checkFunctionalTestingRequirements, type FunctionalTestingOptions, type FunctionalTestingResult, } from './analyzer.js';
 export { createFunctionalTestingMcpServer } from './mcp-server.js';
 export { saveFunctionalTestResultsViaHttp, verifyTestStatusSaved, saveFunctionalTestResultsWithRetry, } from './http-fallback.js';
-export { fetchFeatureTestingContext, updateFeatureTestStatus, formatContextForPrompt, type FeatureTestingContext, } from './context-fetcher.js';
+export { fetchFunctionalTestingContext, formatContextForPrompt, type FunctionalTestingContext, } from './context-fetcher.js';

package/dist/{functional-testing → phases/functional-testing}/index.js

@@ -1,4 +1,4 @@
 export { runFunctionalTesting, checkFunctionalTestingRequirements, } from './analyzer.js';
 export { createFunctionalTestingMcpServer } from './mcp-server.js';
 export { saveFunctionalTestResultsViaHttp, verifyTestStatusSaved, saveFunctionalTestResultsWithRetry, } from './http-fallback.js';
-export { fetchFeatureTestingContext, updateFeatureTestStatus, formatContextForPrompt, } from './context-fetcher.js';
+export { fetchFunctionalTestingContext, formatContextForPrompt, } from './context-fetcher.js';

package/dist/{functional-testing → phases/functional-testing}/mcp-server.js

@@ -1,35 +1,6 @@
 import { createSdkMcpServer, tool } from '@anthropic-ai/claude-code';
 import { z } from 'zod';
-// Helper function to make HTTP requests to the MCP server
-async function callMcpEndpoint(mcpServerUrl, mcpToken, method, params) {
-    try {
-        const response = await fetch(`${mcpServerUrl}/mcp`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${mcpToken}`,
-            },
-            body: JSON.stringify({
-                jsonrpc: '2.0',
-                method,
-                params,
-                id: Math.random().toString(36).substring(7),
-            }),
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-        const data = await response.json();
-        if (data.error) {
-            throw new Error(data.error.message || 'MCP call failed');
-        }
-        return data.result;
-    }
-    catch (error) {
-        console.error(`MCP call failed for ${method}:`, error instanceof Error ? error.message : String(error));
-        throw error;
-    }
-}
+import { callMcpEndpoint } from '../../api/mcp-client.js';
 // Create an SDK MCP server with custom tools for functional testing
 export const createFunctionalTestingMcpServer = (mcpServerUrl, mcpToken) => {
     return createSdkMcpServer({

package/dist/{functional-testing → phases/functional-testing}/test-report-creator.d.ts

@@ -31,16 +31,42 @@ export interface TestReportCreateOptions {
     mcpToken: string;
     featureId: string;
     testReportData: TestReportData;
+    testResults?: TestResultInput[];
     verbose?: boolean;
 }
+export interface TestResultInput {
+    test_case_id: string;
+    result: 'passed' | 'failed' | 'skipped';
+    notes?: string;
+}
 export interface TestReportResult {
     success: boolean;
     testReport?: TestReport;
     testReportUrl?: string;
     error?: string;
 }
+export interface TestReportResultsOptions {
+    mcpServerUrl: string;
+    mcpToken: string;
+    testReportId: string;
+    testResults: TestResultInput[];
+    verbose?: boolean;
+}
+export interface TestReportResultsResponse {
+    success: boolean;
+    resultsCreated?: number;
+    error?: string;
+}
 /**
  * Create a test report via MCP endpoint
  * Uses structured data generated by Claude Code
  */
 export declare function createTestReport(options: TestReportCreateOptions): Promise<TestReportResult>;
+/**
+ * Manual fallback: Call MCP endpoint with structured data
+ * This is used when Claude Code fails to call MCP directly
+ */
+/**
+ * Create test report results via MCP endpoint
+ */
+export declare function createTestReportResults(options: TestReportResultsOptions): Promise<TestReportResultsResponse>;