@yasserkhanorg/e2e-agents 1.2.2 → 1.3.0

package/dist/qa-agent/phase2/exploration_state.js

@@ -0,0 +1,88 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExplorationState = createExplorationState;
+exports.recordAction = recordAction;
+exports.recordFinding = recordFinding;
+exports.markFlowExplored = markFlowExplored;
+exports.nextFlow = nextFlow;
+exports.isStuck = isStuck;
+exports.isBudgetExhausted = isBudgetExhausted;
+exports.allFlowsExplored = allFlowsExplored;
+exports.updateCost = updateCost;
+exports.compressActionsLog = compressActionsLog;
+const RECENT_WINDOW = 10;
+const STUCK_THRESHOLD = 3;
+function createExplorationState(flows, timeLimitMs, budgetUSD) {
+    return {
+        flowsToExplore: [...flows],
+        flowsExplored: [],
+        currentFlow: null,
+        findings: [],
+        actionsLog: [],
+        recentActions: [],
+        tokensUsed: 0,
+        costUSD: 0,
+        startTime: Date.now(),
+        timeLimitMs,
+        budgetUSD,
+    };
+}
+function recordAction(state, action) {
+    state.actionsLog.push(action);
+    state.recentActions.push(action);
+    if (state.recentActions.length > RECENT_WINDOW) {
+        state.recentActions.shift();
+    }
+}
+function recordFinding(state, finding) {
+    state.findings.push(finding);
+}
+function markFlowExplored(state, flowId) {
+    if (!state.flowsExplored.includes(flowId)) {
+        state.flowsExplored.push(flowId);
+    }
+    state.flowsToExplore = state.flowsToExplore.filter((f) => f.id !== flowId);
+    state.currentFlow = null;
+}
+function nextFlow(state) {
+    if (state.flowsToExplore.length === 0)
+        return null;
+    const flow = state.flowsToExplore[0];
+    state.currentFlow = flow.id;
+    return flow;
+}
+function isStuck(state) {
+    if (state.recentActions.length < STUCK_THRESHOLD)
+        return false;
+    const last = state.recentActions.slice(-STUCK_THRESHOLD);
+    const signature = last.map((a) => `${a.type}:${a.target || ''}:${a.value || ''}`);
+    return signature.every((s) => s === signature[0]);
+}
+function isBudgetExhausted(state) {
+    if (state.costUSD >= state.budgetUSD)
+        return true;
+    if (Date.now() - state.startTime >= state.timeLimitMs)
+        return true;
+    return false;
+}
+function allFlowsExplored(state) {
+    return state.flowsToExplore.length === 0;
+}
+function updateCost(state, inputTokens, outputTokens, cost) {
+    state.tokensUsed += inputTokens + outputTokens;
+    state.costUSD += cost;
+}
+function compressActionsLog(state, summaryText) {
+    // Replace all but the most recent 10 actions with a summary marker
+    if (state.actionsLog.length <= 20)
+        return;
+    const recent = state.actionsLog.slice(-10);
+    const compressed = {
+        type: 'compressed',
+        value: `[Compressed ${state.actionsLog.length - 10} earlier actions] ${summaryText}`,
+        timestamp: Date.now(),
+    };
+    state.actionsLog = [compressed, ...recent];
+}

package/dist/qa-agent/phase2/tools.d.ts

@@ -0,0 +1,28 @@
+import type Anthropic from '@anthropic-ai/sdk';
+import type { AgentBrowser } from './agent_browser.js';
+import type { Finding } from '../types.js';
+export declare const TOOL_DEFINITIONS: Anthropic.Tool[];
+export interface ToolContext {
+    browser: AgentBrowser;
+    baseUrl: string;
+    screenshotDir: string;
+    screenshotCounter: number;
+    currentUrl: string;
+    currentFlow: string;
+    users?: Array<{
+        role: string;
+        username: string;
+        password: string;
+    }>;
+}
+export interface ToolResult {
+    output: string;
+    finding?: Finding;
+    flowDone?: {
+        flowId: string;
+        status: 'verified-ok' | 'has-issues';
+    };
+    navigated?: boolean;
+}
+export declare function executeTool(ctx: ToolContext, name: string, input: Record<string, unknown>): ToolResult;
+//# sourceMappingURL=tools.d.ts.map

package/dist/qa-agent/phase2/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/qa-agent/phase2/tools.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,SAAS,MAAM,mBAAmB,CAAC;AAE/C,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAC,OAAO,EAA+B,MAAM,aAAa,CAAC;AAMvE,eAAO,MAAM,gBAAgB,EAAE,SAAS,CAAC,IAAI,EAkI5C,CAAC;AAMF,MAAM,WAAW,WAAW;IACxB,OAAO,EAAE,YAAY,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;CACrE;AAED,MAAM,WAAW,UAAU;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,aAAa,GAAG,YAAY,CAAA;KAAC,CAAC;IAClE,SAAS,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,wBAAgB,WAAW,CACvB,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,UAAU,CAqIZ"}

package/dist/qa-agent/phase2/tools.js

@@ -0,0 +1,292 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_DEFINITIONS = void 0;
+exports.executeTool = executeTool;
+// ---------------------------------------------------------------------------
+// Tool definitions (Anthropic tool_use schema)
+// ---------------------------------------------------------------------------
+exports.TOOL_DEFINITIONS = [
+    {
+        name: 'navigate',
+        description: 'Navigate to a URL. Use absolute paths starting with / or full URLs.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'URL or path to navigate to' },
+            },
+            required: ['url'],
+        },
+    },
+    {
+        name: 'click',
+        description: 'Click an element by its accessibility ref (e.g. @e4).',
+        input_schema: {
+            type: 'object',
+            properties: {
+                ref: { type: 'string', description: 'Accessibility ref like @e4' },
+            },
+            required: ['ref'],
+        },
+    },
+    {
+        name: 'fill',
+        description: 'Clear a field and type new text into it.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                ref: { type: 'string', description: 'Accessibility ref of the input field' },
+                value: { type: 'string', description: 'Text to type' },
+            },
+            required: ['ref', 'value'],
+        },
+    },
+    {
+        name: 'press_key',
+        description: 'Press a keyboard key (e.g. Enter, Escape, Tab).',
+        input_schema: {
+            type: 'object',
+            properties: {
+                key: { type: 'string', description: 'Key name (Enter, Escape, Tab, etc.)' },
+            },
+            required: ['key'],
+        },
+    },
+    {
+        name: 'scroll',
+        description: 'Scroll the page or a specific element up or down.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                direction: { type: 'string', enum: ['up', 'down'] },
+                ref: { type: 'string', description: 'Optional element ref to scroll within' },
+            },
+            required: ['direction'],
+        },
+    },
+    {
+        name: 'go_back',
+        description: 'Go back to the previous page.',
+        input_schema: {
+            type: 'object',
+            properties: {},
+            required: [],
+        },
+    },
+    {
+        name: 'take_screenshot',
+        description: 'Take an annotated screenshot for evidence or vision analysis. Use sparingly (costs tokens).',
+        input_schema: {
+            type: 'object',
+            properties: {
+                label: { type: 'string', description: 'Short label for the screenshot (used in filename)' },
+            },
+            required: ['label'],
+        },
+    },
+    {
+        name: 'get_text',
+        description: 'Read the text content of a specific element.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                ref: { type: 'string', description: 'Accessibility ref' },
+            },
+            required: ['ref'],
+        },
+    },
+    {
+        name: 'report_finding',
+        description: 'Report a bug, visual issue, UX problem, or gap you discovered. Always include current URL and repro steps.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                type: { type: 'string', enum: ['bug', 'visual-regression', 'ux-issue', 'gap'] },
+                severity: { type: 'string', enum: ['critical', 'high', 'medium', 'low', 'info'] },
+                summary: { type: 'string', description: 'What you found' },
+                repro_steps: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Steps to reproduce',
+                },
+            },
+            required: ['type', 'severity', 'summary', 'repro_steps'],
+        },
+    },
+    {
+        name: 'mark_flow_done',
+        description: 'Mark the current flow as verified/explored. Call when you are done testing a flow.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                flow_id: { type: 'string', description: 'ID of the flow being marked done' },
+                status: { type: 'string', enum: ['verified-ok', 'has-issues'] },
+            },
+            required: ['flow_id', 'status'],
+        },
+    },
+    {
+        name: 'switch_user',
+        description: 'Log out and log in as a different user role.',
+        input_schema: {
+            type: 'object',
+            properties: {
+                role: { type: 'string', description: 'Role of the user to switch to (e.g. admin, regular, guest)' },
+            },
+            required: ['role'],
+        },
+    },
+];
+function executeTool(ctx, name, input) {
+    switch (name) {
+        case 'navigate': {
+            const url = String(input.url || '');
+            const fullUrl = url.startsWith('http') ? url : `${ctx.baseUrl}${url}`;
+            // Security: restrict navigation to the configured baseUrl domain
+            if (!isAllowedUrl(fullUrl, ctx.baseUrl)) {
+                return { output: `Blocked: navigation to "${fullUrl}" is outside the allowed domain (${ctx.baseUrl}).` };
+            }
+            const output = ctx.browser.open(fullUrl);
+            ctx.currentUrl = ctx.browser.getUrl();
+            return { output: output || `Navigated to ${ctx.currentUrl}`, navigated: true };
+        }
+        case 'click': {
+            const output = ctx.browser.click(String(input.ref));
+            return { output: output || `Clicked ${input.ref}` };
+        }
+        case 'fill': {
+            const ref = String(input.ref);
+            const value = String(input.value);
+            const output = ctx.browser.fill(ref, value);
+            // Redact value for password-like fields to avoid leaking credentials to LLM
+            const isSensitive = /password|passwd|pwd|secret|token/i.test(ref);
+            const displayValue = isSensitive ? '[REDACTED]' : `"${value}"`;
+            return { output: output || `Filled ${ref} with ${displayValue}` };
+        }
+        case 'press_key': {
+            const output = ctx.browser.press(String(input.key));
+            return { output: output || `Pressed ${input.key}` };
+        }
+        case 'scroll': {
+            const rawDir = String(input.direction);
+            if (rawDir !== 'up' && rawDir !== 'down') {
+                return { output: `Invalid scroll direction "${rawDir}". Must be "up" or "down".` };
+            }
+            const ref = input.ref ? String(input.ref) : undefined;
+            const output = ctx.browser.scroll(rawDir, ref);
+            return { output: output || `Scrolled ${rawDir}` };
+        }
+        case 'go_back': {
+            const output = ctx.browser.back();
+            ctx.currentUrl = ctx.browser.getUrl();
+            return { output: output || `Went back to ${ctx.currentUrl}` };
+        }
+        case 'take_screenshot': {
+            ctx.screenshotCounter++;
+            const label = String(input.label || 'evidence').replace(/[^a-zA-Z0-9_-]/g, '_');
+            const filename = `${String(ctx.screenshotCounter).padStart(3, '0')}-${label}.png`;
+            const path = `${ctx.screenshotDir}/${filename}`;
+            ctx.browser.screenshot(path);
+            return { output: `Screenshot saved: ${path}` };
+        }
+        case 'get_text': {
+            const text = ctx.browser.getText(String(input.ref));
+            return { output: text || '(empty)' };
+        }
+        case 'report_finding': {
+            const VALID_TYPES = new Set(['bug', 'visual-regression', 'ux-issue', 'gap']);
+            const VALID_SEVERITIES = new Set(['critical', 'high', 'medium', 'low', 'info']);
+            const rawType = String(input.type);
+            const rawSeverity = String(input.severity);
+            if (!VALID_TYPES.has(rawType)) {
+                return { output: `Invalid finding type "${rawType}". Must be one of: ${[...VALID_TYPES].join(', ')}.` };
+            }
+            if (!VALID_SEVERITIES.has(rawSeverity)) {
+                return { output: `Invalid severity "${rawSeverity}". Must be one of: ${[...VALID_SEVERITIES].join(', ')}.` };
+            }
+            if (!Array.isArray(input.repro_steps)) {
+                return { output: `Invalid repro_steps: expected an array of strings.` };
+            }
+            const finding = {
+                id: `f-${crypto.randomUUID()}`,
+                type: rawType,
+                severity: rawSeverity,
+                summary: String(input.summary),
+                flow: ctx.currentFlow,
+                evidence: {
+                    url: ctx.currentUrl,
+                    reproSteps: input.repro_steps.map(String),
+                },
+                timestamp: Date.now(),
+            };
+            return { output: `Finding recorded: [${finding.severity}] ${finding.summary}`, finding };
+        }
+        case 'mark_flow_done': {
+            const flowId = String(input.flow_id);
+            const rawStatus = String(input.status);
+            if (rawStatus !== 'verified-ok' && rawStatus !== 'has-issues') {
+                return { output: `Invalid status "${rawStatus}". Must be "verified-ok" or "has-issues".` };
+            }
+            return {
+                output: `Flow "${flowId}" marked as ${rawStatus}`,
+                flowDone: { flowId, status: rawStatus },
+            };
+        }
+        case 'switch_user': {
+            const role = String(input.role);
+            const user = ctx.users?.find((u) => u.role === role);
+            if (!user) {
+                return { output: `No user configured for role "${role}". Available: ${(ctx.users || []).map((u) => u.role).join(', ')}` };
+            }
+            // Log out first, then log in as new user
+            try {
+                ctx.browser.open(`${ctx.baseUrl}/logout`);
+            }
+            catch {
+                // May not be logged in
+            }
+            ctx.browser.open(`${ctx.baseUrl}/login`);
+            // Use snapshot to find login fields, then fill
+            const snap = ctx.browser.snapshot();
+            const emailRef = extractRef(snap, 'email') || extractRef(snap, 'username') || '@e1';
+            const passRef = extractRef(snap, 'password') || '@e2';
+            ctx.browser.fill(emailRef, user.username);
+            ctx.browser.fill(passRef, user.password);
+            ctx.browser.press('Enter');
+            ctx.currentUrl = ctx.browser.getUrl();
+            // Redact credentials from LLM context — only expose role
+            return { output: `Switched to user role: ${user.role}` };
+        }
+        default:
+            return { output: `Unknown tool: ${name}` };
+    }
+}
+function isAllowedUrl(url, baseUrl) {
+    // Block dangerous schemes
+    const scheme = url.split(':')[0]?.toLowerCase();
+    if (scheme && !['http', 'https'].includes(scheme))
+        return false;
+    // Parse both URLs and compare origins (hostname + port)
+    try {
+        const target = new URL(url);
+        const base = new URL(baseUrl);
+        return target.origin === base.origin;
+    }
+    catch {
+        // If URL parsing fails, only allow relative paths (already prefixed with baseUrl)
+        return url.startsWith(baseUrl);
+    }
+}
+function extractRef(snapshot, fieldHint) {
+    // Look for lines containing the hint and extract the @eN ref
+    const lines = snapshot.split('\n');
+    for (const line of lines) {
+        if (line.toLowerCase().includes(fieldHint)) {
+            const match = line.match(/@e\d+/);
+            if (match)
+                return match[0];
+        }
+    }
+    return undefined;
+}

package/dist/qa-agent/phase2/vision.d.ts

@@ -0,0 +1,3 @@
+import type { Finding } from '../types.js';
+export declare function analyzeScreenshot(screenshotPath: string, url: string, flow: string): Promise<Finding[]>;
+//# sourceMappingURL=vision.d.ts.map

package/dist/qa-agent/phase2/vision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vision.d.ts","sourceRoot":"","sources":["../../../src/qa-agent/phase2/vision.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,OAAO,EAA+B,MAAM,aAAa,CAAC;AA2BvE,wBAAsB,iBAAiB,CACnC,cAAc,EAAE,MAAM,EACtB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,GACb,OAAO,CAAC,OAAO,EAAE,CAAC,CAoBpB"}

package/dist/qa-agent/phase2/vision.js

@@ -0,0 +1,78 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeScreenshot = analyzeScreenshot;
+const fs_1 = require("fs");
+const provider_factory_js_1 = require("../../provider_factory.js");
+const VALID_TYPES = new Set(['bug', 'visual-regression', 'ux-issue', 'gap']);
+const VALID_SEVERITIES = new Set(['critical', 'high', 'medium', 'low', 'info']);
+const VISION_PROMPT = `You are a QA engineer analyzing a screenshot of a web application.
+Look for these categories of issues:
+
+1. **Layout issues**: overlapping elements, misaligned content, broken grid, elements outside viewport
+2. **Visual issues**: truncated text, missing icons/images, broken styling, inconsistent spacing
+3. **UX issues**: unclear button labels, confusing navigation, missing feedback states, poor contrast
+4. **State issues**: loading spinners stuck, empty states without messaging, stale data indicators
+5. **Error states**: visible error messages, 404/500 pages, broken components
+
+For each issue found, respond with a JSON array of objects:
+[
+  {
+    "type": "bug" | "visual-regression" | "ux-issue",
+    "severity": "critical" | "high" | "medium" | "low" | "info",
+    "summary": "description of the issue"
+  }
+]
+
+If no issues are found, respond with an empty array: []
+
+Only report clear, actionable issues. Do not speculate about functionality you cannot see.`;
+async function analyzeScreenshot(screenshotPath, url, flow) {
+    const provider = await provider_factory_js_1.LLMProviderFactory.createFromEnv();
+    if (!provider.capabilities.vision || !provider.analyzeImage) {
+        return [];
+    }
+    let imageData;
+    try {
+        imageData = (0, fs_1.readFileSync)(screenshotPath).toString('base64');
+    }
+    catch {
+        return [];
+    }
+    const response = await provider.analyzeImage([{ base64: imageData, mediaType: 'image/png' }], VISION_PROMPT, { maxTokens: 2000, temperature: 0.1 });
+    return parseVisionResponse(response.text, url, flow, screenshotPath);
+}
+function parseVisionResponse(text, url, flow, screenshotPath) {
+    // Extract JSON array from response
+    const jsonMatch = text.match(/\[[\s\S]*\]/);
+    if (!jsonMatch)
+        return [];
+    try {
+        const items = JSON.parse(jsonMatch[0]);
+        if (!Array.isArray(items))
+            return [];
+        return items
+            .filter((item) => {
+            const t = String(item.type || '');
+            const s = String(item.severity || '');
+            return VALID_TYPES.has(t) && VALID_SEVERITIES.has(s);
+        })
+            .map((item) => ({
+            id: `v-${Date.now()}-${crypto.randomUUID().slice(0, 8)}`,
+            type: String(item.type),
+            severity: String(item.severity),
+            summary: String(item.summary || 'Visual issue detected'),
+            flow,
+            evidence: {
+                url,
+                screenshotPath,
+                reproSteps: ['Captured via automated vision analysis'],
+            },
+            timestamp: Date.now(),
+        }));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/qa-agent/phase3/feedback.d.ts

@@ -0,0 +1,3 @@
+import type { QAConfig } from '../types.js';
+export declare function submitFeedback(config: QAConfig): void;
+//# sourceMappingURL=feedback.d.ts.map

package/dist/qa-agent/phase3/feedback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feedback.d.ts","sourceRoot":"","sources":["../../../src/qa-agent/phase3/feedback.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,aAAa,CAAC;AAE1C,wBAAgB,cAAc,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI,CA8BrD"}

package/dist/qa-agent/phase3/feedback.js

@@ -0,0 +1,37 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.submitFeedback = submitFeedback;
+const child_process_1 = require("child_process");
+const logger_js_1 = require("../../logger.js");
+const safe_env_js_1 = require("../safe_env.js");
+function submitFeedback(config) {
+    const args = ['e2e-ai-agents', 'feedback'];
+    if (config.testsRoot) {
+        args.push('--tests-root', config.testsRoot);
+    }
+    logger_js_1.logger.info('Submitting feedback to calibration system');
+    const result = (0, child_process_1.spawnSync)('npx', args, {
+        cwd: config.testsRoot || process.cwd(),
+        encoding: 'utf-8',
+        timeout: 30000,
+        env: (0, safe_env_js_1.safeEnv)(),
+    });
+    if (result.error) {
+        logger_js_1.logger.warn('Feedback submission spawn failed', {
+            error: result.error.message,
+        });
+    }
+    else if (result.signal) {
+        logger_js_1.logger.warn('Feedback submission killed by signal', {
+            signal: result.signal,
+        });
+    }
+    else if (result.status !== 0) {
+        logger_js_1.logger.warn('Feedback submission failed', {
+            status: result.status,
+            stderr: (result.stderr || '').slice(0, 200),
+        });
+    }
+}

package/dist/qa-agent/phase3/reporter.d.ts

@@ -0,0 +1,3 @@
+import type { Phase1Result, Phase2Result, Phase3Result, QAConfig, ReleaseVerdict } from '../types.js';
+export declare function generateReport(config: QAConfig, phase1: Phase1Result, phase2: Phase2Result, verdict: ReleaseVerdict, generatedSpecs: string[]): Phase3Result;
+//# sourceMappingURL=reporter.d.ts.map

package/dist/qa-agent/phase3/reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reporter.d.ts","sourceRoot":"","sources":["../../../src/qa-agent/phase3/reporter.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAY,cAAc,EAAC,MAAM,aAAa,CAAC;AAE9G,wBAAgB,cAAc,CAC1B,MAAM,EAAE,QAAQ,EAChB,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,cAAc,EACvB,cAAc,EAAE,MAAM,EAAE,GACzB,YAAY,CA8Cd"}

package/dist/qa-agent/phase3/reporter.js

@@ -0,0 +1,121 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateReport = generateReport;
+const fs_1 = require("fs");
+const path_1 = require("path");
+function generateReport(config, phase1, phase2, verdict, generatedSpecs) {
+    const outputDir = config.outputDir || '.e2e-ai-agents';
+    (0, fs_1.mkdirSync)(outputDir, { recursive: true });
+    const reportPath = (0, path_1.join)(outputDir, 'qa-report.json');
+    const summaryPath = (0, path_1.join)(outputDir, 'qa-summary.md');
+    const report = {
+        schemaVersion: '1.0.0',
+        generatedAt: new Date().toISOString(),
+        mode: config.mode,
+        config: {
+            baseUrl: config.baseUrl,
+            timeLimitMinutes: config.timeLimitMinutes,
+            budgetUSD: config.budgetUSD,
+        },
+        phase1,
+        phase2,
+        phase3: {
+            reportPath,
+            summaryPath,
+            verdict,
+            generatedSpecs,
+        },
+        verdict,
+    };
+    try {
+        (0, fs_1.writeFileSync)(reportPath, JSON.stringify(report, null, 2), 'utf-8');
+    }
+    catch (err) {
+        throw new Error(`Failed to write report to ${reportPath}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const markdown = renderMarkdown(report);
+    try {
+        (0, fs_1.writeFileSync)(summaryPath, markdown, 'utf-8');
+    }
+    catch (err) {
+        throw new Error(`Failed to write summary to ${summaryPath}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return {
+        reportPath,
+        summaryPath,
+        verdict,
+        generatedSpecs,
+    };
+}
+function renderMarkdown(report) {
+    const v = report.verdict;
+    const badge = v.decision === 'go' ? '✅ GO' : v.decision === 'no-go' ? '❌ NO-GO' : '⚠️ CONDITIONAL';
+    const lines = [
+        `# QA Agent Report — ${badge}`,
+        '',
+        `**Mode:** ${report.mode}`,
+        `**Base URL:** ${report.config.baseUrl}`,
+        `**Generated:** ${report.generatedAt}`,
+        '',
+        `## Verdict`,
+        '',
+        `**Decision:** ${badge}`,
+        `**Reason:** ${v.reason}`,
+        '',
+        `| Severity | Count |`,
+        `|----------|-------|`,
+        `| Critical | ${v.criticalFindings} |`,
+        `| High | ${v.highFindings} |`,
+        `| Medium | ${v.mediumFindings} |`,
+        `| Low | ${v.lowFindings} |`,
+        '',
+    ];
+    // Phase 1 summary
+    const specTotal = report.phase1.specResults.length;
+    const specPassed = report.phase1.specResults.reduce((s, r) => s + r.passed, 0);
+    const specFailed = report.phase1.specResults.reduce((s, r) => s + r.failed, 0);
+    lines.push(`## Phase 1: Scripted Tests`, '', `- Flows identified: ${report.phase1.flows.length}`, `- Specs run: ${specTotal} (${specPassed} passed, ${specFailed} failed)`, '');
+    // Phase 2 summary
+    lines.push(`## Phase 2: Autonomous Exploration`, '', `- Flows explored: ${report.phase2.flowsExplored.length}`, `- Actions taken: ${report.phase2.actionsCount}`, `- Duration: ${Math.round(report.phase2.durationMs / 1000)}s`, `- Cost: $${report.phase2.costUSD.toFixed(4)}`, `- Tokens: ${report.phase2.tokensUsed}`, '');
+    // Findings
+    if (report.phase2.findings.length > 0) {
+        lines.push(`## Findings`, '');
+        for (const f of report.phase2.findings) {
+            lines.push(`### [${f.severity.toUpperCase()}] ${f.summary}`);
+            lines.push('');
+            lines.push(`- **Type:** ${f.type}`);
+            lines.push(`- **Flow:** ${f.flow}`);
+            lines.push(`- **URL:** ${f.evidence.url}`);
+            if (f.evidence.screenshotPath) {
+                lines.push(`- **Screenshot:** ${f.evidence.screenshotPath}`);
+            }
+            if (f.evidence.reproSteps.length > 0) {
+                lines.push('- **Repro steps:**');
+                for (const step of f.evidence.reproSteps) {
+                    lines.push(`  1. ${step}`);
+                }
+            }
+            lines.push('');
+        }
+    }
+    // Flow sign-offs
+    lines.push(`## Flow Sign-offs`, '');
+    lines.push(`| Flow | Status | Findings |`);
+    lines.push(`|------|--------|----------|`);
+    for (const s of v.flowSignoffs) {
+        const statusIcon = s.status === 'passed' ? '✅' : s.status === 'failed' ? '❌' : '⏭️';
+        lines.push(`| ${s.flowName} | ${statusIcon} ${s.status} | ${s.findings.length} |`);
+    }
+    lines.push('');
+    // Generated specs
+    if (report.phase3.generatedSpecs.length > 0) {
+        lines.push(`## Generated Specs`, '');
+        for (const spec of report.phase3.generatedSpecs) {
+            lines.push(`- ${spec}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}