@yasserkhanorg/e2e-agents 0.5.15 → 0.6.0

package/dist/esm/agent/selectors.js

@@ -1,71 +0,0 @@
-// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
-// See LICENSE.txt for license information.
-import { normalizePath } from './utils.js';
-const INTERACTIVE_TAGS = ['button', 'input', 'select', 'textarea', 'form', 'a'];
-const INTERACTIVE_HINT = /(onClick|onSubmit|onChange|type=['"]submit['"]|role=['"]button['"])/;
-export function findDataTestIdSuggestions(relativePath, content, flowId) {
-    if (!content) {
-        return [];
-    }
-    const suggestions = [];
-    const lines = content.split('\n');
-    let counter = 1;
-    for (let i = 0; i < lines.length; i += 1) {
-        const line = lines[i];
-        const trimmed = line.trim();
-        if (!trimmed.startsWith('<')) {
-            continue;
-        }
-        if (trimmed.includes('data-testid')) {
-            continue;
-        }
-        const tagMatch = trimmed.match(/^<([a-z][a-z0-9-]*)\b/);
-        if (!tagMatch) {
-            continue;
-        }
-        const tag = tagMatch[1];
-        if (!INTERACTIVE_TAGS.includes(tag)) {
-            continue;
-        }
-        if (!INTERACTIVE_HINT.test(trimmed)) {
-            continue;
-        }
-        const testId = `${flowId}-${tag}-${counter}`;
-        counter += 1;
-        suggestions.push({
-            file: normalizePath(relativePath),
-            line: i + 1,
-            tag,
-            testId,
-            snippet: trimmed.slice(0, 200),
-        });
-    }
-    return suggestions;
-}
-export function applyDataTestIdSuggestions(content, suggestions) {
-    if (suggestions.length === 0) {
-        return content;
-    }
-    const lines = content.split('\n');
-    const suggestionsByLine = new Map();
-    for (const suggestion of suggestions) {
-        const bucket = suggestionsByLine.get(suggestion.line) || [];
-        bucket.push(suggestion);
-        suggestionsByLine.set(suggestion.line, bucket);
-    }
-    for (const [lineNumber, lineSuggestions] of suggestionsByLine.entries()) {
-        const index = lineNumber - 1;
-        if (index < 0 || index >= lines.length) {
-            continue;
-        }
-        let line = lines[index];
-        for (const suggestion of lineSuggestions) {
-            const pattern = new RegExp(`<${suggestion.tag}(\\s|>)`);
-            if (pattern.test(line) && !line.includes('data-testid')) {
-                line = line.replace(pattern, `<${suggestion.tag} data-testid="${suggestion.testId}"$1`);
-            }
-        }
-        lines[index] = line;
-    }
-    return lines.join('\n');
-}

package/dist/esm/agent/subsystem_risk.js

@@ -1,204 +0,0 @@
-// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
-// See LICENSE.txt for license information.
-import { existsSync, readFileSync } from 'fs';
-import { matchGlob, normalizePath } from './utils.js';
-const PRIORITY_RANK = {
-    P0: 0,
-    P1: 1,
-    P2: 2,
-};
-function coerceNumber(value) {
-    if (typeof value === 'number' && Number.isFinite(value)) {
-        return value;
-    }
-    if (typeof value === 'string') {
-        const parsed = Number(value);
-        if (Number.isFinite(parsed)) {
-            return parsed;
-        }
-    }
-    return undefined;
-}
-function normalizePriority(value) {
-    if (value === 'P0' || value === 'P1' || value === 'P2') {
-        return value;
-    }
-    return undefined;
-}
-function parseStringArray(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value
-        .filter((item) => typeof item === 'string')
-        .map((item) => item.trim())
-        .filter(Boolean);
-}
-function parsePathArray(value) {
-    return parseStringArray(value).map((item) => normalizePath(item));
-}
-function parseKeywords(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return Array.from(new Set(value
-        .filter((item) => typeof item === 'string')
-        .map((item) => item.trim().toLowerCase())
-        .filter(Boolean)));
-}
-function parseRules(rawRules, warnings) {
-    if (!Array.isArray(rawRules)) {
-        warnings.push('Subsystem risk map has no "rules" array.');
-        return [];
-    }
-    const parsed = [];
-    for (let i = 0; i < rawRules.length; i += 1) {
-        const rawRule = rawRules[i];
-        if (!rawRule || typeof rawRule !== 'object') {
-            continue;
-        }
-        const patterns = parsePathArray(rawRule.patterns);
-        if (patterns.length === 0) {
-            warnings.push(`Subsystem risk rule at index ${i} has no valid patterns and was skipped.`);
-            continue;
-        }
-        const id = typeof rawRule.id === 'string' && rawRule.id.trim()
-            ? rawRule.id.trim()
-            : `rule-${i + 1}`;
-        const description = typeof rawRule.description === 'string' ? rawRule.description.trim() : undefined;
-        const reasons = parseStringArray(rawRule.reasons);
-        const keywords = parseKeywords(rawRule.keywords);
-        const scoreDelta = coerceNumber(rawRule.scoreDelta) ?? 0;
-        const priorityFloor = normalizePriority(rawRule.priorityFloor);
-        const normalizedReasons = reasons.length > 0
-            ? reasons
-            : (description ? [description] : []);
-        parsed.push({
-            id,
-            description,
-            patterns,
-            scoreDelta,
-            priorityFloor,
-            reasons: normalizedReasons,
-            keywords,
-        });
-    }
-    return parsed;
-}
-function comparePriority(a, b) {
-    return PRIORITY_RANK[a] <= PRIORITY_RANK[b] ? a : b;
-}
-export function loadSubsystemRiskResolver(config) {
-    const mapPath = normalizePath(config.mapPath);
-    const warnings = [];
-    if (!config.enabled) {
-        return {
-            info: {
-                source: 'map',
-                enabled: false,
-                mapPath,
-                mapFound: false,
-                rulesLoaded: 0,
-            },
-            warnings,
-            matchFile: () => [],
-        };
-    }
-    if (!existsSync(config.mapPath)) {
-        warnings.push(`Subsystem risk map file not found: ${config.mapPath}`);
-        return {
-            info: {
-                source: 'map',
-                enabled: true,
-                mapPath,
-                mapFound: false,
-                rulesLoaded: 0,
-            },
-            warnings,
-            matchFile: () => [],
-        };
-    }
-    let raw;
-    try {
-        raw = JSON.parse(readFileSync(config.mapPath, 'utf-8'));
-    }
-    catch {
-        warnings.push(`Subsystem risk map is invalid JSON: ${config.mapPath}`);
-        return {
-            info: {
-                source: 'map',
-                enabled: true,
-                mapPath,
-                mapFound: true,
-                rulesLoaded: 0,
-            },
-            warnings,
-            matchFile: () => [],
-        };
-    }
-    const rules = parseRules(raw.rules, warnings);
-    if (rules.length === 0) {
-        warnings.push(`Subsystem risk map loaded but no valid rules were found: ${config.mapPath}`);
-    }
-    const maxRules = Math.max(1, Math.round(config.maxRulesPerFile));
-    return {
-        info: {
-            source: 'map',
-            enabled: true,
-            mapPath,
-            mapFound: true,
-            rulesLoaded: rules.length,
-        },
-        warnings,
-        matchFile: (relativePath) => {
-            const normalizedPath = normalizePath(relativePath);
-            const matches = [];
-            for (const rule of rules) {
-                const matched = rule.patterns.some((pattern) => matchGlob(normalizedPath, pattern));
-                if (!matched) {
-                    continue;
-                }
-                const reasons = rule.reasons.length > 0
-                    ? rule.reasons
-                    : [`Subsystem risk rule matched: ${rule.id}`];
-                matches.push({
-                    ruleId: rule.id,
-                    scoreDelta: rule.scoreDelta,
-                    priorityFloor: rule.priorityFloor,
-                    reasons,
-                    keywords: rule.keywords,
-                    priorityRank: rule.priorityFloor ? PRIORITY_RANK[rule.priorityFloor] : 99,
-                });
-            }
-            if (matches.length <= maxRules) {
-                return matches.map(({ priorityRank, ...rest }) => rest);
-            }
-            matches.sort((a, b) => {
-                const deltaDiff = Math.abs(b.scoreDelta) - Math.abs(a.scoreDelta);
-                if (deltaDiff !== 0) {
-                    return deltaDiff;
-                }
-                const priorityDiff = a.priorityRank - b.priorityRank;
-                if (priorityDiff !== 0) {
-                    return priorityDiff;
-                }
-                return a.ruleId.localeCompare(b.ruleId);
-            });
-            const capped = matches.slice(0, maxRules).map(({ priorityRank, ...rest }) => rest);
-            let floor;
-            for (const match of capped) {
-                if (match.priorityFloor) {
-                    floor = floor ? comparePriority(floor, match.priorityFloor) : match.priorityFloor;
-                }
-            }
-            if (floor) {
-                for (const match of capped) {
-                    if (!match.priorityFloor) {
-                        match.priorityFloor = floor;
-                    }
-                }
-            }
-            return capped;
-        },
-    };
-}

package/dist/esm/agent/tests.js

@@ -1,111 +0,0 @@
-// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
-// See LICENSE.txt for license information.
-import { existsSync } from 'fs';
-import { globSync } from 'glob';
-import { join } from 'path';
-import { normalizePath, safeReadTextFile, tokenize, uniqueTokens } from './utils.js';
-export function discoverTests(appRoot, patterns) {
-    const files = new Set();
-    for (const pattern of patterns) {
-        const matches = globSync(pattern, {
-            cwd: appRoot,
-            ignore: ['**/node_modules/**', '**/.git/**'],
-            nodir: true,
-        });
-        for (const match of matches) {
-            files.add(normalizePath(match));
-        }
-    }
-    return Array.from(files).map((relativePath) => {
-        const fullPath = join(appRoot, relativePath);
-        const content = safeReadTextFile(fullPath);
-        return { path: relativePath, content };
-    });
-}
-function buildFlowKeywords(flow) {
-    const tokens = [];
-    tokens.push(...tokenize(flow.id));
-    tokens.push(...tokenize(flow.name));
-    tokens.push(...flow.keywords);
-    return uniqueTokens(tokens);
-}
-export function mapTestsToFlows(flows, tests) {
-    const coverage = [];
-    for (const flow of flows) {
-        const keywords = buildFlowKeywords(flow);
-        const matched = [];
-        let score = 0;
-        for (const test of tests) {
-            const haystack = `${test.path} ${test.content || ''}`.toLowerCase();
-            let localScore = 0;
-            for (const keyword of keywords) {
-                if (keyword && haystack.includes(keyword.toLowerCase())) {
-                    localScore += 1;
-                }
-            }
-            if (localScore > 0) {
-                matched.push(test.path);
-                score += localScore;
-            }
-        }
-        coverage.push({
-            flowId: flow.id,
-            flowName: flow.name,
-            priority: flow.priority,
-            coveredBy: matched,
-            score,
-            source: 'heuristic',
-        });
-    }
-    return coverage;
-}
-function resolveExpectedTests(testsRoot, expectedTests) {
-    const resolved = [];
-    for (const entry of expectedTests) {
-        if (!entry) {
-            continue;
-        }
-        const normalized = normalizePath(entry).replace(/^\.\//, '');
-        if (normalized.startsWith('e2e-tests/playwright/')) {
-            resolved.push(normalized.slice('e2e-tests/playwright/'.length));
-            continue;
-        }
-        const specsIndex = normalized.indexOf('specs/');
-        if (specsIndex >= 0) {
-            resolved.push(normalized.slice(specsIndex));
-            continue;
-        }
-        resolved.push(normalized);
-    }
-    return Array.from(new Set(resolved));
-}
-export function mapCatalogTestsToFlows(flows, testsRoot, testsByFlow) {
-    return flows.map((flow) => {
-        const expectedTests = resolveExpectedTests(testsRoot, testsByFlow.get(flow.id) || []);
-        const coveredBy = [];
-        for (const expected of expectedTests) {
-            const isAbsolute = expected.startsWith('/');
-            const globTarget = isAbsolute ? expected : expected;
-            if (expected.includes('*') || expected.includes('?') || expected.includes('{')) {
-                const matches = globSync(globTarget, { cwd: isAbsolute ? undefined : testsRoot, nodir: true });
-                if (matches.length > 0) {
-                    coveredBy.push(...matches.map((match) => normalizePath(match)));
-                }
-                continue;
-            }
-            const fullPath = isAbsolute ? expected : join(testsRoot, expected);
-            if (existsSync(fullPath)) {
-                coveredBy.push(isAbsolute ? normalizePath(expected) : expected);
-            }
-        }
-        return {
-            flowId: flow.id,
-            flowName: flow.name,
-            priority: flow.priority,
-            coveredBy: Array.from(new Set(coveredBy)),
-            score: coveredBy.length,
-            expectedTests,
-            source: 'catalog',
-        };
-    });
-}

package/dist/esm/agent/traceability.js

@@ -1,180 +0,0 @@
-// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
-// See LICENSE.txt for license information.
-import { existsSync, readFileSync } from 'fs';
-import { isAbsolute, join } from 'path';
-import { normalizePath } from './utils.js';
-function ratio(numerator, denominator) {
-    if (denominator <= 0) {
-        return 0;
-    }
-    return Number((numerator / denominator).toFixed(4));
-}
-function resolveManifestPath(root, configuredPath) {
-    if (isAbsolute(configuredPath)) {
-        return configuredPath;
-    }
-    return join(root, configuredPath);
-}
-function safeReadManifest(path) {
-    if (!existsSync(path)) {
-        return null;
-    }
-    try {
-        return JSON.parse(readFileSync(path, 'utf-8'));
-    }
-    catch {
-        return null;
-    }
-}
-function normalizeFiles(files) {
-    if (!files) {
-        return [];
-    }
-    return files.map((file) => normalizePath(file)).filter(Boolean);
-}
-function normalizeTests(tests) {
-    if (!tests) {
-        return [];
-    }
-    return tests.map((test) => normalizePath(test)).filter(Boolean);
-}
-function buildFileToTestsMap(manifest) {
-    const fileToTests = new Map();
-    const setMapping = (file, test) => {
-        if (!file || !test) {
-            return;
-        }
-        const key = normalizePath(file);
-        const value = normalizePath(test);
-        if (!fileToTests.has(key)) {
-            fileToTests.set(key, new Set());
-        }
-        fileToTests.get(key)?.add(value);
-    };
-    if (manifest.tests) {
-        for (const entry of manifest.tests) {
-            const files = normalizeFiles(entry.touchedFiles);
-            for (const file of files) {
-                setMapping(file, entry.test);
-            }
-        }
-    }
-    if (manifest.fileToTests) {
-        for (const [file, tests] of Object.entries(manifest.fileToTests)) {
-            const normalizedTests = normalizeTests(tests);
-            for (const test of normalizedTests) {
-                setMapping(file, test);
-            }
-        }
-    }
-    if (manifest.mappings) {
-        for (const entry of manifest.mappings) {
-            const normalizedTests = normalizeTests(entry.tests);
-            for (const test of normalizedTests) {
-                setMapping(entry.file, test);
-            }
-        }
-    }
-    return fileToTests;
-}
-export function mapTraceabilityToFlows(appRoot, config, flows) {
-    const manifestPath = resolveManifestPath(appRoot, config.manifestPath);
-    const warnings = [];
-    const fallbackStats = {
-        source: 'manifest',
-        enabled: config.enabled,
-        manifestPath,
-        manifestFound: false,
-        manifestTests: 0,
-        manifestEdges: 0,
-        matchedFlows: 0,
-        totalFlows: flows.length,
-        matchedTests: 0,
-        coverageRatio: 0,
-    };
-    if (!config.enabled) {
-        return {
-            coverage: [],
-            warnings,
-            stats: fallbackStats,
-        };
-    }
-    const manifest = safeReadManifest(manifestPath);
-    if (!manifest) {
-        warnings.push(`Traceability manifest not found or invalid: ${manifestPath}`);
-        return {
-            coverage: [],
-            warnings,
-            stats: fallbackStats,
-        };
-    }
-    const fileToTests = buildFileToTestsMap(manifest);
-    let manifestEdges = 0;
-    for (const tests of fileToTests.values()) {
-        manifestEdges += tests.size;
-    }
-    const manifestTests = new Set();
-    const coverage = [];
-    const matchedTests = new Set();
-    let matchedFlows = 0;
-    for (const tests of fileToTests.values()) {
-        for (const test of tests) {
-            manifestTests.add(test);
-        }
-    }
-    for (const flow of flows) {
-        const signalCounts = new Map();
-        const files = flow.files.map((file) => normalizePath(file));
-        for (const file of files) {
-            const tests = fileToTests.get(file);
-            if (!tests) {
-                continue;
-            }
-            for (const test of tests) {
-                signalCounts.set(test, (signalCounts.get(test) || 0) + 1);
-            }
-        }
-        const coveredBy = Array.from(signalCounts.entries())
-            .filter(([, count]) => count >= Math.max(1, config.minSignalsPerTest))
-            .map(([test]) => test)
-            .sort();
-        const score = Array.from(signalCounts.values()).reduce((acc, value) => acc + value, 0);
-        if (coveredBy.length > 0) {
-            matchedFlows += 1;
-            for (const test of coveredBy) {
-                matchedTests.add(test);
-            }
-        }
-        coverage.push({
-            flowId: flow.id,
-            flowName: flow.name,
-            priority: flow.priority,
-            coveredBy,
-            score,
-            source: 'traceability',
-        });
-    }
-    const stats = {
-        source: 'manifest',
-        enabled: config.enabled,
-        manifestPath,
-        manifestFound: true,
-        manifestTests: manifestTests.size,
-        manifestEdges,
-        matchedFlows,
-        totalFlows: flows.length,
-        matchedTests: matchedTests.size,
-        coverageRatio: ratio(matchedFlows, flows.length),
-    };
-    if (manifestEdges === 0) {
-        warnings.push(`Traceability manifest has no file-to-test mappings: ${manifestPath}`);
-    }
-    else if (stats.coverageRatio < 0.4) {
-        warnings.push(`Traceability coverage is low (${stats.matchedFlows}/${stats.totalFlows} flows mapped). Recommendations may require heuristic fallback.`);
-    }
-    return {
-        coverage,
-        warnings,
-        stats,
-    };
-}