@yasserkhanorg/e2e-agents 0.3.2

package/dist/e2e-test-gen/types.d.ts

@@ -0,0 +1,185 @@
+/**
+ * Core types for the autonomous testing system
+ *
+ * This file contains the essential types for specification parsing
+ * and the spec-to-Playwright bridge. The heavy lifting (test generation,
+ * execution, healing) is delegated to Playwright's native agents.
+ */
+/**
+ * Feature Specification - parsed from specification document (PDF, MD, JSON)
+ *
+ * This is the primary data structure extracted from user specifications.
+ * It represents a feature to be tested with its scenarios and acceptance criteria.
+ */
+export interface FeatureSpecification {
+    /**
+     * Unique identifier (derived from feature name)
+     */
+    id: string;
+    /**
+     * Feature name
+     */
+    name: string;
+    /**
+     * Feature description
+     */
+    description: string;
+    /**
+     * Priority level
+     */
+    priority: 'critical' | 'high' | 'medium' | 'low';
+    /**
+     * Target URLs to prioritize (optional - PDF specs describe behavior, not routes)
+     */
+    targetUrls: string[];
+    /**
+     * Business scenarios to test (Given-When-Then format)
+     */
+    scenarios: BusinessScenario[];
+    /**
+     * Reference screenshots from spec
+     */
+    screenshots: SpecScreenshot[];
+    /**
+     * Acceptance criteria (testable statements)
+     */
+    acceptanceCriteria: string[];
+    /**
+     * Related feature IDs
+     */
+    relatedFeatures?: string[];
+    /**
+     * Source file path
+     */
+    sourcePath: string;
+    /**
+     * Hash of source file (for cache validation)
+     */
+    sourceHash?: string;
+    /**
+     * Additional metadata (for PDFs and other formats)
+     */
+    metadata?: {
+        /**
+         * UI elements mentioned in the spec
+         */
+        uiElements?: string[];
+        /**
+         * User flows described in the spec
+         */
+        userFlows?: string[];
+        /**
+         * Source format (pdf, markdown, json, etc.)
+         */
+        extractedFrom?: string;
+        /**
+         * Any other custom metadata
+         */
+        [key: string]: any;
+    };
+}
+/**
+ * Business scenario from specification (Given-When-Then format)
+ *
+ * This format is widely used in BDD (Behavior-Driven Development)
+ * and maps well to Playwright test structure.
+ */
+export interface BusinessScenario {
+    /**
+     * Scenario name (describes the test case)
+     */
+    name: string;
+    /**
+     * Given (precondition) - the initial state
+     */
+    given: string;
+    /**
+     * When (action) - the user action being tested
+     */
+    when: string;
+    /**
+     * Then (expected outcome) - the expected result
+     */
+    then: string;
+    /**
+     * Scenario priority (for test ordering)
+     */
+    priority: 'must-have' | 'should-have' | 'nice-to-have';
+    /**
+     * Test IDs that cover this scenario (populated after test generation)
+     */
+    coveredByTests?: string[];
+}
+/**
+ * Specification screenshot (for visual reference)
+ */
+export interface SpecScreenshot {
+    /**
+     * File path or URL
+     */
+    path: string;
+    /**
+     * Description of what the screenshot shows
+     */
+    description: string;
+    /**
+     * Page number (for PDF screenshots)
+     */
+    pageNumber?: number;
+    /**
+     * Base64-encoded image data (loaded from path)
+     */
+    data?: string;
+}
+/**
+ * Generated test metadata
+ *
+ * Tracks information about tests generated from specifications.
+ * The actual test code is generated by Playwright's agents.
+ */
+export interface GeneratedTest {
+    /**
+     * Unique test ID
+     */
+    id: string;
+    /**
+     * Test title
+     */
+    title: string;
+    /**
+     * Test file path
+     */
+    filePath: string;
+    /**
+     * Test code (Playwright test)
+     */
+    code: string;
+    /**
+     * Source UI states that led to this test
+     */
+    sourceStates: string[];
+    /**
+     * Related specification (if spec-driven)
+     */
+    relatedSpec?: {
+        specId: string;
+        scenarioName: string;
+    };
+    /**
+     * AI confidence score (0.0 - 1.0)
+     */
+    confidence: number;
+    /**
+     * Test tags
+     */
+    tags: string[];
+    /**
+     * When test was generated
+     */
+    generatedAt: Date;
+    /**
+     * Generation method
+     */
+    generatedBy: 'playwright-planner' | 'playwright-generator' | 'manual' | 'autonomous-system' | 'spec-driven-generator';
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/e2e-test-gen/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/e2e-test-gen/types.ts"],"names":[],"mappings":"AAGA;;;;;;GAMG;AAMH;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACjC;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;IAEX;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,QAAQ,EAAE,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IAEjD;;OAEG;IACH,UAAU,EAAE,MAAM,EAAE,CAAC;IAErB;;OAEG;IACH,SAAS,EAAE,gBAAgB,EAAE,CAAC;IAE9B;;OAEG;IACH,WAAW,EAAE,cAAc,EAAE,CAAC;IAE9B;;OAEG;IACH,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAE7B;;OAEG;IACH,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAE3B;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,QAAQ,CAAC,EAAE;QACP;;WAEG;QACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;QAEtB;;WAEG;QACH,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;QAErB;;WAEG;QACH,aAAa,CAAC,EAAE,MAAM,CAAC;QAEvB;;WAEG;QACH,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KACtB,CAAC;CACL;AAED;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC7B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,QAAQ,EAAE,WAAW,GAAG,aAAa,GAAG,cAAc,CAAC;IAEvD;;OAEG;IACH,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACjB;AAMD;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC1B;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;IAEX;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;IAEvB;;OAEG;IACH,WAAW,CAAC,EAAE;QACV,MAAM,EAAE,MAAM,CAAC;QACf,YAAY,EAAE,MAAM,CAAC;KACxB,CAAC;IAEF;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,IAAI,EAAE,MAAM,EAAE,CAAC;IAEf;;OAEG;IACH,WAAW,EAAE,IAAI,CAAC;IAElB;;OAEG;IACH,WAAW,EACL,oBAAoB,GACpB,sBAAsB,GACtB,QAAQ,GACR,mBAAmB,GACnB,uBAAuB,CAAC;CACjC"}

package/dist/e2e-test-gen/types.js

@@ -0,0 +1,4 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/agent/analysis.js

@@ -0,0 +1,287 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { globSync } from 'glob';
+import { extractFlagHits, inferAudienceFromPath, mergeFlags, normalizeRoles } from './flags.js';
+import { baseNameWithoutExt, fileExtension, normalizePath, safeReadTextFile, titleCase, tokenize, uniqueTokens, } from './utils.js';
+import { loadSubsystemRiskResolver } from './subsystem_risk.js';
+const TEST_PATH_PATTERN = /(^|\/)__tests__(\/|$)|(^|\/)tests?(\/|$)|\.(spec|test)\.[a-z0-9]+$/i;
+const SCREEN_DIRS = new Set(['pages', 'screens', 'views', 'routes']);
+const FEATURE_DIRS = new Set(['features', 'modules', 'flows']);
+const COMPONENT_DIRS = new Set(['components', 'widgets', 'ui']);
+const STATE_DIRS = new Set(['state', 'store', 'stores', 'reducers', 'actions', 'context', 'hooks']);
+const STYLE_EXTS = new Set(['css', 'scss', 'sass', 'less', 'styl']);
+const UI_EXTS = new Set(['tsx', 'jsx']);
+const CODE_EXTS = new Set(['ts', 'js', 'tsx', 'jsx']);
+const INTERACTION_PATTERN = /(onClick|onSubmit|onChange|type=['"]submit['"]|role=['"]button['"]|aria-label=)/;
+const PRIORITY_RANK = {
+    P0: 0,
+    P1: 1,
+    P2: 2,
+};
+function deriveFlowFromPath(relativePath) {
+    const segments = normalizePath(relativePath).split('/').filter(Boolean);
+    const baseName = baseNameWithoutExt(relativePath);
+    const base = baseName.toLowerCase() === 'index' && segments.length > 1 ? segments[segments.length - 2] : baseName;
+    for (let i = 0; i < segments.length; i += 1) {
+        const segment = segments[i].toLowerCase();
+        if (SCREEN_DIRS.has(segment)) {
+            const next = segments[i + 1] ? segments[i + 1] : base;
+            return { id: normalizePath(next), name: titleCase(next), kind: 'screen' };
+        }
+        if (FEATURE_DIRS.has(segment)) {
+            const next = segments[i + 1] ? segments[i + 1] : base;
+            return { id: normalizePath(next), name: titleCase(next), kind: 'flow' };
+        }
+    }
+    return { id: normalizePath(base), name: titleCase(base), kind: 'flow' };
+}
+function extractKeywords(relativePath) {
+    const segments = normalizePath(relativePath).split('/').filter(Boolean);
+    const base = baseNameWithoutExt(relativePath);
+    const tokens = segments.flatMap((segment) => tokenize(segment));
+    tokens.push(...tokenize(base));
+    return uniqueTokens(tokens);
+}
+function detectInteractions(content) {
+    if (!content)
+        return false;
+    return INTERACTION_PATTERN.test(content);
+}
+function isScreenPath(relativePath) {
+    const segments = normalizePath(relativePath).split('/').map((segment) => segment.toLowerCase());
+    if (segments.some((segment) => segment === 'selectors' || segment === 'reducers' || segment === 'actions')) {
+        return false;
+    }
+    return segments.some((segment) => SCREEN_DIRS.has(segment));
+}
+function isComponentPath(relativePath) {
+    const segments = normalizePath(relativePath).split('/').map((segment) => segment.toLowerCase());
+    return segments.some((segment) => COMPONENT_DIRS.has(segment));
+}
+function isStatePath(relativePath) {
+    const segments = normalizePath(relativePath).split('/').map((segment) => segment.toLowerCase());
+    return segments.some((segment) => STATE_DIRS.has(segment));
+}
+function scoreFile(file, risk) {
+    let score = 1;
+    const reasons = [];
+    if (file.isScreen) {
+        score += 3;
+        reasons.push('Screen-level change');
+    }
+    if (file.isComponent) {
+        score += 2;
+        reasons.push('Shared component change');
+    }
+    if (file.isUI) {
+        score += 2;
+        reasons.push('UI logic change');
+    }
+    if (file.isState) {
+        score += 2;
+        reasons.push('State or data flow change');
+    }
+    if (file.isStyle) {
+        score += 1;
+        reasons.push('Visual styling change');
+    }
+    if (file.hasInteractions) {
+        score += 2;
+        reasons.push('Interactive element change');
+    }
+    const keywordHit = file.keywords.find((keyword) => risk.criticalKeywords.includes(keyword));
+    if (keywordHit) {
+        score += 2;
+        reasons.push(`Critical keyword: ${keywordHit}`);
+    }
+    if (file.subsystemRisk) {
+        const scoreDelta = file.subsystemRisk.scoreDelta;
+        if (scoreDelta !== 0) {
+            score += scoreDelta;
+            reasons.push(`Subsystem risk adjustment: ${scoreDelta > 0 ? '+' : ''}${scoreDelta}`);
+        }
+        reasons.push(...file.subsystemRisk.reasons);
+    }
+    return { score, reasons };
+}
+function mergePriorityFloor(current, candidate) {
+    if (!candidate) {
+        return current;
+    }
+    if (!current) {
+        return candidate;
+    }
+    return PRIORITY_RANK[candidate] < PRIORITY_RANK[current] ? candidate : current;
+}
+export function analyzeFiles(appRoot, relativePaths, config) {
+    const files = [];
+    const defaultAudience = config.audience.defaultRoles;
+    const defaultFlagState = config.flags.defaultState;
+    const warnings = [];
+    const subsystemRisk = loadSubsystemRiskResolver(config.impact.subsystemRisk);
+    warnings.push(...subsystemRisk.warnings);
+    let subsystemRiskMatchedFiles = 0;
+    let subsystemRiskRuleMatches = 0;
+    for (const relativePath of relativePaths) {
+        if (isTestFilePath(relativePath)) {
+            continue;
+        }
+        const fullPath = join(appRoot, relativePath);
+        const exists = existsSync(fullPath);
+        const extension = fileExtension(relativePath);
+        const content = exists && CODE_EXTS.has(extension) ? safeReadTextFile(fullPath) : null;
+        const { id, name, kind } = deriveFlowFromPath(relativePath);
+        const audience = inferAudienceFromPath(relativePath, config);
+        const flags = extractFlagHits(content, config);
+        const subsystemRiskMatches = subsystemRisk.matchFile(normalizePath(relativePath));
+        let subsystemRiskScoreDelta = 0;
+        let subsystemRiskPriorityFloor;
+        const subsystemRiskRules = uniqueTokens(subsystemRiskMatches.map((entry) => entry.ruleId));
+        const subsystemRiskReasons = uniqueTokens(subsystemRiskMatches.flatMap((entry) => entry.reasons));
+        if (subsystemRiskMatches.length > 0) {
+            subsystemRiskMatchedFiles += 1;
+            subsystemRiskRuleMatches += subsystemRiskMatches.length;
+            subsystemRiskScoreDelta = subsystemRiskMatches.reduce((acc, entry) => acc + entry.scoreDelta, 0);
+            for (const match of subsystemRiskMatches) {
+                subsystemRiskPriorityFloor = mergePriorityFloor(subsystemRiskPriorityFloor, match.priorityFloor);
+            }
+        }
+        const subsystemKeywords = uniqueTokens(subsystemRiskMatches.flatMap((entry) => entry.keywords));
+        const analysis = {
+            relativePath: normalizePath(relativePath),
+            extension,
+            exists,
+            content,
+            isUI: UI_EXTS.has(extension),
+            isScreen: isScreenPath(relativePath),
+            isComponent: isComponentPath(relativePath),
+            isState: isStatePath(relativePath),
+            isStyle: STYLE_EXTS.has(extension),
+            hasInteractions: detectInteractions(content),
+            keywords: uniqueTokens([...extractKeywords(relativePath), ...subsystemKeywords]),
+            flowId: id,
+            flowName: name,
+            flowKind: kind,
+            audience,
+            flags,
+            subsystemRisk: subsystemRiskMatches.length > 0
+                ? {
+                    rules: subsystemRiskRules,
+                    scoreDelta: subsystemRiskScoreDelta,
+                    priorityFloor: subsystemRiskPriorityFloor,
+                    reasons: subsystemRiskReasons,
+                }
+                : undefined,
+        };
+        files.push(analysis);
+    }
+    const flowMap = new Map();
+    for (const file of files) {
+        const { score, reasons } = scoreFile(file, config.risk);
+        const existing = flowMap.get(file.flowId);
+        if (!existing) {
+            flowMap.set(file.flowId, {
+                id: file.flowId,
+                name: file.flowName,
+                kind: file.flowKind,
+                score,
+                priority: 'P2',
+                reasons: [...reasons],
+                keywords: [...file.keywords],
+                files: [file.relativePath],
+                audience: file.audience,
+                flags: file.flags,
+                priorityFloor: file.subsystemRisk?.priorityFloor,
+                subsystemRiskBoost: file.subsystemRisk?.scoreDelta || 0,
+                subsystemRiskRules: file.subsystemRisk?.rules || [],
+            });
+        }
+        else {
+            existing.score += score;
+            existing.files.push(file.relativePath);
+            existing.reasons.push(...reasons);
+            existing.keywords.push(...file.keywords);
+            existing.audience = normalizeRoles([...(existing.audience || []), ...file.audience], defaultAudience);
+            existing.flags = mergeFlags([...(existing.flags || []), ...file.flags], defaultFlagState);
+            existing.priorityFloor = mergePriorityFloor(existing.priorityFloor, file.subsystemRisk?.priorityFloor);
+            existing.subsystemRiskBoost = (existing.subsystemRiskBoost || 0) + (file.subsystemRisk?.scoreDelta || 0);
+            existing.subsystemRiskRules = uniqueTokens([...(existing.subsystemRiskRules || []), ...(file.subsystemRisk?.rules || [])]);
+        }
+    }
+    let boostedFlows = 0;
+    const flows = Array.from(flowMap.values()).map((flow) => {
+        const uniqueReason = uniqueTokens(flow.reasons);
+        const uniqueKeywords = uniqueTokens(flow.keywords);
+        const computedPriority = flow.score >= config.risk.p0Threshold
+            ? 'P0'
+            : flow.score >= config.risk.p1Threshold
+                ? 'P1'
+                : 'P2';
+        const priority = mergePriorityFloor(computedPriority, flow.priorityFloor) || computedPriority;
+        if ((flow.subsystemRiskBoost || 0) !== 0 || (flow.priorityFloor && flow.priorityFloor !== computedPriority)) {
+            boostedFlows += 1;
+        }
+        return {
+            ...flow,
+            reasons: uniqueReason.map((reason) => reason),
+            keywords: uniqueKeywords,
+            priority,
+        };
+    });
+    return {
+        files,
+        flows,
+        warnings,
+        subsystemRisk: {
+            source: 'map',
+            enabled: subsystemRisk.info.enabled,
+            mapPath: subsystemRisk.info.mapPath,
+            mapFound: subsystemRisk.info.mapFound,
+            rulesLoaded: subsystemRisk.info.rulesLoaded,
+            filesMatched: subsystemRiskMatchedFiles,
+            ruleMatches: subsystemRiskRuleMatches,
+            boostedFlows,
+        },
+    };
+}
+export function isTestFilePath(relativePath) {
+    return TEST_PATH_PATTERN.test(normalizePath(relativePath));
+}
+export function scanRepositoryFlows(appRoot, limit = 250, patterns, exclude) {
+    const defaultPatterns = [
+        '**/pages/**/*.{tsx,jsx,ts,js}',
+        '**/screens/**/*.{tsx,jsx,ts,js}',
+        '**/views/**/*.{tsx,jsx,ts,js}',
+        '**/routes/**/*.{tsx,jsx,ts,js}',
+    ];
+    const useDefaults = !(patterns && patterns.length > 0);
+    const activePatterns = useDefaults ? defaultPatterns : patterns;
+    const matches = new Set();
+    const ignorePatterns = [
+        '**/node_modules/**',
+        '**/.git/**',
+        '**/__tests__/**',
+        '**/tests/**',
+        ...(useDefaults ? ['**/selectors/**', '**/reducers/**', '**/actions/**'] : []),
+        ...(exclude || []),
+    ];
+    for (const pattern of activePatterns) {
+        const files = globSync(pattern, {
+            cwd: appRoot,
+            ignore: ignorePatterns,
+            nodir: true,
+        });
+        for (const file of files) {
+            matches.add(normalizePath(file));
+            if (matches.size >= limit) {
+                break;
+            }
+        }
+        if (matches.size >= limit) {
+            break;
+        }
+    }
+    return Array.from(matches);
+}

package/dist/esm/agent/blast_radius.js

@@ -0,0 +1,34 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { computeBlastRadius, mergeFlags, normalizeRoles } from './flags.js';
+export function applyBlastRadius(flows, files, config) {
+    if (flows.length === 0) {
+        return flows;
+    }
+    const fileMap = new Map();
+    for (const file of files) {
+        fileMap.set(file.relativePath, file);
+    }
+    return flows.map((flow) => {
+        const collectedFlags = [...(flow.flags || [])];
+        const collectedAudience = [...(flow.audience || [])];
+        for (const filePath of flow.files) {
+            const file = fileMap.get(filePath);
+            if (!file) {
+                continue;
+            }
+            collectedFlags.push(...file.flags);
+            collectedAudience.push(...file.audience);
+        }
+        const mergedFlags = mergeFlags(collectedFlags, config.flags.defaultState);
+        const mergedAudience = normalizeRoles(collectedAudience, config.audience.defaultRoles);
+        const blastRadius = computeBlastRadius(mergedAudience, mergedFlags, config);
+        return {
+            ...flow,
+            audience: mergedAudience,
+            flags: mergedFlags,
+            blastRadius,
+            score: flow.score + blastRadius.scoreDelta,
+        };
+    });
+}

package/dist/esm/agent/cache_utils.js

@@ -0,0 +1,63 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+export class SimpleCache {
+    constructor(ttlMs = 5 * 60 * 1000) {
+        this.cache = new Map();
+        // Default: 5 minutes
+        this.ttlMs = ttlMs;
+    }
+    /**
+     * Get value from cache if it exists and hasn't expired
+     */
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            return undefined;
+        }
+        // Check if entry has expired
+        if (Date.now() - entry.timestamp > this.ttlMs) {
+            this.cache.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    /**
+     * Set value in cache with current timestamp
+     */
+    set(key, value) {
+        this.cache.set(key, {
+            value,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * Clear all entries from cache
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * Get cache size
+     */
+    size() {
+        return this.cache.size;
+    }
+    /**
+     * Get cache statistics
+     */
+    stats() {
+        // Clean expired entries
+        const now = Date.now();
+        let expired = 0;
+        for (const [key, entry] of this.cache.entries()) {
+            if (now - entry.timestamp > this.ttlMs) {
+                this.cache.delete(key);
+                expired++;
+            }
+        }
+        return {
+            size: this.cache.size,
+            entries: this.cache.size,
+        };
+    }
+}