@diyor28/qa-core 0.1.0

package/dist/agent/tools/index.js

@@ -0,0 +1,152 @@
+import { z } from 'zod';
+export function createAgentTools(browserController, visionAnalyzer) {
+    return {
+        navigate: {
+            description: 'Navigate to a URL',
+            parameters: z.object({
+                url: z.string().describe('The URL to navigate to'),
+            }),
+            execute: async ({ url }) => {
+                return await browserController.navigate(url);
+            },
+        },
+        click: {
+            description: 'Click an element by selector or text. Use role:button, text:Login, or CSS selectors.',
+            parameters: z.object({
+                selector: z.string().describe('CSS selector, role:type, or text:content to find the element'),
+            }),
+            execute: async ({ selector }) => {
+                return await browserController.click(selector);
+            },
+        },
+        fill: {
+            description: 'Fill an input field with a value',
+            parameters: z.object({
+                selector: z.string().describe('Selector for the input field'),
+                value: z.string().describe('Value to fill'),
+            }),
+            execute: async ({ selector, value }) => {
+                return await browserController.fill(selector, value);
+            },
+        },
+        type: {
+            description: 'Type text into an element with key events (simulates typing)',
+            parameters: z.object({
+                selector: z.string().describe('Selector for the element'),
+                text: z.string().describe('Text to type'),
+            }),
+            execute: async ({ selector, text }) => {
+                return await browserController.type(selector, text);
+            },
+        },
+        screenshot: {
+            description: 'Take a screenshot with a descriptive name',
+            parameters: z.object({
+                name: z.string().describe('Descriptive name for the screenshot (e.g., "login-page", "after-submit")'),
+                context: z.string().optional().describe('What is happening in this screenshot'),
+            }),
+            execute: async ({ name, context }) => {
+                return await browserController.screenshot(name, context);
+            },
+        },
+        analyze_ui_ux: {
+            description: 'Analyze the current or a specific screenshot for UX/UI issues using AI vision. Returns findings about visual overflow, poor contrast, bad UX, and accessibility.',
+            parameters: z.object({
+                screenshotName: z
+                    .string()
+                    .optional()
+                    .describe('Name of specific screenshot to analyze. If omitted, analyzes the most recent screenshot.'),
+                focus: z
+                    .enum(['visual', 'accessibility', 'ux', 'all'])
+                    .optional()
+                    .default('all')
+                    .describe('What aspect to focus the analysis on'),
+            }),
+            execute: async ({ screenshotName, focus }) => {
+                // Get screenshot from history
+                let screenshot = screenshotName
+                    ? browserController.getScreenshotByName(screenshotName)
+                    : browserController.getLatestScreenshot();
+                if (!screenshot) {
+                    // No screenshot available, take one automatically
+                    await browserController.screenshot('auto-capture', 'Auto-captured for UX analysis');
+                    screenshot = browserController.getLatestScreenshot();
+                    if (!screenshot) {
+                        return { error: 'Failed to capture screenshot' };
+                    }
+                }
+                // Analyze with Gemini
+                const findings = await visionAnalyzer.analyzeScreenshot(screenshot.buffer, screenshot.context, screenshot.url);
+                return {
+                    findings,
+                    analyzed_screenshot: screenshot.name,
+                    analyzed_url: screenshot.url,
+                };
+            },
+        },
+        assert_visible: {
+            description: 'Assert that an element is visible on the page',
+            parameters: z.object({
+                selector: z.string().describe('Selector for the element'),
+            }),
+            execute: async ({ selector }) => {
+                return await browserController.assertVisible(selector);
+            },
+        },
+        assert_text: {
+            description: 'Assert that an element contains specific text',
+            parameters: z.object({
+                selector: z.string().describe('Selector for the element'),
+                expected: z.string().describe('Expected text content'),
+            }),
+            execute: async ({ selector, expected }) => {
+                return await browserController.assertText(selector, expected);
+            },
+        },
+        get_text: {
+            description: 'Get text content from an element',
+            parameters: z.object({
+                selector: z.string().describe('Selector for the element'),
+            }),
+            execute: async ({ selector }) => {
+                return await browserController.getText(selector);
+            },
+        },
+        wait_for: {
+            description: 'Wait for an element to appear on the page',
+            parameters: z.object({
+                selector: z.string().describe('Selector for the element'),
+                timeout: z.number().optional().default(5000).describe('Timeout in milliseconds'),
+            }),
+            execute: async ({ selector, timeout }) => {
+                return await browserController.waitFor(selector, timeout);
+            },
+        },
+        scroll: {
+            description: 'Scroll the page up or down',
+            parameters: z.object({
+                direction: z.enum(['up', 'down']).describe('Scroll direction'),
+                amount: z.number().optional().describe('Scroll amount in pixels (default: 500)'),
+            }),
+            execute: async ({ direction, amount }) => {
+                return await browserController.scroll(direction, amount);
+            },
+        },
+        evaluate_js: {
+            description: 'Execute JavaScript code in the browser context',
+            parameters: z.object({
+                code: z.string().describe('JavaScript code to execute'),
+            }),
+            execute: async ({ code }) => {
+                return await browserController.evaluateJs(code);
+            },
+        },
+        accessibility_snapshot: {
+            description: 'Capture an accessibility tree snapshot for analysis',
+            parameters: z.object({}),
+            execute: async () => {
+                return await browserController.accessibilitySnapshot();
+            },
+        },
+    };
+}

package/dist/browser/controller.d.ts

@@ -0,0 +1,82 @@
+import type { ScreenshotEntry } from '../types.js';
+export interface BrowserControllerConfig {
+    headless?: boolean;
+    viewport: {
+        width: number;
+        height: number;
+    };
+    enableTrace?: boolean;
+    traceDir?: string;
+}
+export declare class BrowserController {
+    private browser;
+    private context;
+    private page;
+    private screenshotHistory;
+    private config;
+    constructor(config: BrowserControllerConfig);
+    launch(): Promise<void>;
+    close(): Promise<void>;
+    navigate(url: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    click(selector: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    fill(selector: string, value: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    type(selector: string, text: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    screenshot(name: string, context?: string): Promise<{
+        success: boolean;
+        message: string;
+        screenshotName: string;
+    }>;
+    assertVisible(selector: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    assertText(selector: string, expected: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    waitFor(selector: string, timeout?: number): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    getText(selector: string): Promise<{
+        success: boolean;
+        message: string;
+        text?: string;
+    }>;
+    scroll(direction: 'up' | 'down', amount?: number): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    evaluateJs(code: string): Promise<{
+        success: boolean;
+        message: string;
+        result?: any;
+    }>;
+    accessibilitySnapshot(): Promise<{
+        success: boolean;
+        message: string;
+        snapshot?: any;
+    }>;
+    getLatestScreenshot(): ScreenshotEntry | null;
+    getScreenshotByName(name: string): ScreenshotEntry | null;
+    getAllScreenshots(): ScreenshotEntry[];
+    getCurrentUrl(): string;
+    getViewport(): {
+        width: number;
+        height: number;
+    };
+    getScreenshotCount(): number;
+}
+//# sourceMappingURL=controller.d.ts.map

package/dist/browser/controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../src/browser/controller.ts"],"names":[],"mappings":"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"}

package/dist/browser/controller.js

@@ -0,0 +1,289 @@
+import { chromium } from 'playwright';
+export class BrowserController {
+    browser = null;
+    context = null;
+    page = null;
+    screenshotHistory = [];
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async launch() {
+        this.browser = await chromium.launch({
+            headless: this.config.headless ?? true,
+        });
+        this.context = await this.browser.newContext({
+            viewport: this.config.viewport,
+        });
+        if (this.config.enableTrace) {
+            await this.context.tracing.start({
+                screenshots: true,
+                snapshots: true,
+                sources: true,
+            });
+        }
+        this.page = await this.context.newPage();
+    }
+    async close() {
+        if (this.config.enableTrace && this.context) {
+            const tracePath = `${this.config.traceDir}/trace-${Date.now()}.zip`;
+            await this.context.tracing.stop({ path: tracePath });
+        }
+        await this.context?.close();
+        await this.browser?.close();
+    }
+    async navigate(url) {
+        if (!this.page)
+            throw new Error('Browser not launched');
+        try {
+            await this.page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30000 });
+            return { success: true, message: `Navigated to ${url}` };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to navigate to ${url}: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    async click(selector) {
+        if (!this.page)
+            throw new Error('Browser not launched');
+        try {
+            // Try intelligent locator strategies
+            let element = null;
+            // Strategy 1: getByRole
+            if (selector.includes('role:')) {
+                const role = selector.replace('role:', '');
+                element = this.page.getByRole(role);
+            }
+            // Strategy 2: getByText
+            else if (selector.includes('text:')) {
+                const text = selector.replace('text:', '');
+                element = this.page.getByText(text);
+            }
+            // Strategy 3: CSS/XPath
+            else {
+                element = this.page.locator(selector);
+            }
+            await element.click({ timeout: 10000 });
+            return { success: true, message: `Clicked ${selector}` };
+        }
+        catch (error) {
+            // Retry with alternative strategies
+            try {
+                await this.page.locator(selector).first().click({ timeout: 5000 });
+                return { success: true, message: `Clicked ${selector} (fallback)` };
+            }
+            catch {
+                return {
+                    success: false,
+                    message: `Failed to click ${selector}: ${error instanceof Error ? error.message : String(error)}`,
+                };
+            }
+        }
+    }
+    async fill(selector, value) {
+        if (!this.page)
+            throw new Error('Browser not launched');
+        try {
+            await this.page.locator(selector).fill(value, { timeout: 10000 });
+            return { success: true, message: `Filled ${selector} with "${value}"` };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to fill ${selector}: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    async type(selector, text) {
+        if (!this.page)
+            throw new Error('Browser not launched');
+        try {
+            await this.page.locator(selector).pressSequentially(text, { timeout: 10000 });
+            return { success: true, message: `Typed "${text}" into ${selector}` };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to type into ${selector}: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    async screenshot(name, context) {
+        if (!this.page)
+            throw new Error('Browser not launched');
+        try {
+            const buffer = await this.page.screenshot({ fullPage: false });
+            const url = this.page.url();
+            this.screenshotHistory.push({
+                timestamp: Date.now(),
+                name,
+                buffer,
+                context: context || `Screenshot: ${name}`,
+                url,
+            });
+            return { success: true, message: `Captured screenshot: ${name}`, screenshotName: name };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to capture screenshot: ${error instanceof Error ? error.message : String(error)}`,
+                screenshotName: name,
+            };
+        }
+    }
+    async assertVisible(selector) {
+        if (!this.page)
+            throw new Error('Browser not launched');
+        try {
+            const element = this.page.locator(selector);
+            await element.waitFor({ state: 'visible', timeout: 10000 });
+            const isVisible = await element.isVisible();
+            if (isVisible) {
+                return { success: true, message: `Element ${selector} is visible` };
+            }
+            else {
+                return { success: false, message: `Element ${selector} is not visible` };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Element ${selector} not found or not visible: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    async assertText(selector, expected) {
+        if (!this.page)
+            throw new Error('Browser not launched');
+        try {
+            const element = this.page.locator(selector);
+            const actual = await element.textContent();
+            if (actual?.includes(expected)) {
+                return { success: true, message: `Text "${expected}" found in ${selector}` };
+            }
+            else {
+                return {
+                    success: false,
+                    message: `Expected "${expected}" but got "${actual}" in ${selector}`,
+                };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to assert text in ${selector}: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    async waitFor(selector, timeout = 5000) {
+        if (!this.page)
+            throw new Error('Browser not launched');
+        try {
+            await this.page.locator(selector).waitFor({ state: 'visible', timeout });
+            return { success: true, message: `Element ${selector} appeared` };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Element ${selector} did not appear within ${timeout}ms`,
+            };
+        }
+    }
+    async getText(selector) {
+        if (!this.page)
+            throw new Error('Browser not launched');
+        try {
+            const text = await this.page.locator(selector).textContent();
+            return { success: true, message: `Got text from ${selector}`, text: text || '' };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to get text from ${selector}: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    async scroll(direction, amount) {
+        if (!this.page)
+            throw new Error('Browser not launched');
+        try {
+            const delta = amount || 500;
+            const scrollAmount = direction === 'down' ? delta : -delta;
+            await this.page.evaluate((scroll) => {
+                window.scrollBy(0, scroll);
+            }, scrollAmount);
+            return { success: true, message: `Scrolled ${direction} by ${Math.abs(scrollAmount)}px` };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to scroll: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    async evaluateJs(code) {
+        if (!this.page)
+            throw new Error('Browser not launched');
+        try {
+            const result = await this.page.evaluate((jsCode) => {
+                return eval(jsCode);
+            }, code);
+            return { success: true, message: 'JavaScript executed', result };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to execute JavaScript: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    async accessibilitySnapshot() {
+        if (!this.page)
+            throw new Error('Browser not launched');
+        try {
+            // Get ARIA tree via evaluate
+            const snapshot = await this.page.evaluate(() => {
+                const getAriaTree = (element) => {
+                    const role = element.getAttribute('role');
+                    const ariaLabel = element.getAttribute('aria-label');
+                    const ariaLabelledby = element.getAttribute('aria-labelledby');
+                    return {
+                        role: role || element.tagName.toLowerCase(),
+                        name: ariaLabel || ariaLabelledby || element.textContent?.substring(0, 50),
+                        children: Array.from(element.children).map((child) => getAriaTree(child)),
+                    };
+                };
+                return getAriaTree(document.body);
+            });
+            return { success: true, message: 'Accessibility snapshot captured', snapshot };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to capture accessibility snapshot: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    // Screenshot history access methods
+    getLatestScreenshot() {
+        return this.screenshotHistory[this.screenshotHistory.length - 1] || null;
+    }
+    getScreenshotByName(name) {
+        return this.screenshotHistory.find((s) => s.name === name) || null;
+    }
+    getAllScreenshots() {
+        return [...this.screenshotHistory];
+    }
+    getCurrentUrl() {
+        return this.page?.url() || '';
+    }
+    getViewport() {
+        return this.config.viewport;
+    }
+    getScreenshotCount() {
+        return this.screenshotHistory.length;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { QaRunner } from './runner.js';
+export type { QaScenario, QaFinding, QaArtifact, QaReport, QaProgressEvent, QaRunnerConfig, ScreenshotEntry, } from './types.js';
+export { BrowserController } from './browser/controller.js';
+export { VisionAnalyzer } from './vision/analyzer.js';
+export { AgentLoop } from './agent/loop.js';
+export { ReportBuilder } from './report/builder.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGvC,YAAY,EACV,UAAU,EACV,SAAS,EACT,UAAU,EACV,QAAQ,EACR,eAAe,EACf,cAAc,EACd,eAAe,GAChB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+// Main exports
+export { QaRunner } from './runner.js';
+// Component exports (for advanced usage)
+export { BrowserController } from './browser/controller.js';
+export { VisionAnalyzer } from './vision/analyzer.js';
+export { AgentLoop } from './agent/loop.js';
+export { ReportBuilder } from './report/builder.js';

package/dist/report/builder.d.ts

@@ -0,0 +1,23 @@
+import type { QaReport, QaFinding, QaArtifact } from '../types.js';
+export interface BuildReportOptions {
+    findings: QaFinding[];
+    artifacts: QaArtifact[];
+    metadata: {
+        scenarioName: string;
+        baseUrl: string;
+        viewport: {
+            width: number;
+            height: number;
+        };
+        timestamp: string;
+    };
+    duration: number;
+    summary: string;
+}
+export declare class ReportBuilder {
+    static buildReport(options: BuildReportOptions): QaReport;
+    private static generateSummary;
+    static aggregateFindingsByCategory(findings: QaFinding[]): Record<string, QaFinding[]>;
+    static aggregateFindingsBySeverity(findings: QaFinding[]): Record<string, QaFinding[]>;
+}
+//# sourceMappingURL=builder.d.ts.map

package/dist/report/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/report/builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEnE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,SAAS,EAAE,CAAC;IACtB,SAAS,EAAE,UAAU,EAAE,CAAC;IACxB,QAAQ,EAAE;QACR,YAAY,EAAE,MAAM,CAAC;QACrB,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,EAAE;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAC;QAC5C,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,aAAa;IACxB,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,QAAQ;IA4BzD,OAAO,CAAC,MAAM,CAAC,eAAe;IAoB9B,MAAM,CAAC,2BAA2B,CAAC,QAAQ,EAAE,SAAS,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC;IAetF,MAAM,CAAC,2BAA2B,CAAC,QAAQ,EAAE,SAAS,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC;CAcvF"}

package/dist/report/builder.js

@@ -0,0 +1,69 @@
+export class ReportBuilder {
+    static buildReport(options) {
+        const { findings, artifacts, metadata, duration, summary } = options;
+        // Determine overall status
+        let status = 'passed';
+        if (findings.some((f) => f.severity === 'critical' || f.severity === 'high')) {
+            status = 'failed';
+        }
+        else if (findings.length > 0) {
+            status = 'issues_found';
+        }
+        // Generate summary if not provided
+        let finalSummary = summary;
+        if (!finalSummary) {
+            finalSummary = this.generateSummary(findings, status);
+        }
+        return {
+            summary: finalSummary,
+            status,
+            duration,
+            findings,
+            artifacts,
+            metadata,
+        };
+    }
+    static generateSummary(findings, status) {
+        if (status === 'passed') {
+            return 'Test completed successfully with no issues found.';
+        }
+        const critical = findings.filter((f) => f.severity === 'critical').length;
+        const high = findings.filter((f) => f.severity === 'high').length;
+        const medium = findings.filter((f) => f.severity === 'medium').length;
+        const low = findings.filter((f) => f.severity === 'low').length;
+        const parts = [`Test completed with ${findings.length} issue(s) found:`];
+        if (critical > 0)
+            parts.push(`${critical} critical`);
+        if (high > 0)
+            parts.push(`${high} high`);
+        if (medium > 0)
+            parts.push(`${medium} medium`);
+        if (low > 0)
+            parts.push(`${low} low`);
+        return parts.join(', ') + '.';
+    }
+    static aggregateFindingsByCategory(findings) {
+        const byCategory = {
+            functional: [],
+            ux: [],
+            ui: [],
+            accessibility: [],
+        };
+        for (const finding of findings) {
+            byCategory[finding.category].push(finding);
+        }
+        return byCategory;
+    }
+    static aggregateFindingsBySeverity(findings) {
+        const bySeverity = {
+            critical: [],
+            high: [],
+            medium: [],
+            low: [],
+        };
+        for (const finding of findings) {
+            bySeverity[finding.severity].push(finding);
+        }
+        return bySeverity;
+    }
+}

package/dist/runner.d.ts

@@ -0,0 +1,10 @@
+import type { QaReport, QaRunnerConfig } from './types.js';
+export declare class QaRunner {
+    private config;
+    private browserController;
+    private visionAnalyzer;
+    constructor(config: QaRunnerConfig);
+    run(): Promise<QaReport>;
+    private emitProgress;
+}
+//# sourceMappingURL=runner.d.ts.map

package/dist/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAA+B,MAAM,YAAY,CAAC;AAIxF,qBAAa,QAAQ;IACnB,OAAO,CAAC,MAAM,CAAiB;IAC/B,OAAO,CAAC,iBAAiB,CAAkC;IAC3D,OAAO,CAAC,cAAc,CAA+B;gBAEzC,MAAM,EAAE,cAAc;IAI5B,GAAG,IAAI,OAAO,CAAC,QAAQ,CAAC;IA2I9B,OAAO,CAAC,YAAY;CASrB"}