@yasserkhanorg/e2e-agents 0.5.16 → 0.6.0

package/dist/esm/agent/flags.js

@@ -1,160 +0,0 @@
-// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
-// See LICENSE.txt for license information.
-const ROLE_ORDER = [
-    'system_admin',
-    'team_admin',
-    'channel_admin',
-    'member',
-    'guest',
-    'deactivated',
-];
-const FEATURE_FLAG_REGEX = /\bFeatureFlags?\.(\w+)\b/g;
-const FEATURE_FLAG_STRING_REGEX = /\b(?:isFeatureEnabled|getFeatureFlag|featureFlag)\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-const SERVICE_SETTINGS_REGEX = /\bServiceSettings\.(\w+)\b/g;
-const TEST_GATE_REGEX = /\bskipIfFeatureFlagNotSet\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
-const ROLE_ALIASES = {
-    'system admin': 'system_admin',
-    'system_admin': 'system_admin',
-    sysadmin: 'system_admin',
-    'team admin': 'team_admin',
-    'team_admin': 'team_admin',
-    'channel admin': 'channel_admin',
-    'channel_admin': 'channel_admin',
-    member: 'member',
-    members: 'member',
-    guest: 'guest',
-    guests: 'guest',
-    deactivated: 'deactivated',
-    inactive: 'deactivated',
-    disabled: 'deactivated',
-};
-export function normalizeRole(role) {
-    const key = role.trim().toLowerCase();
-    return ROLE_ALIASES[key] ?? null;
-}
-export function normalizeRoles(roles, fallback) {
-    const normalized = roles
-        .map((role) => normalizeRole(role))
-        .filter((role) => Boolean(role));
-    const combined = normalized.length > 0 ? normalized : fallback;
-    const unique = new Set(combined);
-    return ROLE_ORDER.filter((role) => unique.has(role));
-}
-export function normalizeFlagSource(source) {
-    if (!source) {
-        return 'featureFlag';
-    }
-    const value = source.trim().toLowerCase();
-    if (['feature', 'featureflag', 'feature_flag', 'flag'].includes(value)) {
-        return 'featureFlag';
-    }
-    if (['config', 'service', 'servicesettings', 'server'].includes(value)) {
-        return 'configFlag';
-    }
-    if (['test', 'gate', 'testgate'].includes(value)) {
-        return 'testGate';
-    }
-    return 'featureFlag';
-}
-export function normalizeFlagState(value, fallback) {
-    if (!value) {
-        return fallback;
-    }
-    const lowered = value.trim().toLowerCase();
-    if (lowered === 'on' || lowered === 'off' || lowered === 'unknown') {
-        return lowered;
-    }
-    return fallback;
-}
-export function mergeFlags(flags, defaultState) {
-    const map = new Map();
-    for (const flag of flags) {
-        const key = `${flag.source}:${flag.name.toLowerCase()}`;
-        if (!map.has(key)) {
-            map.set(key, {
-                ...flag,
-                defaultState: flag.defaultState ?? defaultState,
-            });
-        }
-    }
-    return Array.from(map.values());
-}
-export function extractFlagHits(content, config) {
-    if (!content) {
-        return [];
-    }
-    const hits = [];
-    const defaultState = config.flags.defaultState;
-    for (const match of content.matchAll(FEATURE_FLAG_REGEX)) {
-        if (match[1]) {
-            hits.push({ name: match[1], source: 'featureFlag', defaultState });
-        }
-    }
-    for (const match of content.matchAll(FEATURE_FLAG_STRING_REGEX)) {
-        if (match[1]) {
-            hits.push({ name: match[1], source: 'featureFlag', defaultState });
-        }
-    }
-    for (const match of content.matchAll(SERVICE_SETTINGS_REGEX)) {
-        if (match[1]) {
-            hits.push({ name: match[1], source: 'configFlag', defaultState });
-        }
-    }
-    for (const match of content.matchAll(TEST_GATE_REGEX)) {
-        if (match[1]) {
-            hits.push({ name: match[1], source: 'testGate', defaultState });
-        }
-    }
-    return mergeFlags(hits, defaultState);
-}
-export function inferAudienceFromPath(relativePath, config) {
-    const normalized = relativePath.toLowerCase();
-    if (normalized.includes('admin_console') || normalized.includes('system_console')) {
-        return normalizeRoles(['system_admin'], config.audience.defaultRoles);
-    }
-    if (normalized.includes('team') && normalized.includes('admin')) {
-        return normalizeRoles(['team_admin'], config.audience.defaultRoles);
-    }
-    if (normalized.includes('channel') && normalized.includes('admin')) {
-        return normalizeRoles(['channel_admin'], config.audience.defaultRoles);
-    }
-    return normalizeRoles(config.audience.defaultRoles, config.audience.defaultRoles);
-}
-export function formatFlags(flags) {
-    if (flags.length === 0) {
-        return 'none';
-    }
-    return flags.map((flag) => `${flag.name} (${flag.defaultState})`).join(', ');
-}
-export function computeBlastRadius(audience, flags, config) {
-    const normalizedAudience = normalizeRoles(audience, config.audience.defaultRoles);
-    const normalizedFlags = mergeFlags(flags, config.flags.defaultState);
-    const hasMember = normalizedAudience.includes('member');
-    const hasGuest = normalizedAudience.includes('guest');
-    const hasAdmin = normalizedAudience.some((role) => role === 'system_admin' || role === 'team_admin' || role === 'channel_admin');
-    const scope = hasMember || hasGuest ? 'broad' : hasAdmin ? 'admin-only' : 'unknown';
-    const flagState = normalizedFlags.length === 0
-        ? 'unflagged'
-        : normalizedFlags.some((flag) => flag.defaultState === 'off')
-            ? 'flagged-off'
-            : 'flagged-on';
-    let scoreDelta = 0;
-    if (hasMember) {
-        scoreDelta += config.blastRadius.memberBonus;
-    }
-    if (hasGuest) {
-        scoreDelta += config.blastRadius.guestBonus;
-    }
-    if (!hasMember && !hasGuest) {
-        scoreDelta += config.blastRadius.adminOnlyPenalty;
-    }
-    if (normalizedFlags.some((flag) => flag.defaultState === 'off')) {
-        scoreDelta += config.blastRadius.flagOffPenalty;
-    }
-    return {
-        audience: normalizedAudience,
-        flags: normalizedFlags,
-        summary: `${scope}; ${flagState}`,
-        scoreDelta,
-    };
-}

package/dist/esm/agent/flow_catalog.js

@@ -1,112 +0,0 @@
-// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
-// See LICENSE.txt for license information.
-import { existsSync, readFileSync, statSync } from 'fs';
-import { join } from 'path';
-import { normalizeFlagSource, normalizeFlagState, normalizeRoles } from './flags.js';
-import { normalizePath, titleCase } from './utils.js';
-const catalogCache = new Map();
-function normalizePriority(value) {
-    const upper = value.toUpperCase();
-    if (upper === 'P0' || upper === 'P1' || upper === 'P2') {
-        return upper;
-    }
-    return null;
-}
-function normalizeEntry(entry, config) {
-    if (!entry.id || !entry.priority) {
-        return null;
-    }
-    const priority = normalizePriority(entry.priority);
-    if (!priority) {
-        return null;
-    }
-    const rawAudience = Array.isArray(entry.audience)
-        ? entry.audience.filter((role) => typeof role === 'string')
-        : [];
-    const normalizedAudience = normalizeRoles(rawAudience, config.audience.defaultRoles);
-    const rawFlags = Array.isArray(entry.flags) ? entry.flags : [];
-    const normalizedFlags = [];
-    for (const flag of rawFlags) {
-        if (typeof flag === 'string') {
-            normalizedFlags.push({
-                name: flag,
-                source: 'featureFlag',
-                defaultState: config.flags.defaultState,
-            });
-            continue;
-        }
-        if (flag && typeof flag === 'object' && typeof flag.name === 'string') {
-            normalizedFlags.push({
-                name: flag.name,
-                source: normalizeFlagSource(flag.source),
-                defaultState: normalizeFlagState(flag.defaultState, config.flags.defaultState),
-            });
-        }
-    }
-    return {
-        ...entry,
-        id: normalizePath(entry.id),
-        name: entry.name || titleCase(entry.id),
-        priority,
-        keywords: (entry.keywords || []).map((keyword) => keyword.toLowerCase()),
-        paths: (entry.paths || []).map((path) => normalizePath(path)),
-        tests: (entry.tests || []).map((path) => normalizePath(path)),
-        audience: normalizedAudience,
-        flags: normalizedFlags,
-    };
-}
-function readCatalog(path, config) {
-    try {
-        if (!existsSync(path)) {
-            return null;
-        }
-        const mtimeMs = statSync(path).mtimeMs;
-        const cached = catalogCache.get(path);
-        if (cached && cached.mtimeMs === mtimeMs) {
-            return cached.catalog;
-        }
-        const raw = JSON.parse(readFileSync(path, 'utf-8'));
-        if (!raw.flows || !Array.isArray(raw.flows)) {
-            if (config.profile === 'mattermost') {
-                throw new Error(`Mattermost profile requires a non-empty flow catalog schema at ${path}.`);
-            }
-            catalogCache.set(path, { mtimeMs, catalog: null });
-            return null;
-        }
-        const flows = raw.flows
-            .map((flow) => normalizeEntry(flow, config))
-            .filter((flow) => Boolean(flow));
-        if (flows.length === 0) {
-            if (config.profile === 'mattermost') {
-                throw new Error(`Mattermost profile requires at least one valid flow catalog entry at ${path}.`);
-            }
-            catalogCache.set(path, { mtimeMs, catalog: null });
-            return null;
-        }
-        const catalog = { flows, source: path };
-        catalogCache.set(path, { mtimeMs, catalog });
-        return catalog;
-    }
-    catch (error) {
-        if (config.profile === 'mattermost') {
-            throw error;
-        }
-        return null;
-    }
-}
-export function loadFlowCatalog(config) {
-    const candidates = [];
-    if (config.flowCatalogPath) {
-        candidates.push(config.flowCatalogPath);
-    }
-    const testsRoot = config.testsRoot || config.path;
-    candidates.push(join(testsRoot, '.e2e-ai-agents', 'flows.json'));
-    candidates.push(join(config.path, '.e2e-ai-agents', 'flows.json'));
-    for (const candidate of candidates) {
-        const catalog = readCatalog(candidate, config);
-        if (catalog) {
-            return catalog;
-        }
-    }
-    return null;
-}

package/dist/esm/agent/flow_mapping.js

@@ -1,81 +0,0 @@
-// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
-// See LICENSE.txt for license information.
-import { matchGlob, normalizePath, tokenize, uniqueTokens } from './utils.js';
-function pathMatches(patterns, filePath) {
-    for (const pattern of patterns) {
-        if (matchGlob(filePath, pattern)) {
-            return pattern;
-        }
-    }
-    return null;
-}
-function keywordMatches(keywords, filePath) {
-    const tokens = tokenize(filePath);
-    for (const keyword of keywords) {
-        if (tokens.includes(keyword.toLowerCase())) {
-            return keyword;
-        }
-    }
-    return null;
-}
-export function mapChangesToCatalogFlows(catalog, changedFiles, mode, config) {
-    const warnings = [];
-    const flows = [];
-    const testsByFlow = new Map();
-    const normalizedChanges = Array.from(new Set(changedFiles.map((file) => normalizePath(file))));
-    for (const flow of catalog.flows) {
-        const reasons = [];
-        const matchedFiles = new Set();
-        let matched = false;
-        if (flow.paths && flow.paths.length > 0) {
-            for (const file of normalizedChanges) {
-                const match = pathMatches(flow.paths, file);
-                if (match) {
-                    matchedFiles.add(file);
-                    reasons.push(`Path match: ${match}`);
-                    matched = true;
-                }
-            }
-        }
-        if (!matched && flow.keywords && flow.keywords.length > 0) {
-            for (const file of normalizedChanges) {
-                const keyword = keywordMatches(flow.keywords, file);
-                if (keyword) {
-                    matchedFiles.add(file);
-                    reasons.push(`Keyword match: ${keyword}`);
-                    matched = true;
-                }
-            }
-        }
-        if (mode === 'impact' && !matched) {
-            continue;
-        }
-        if (mode === 'gap' && reasons.length === 0) {
-            reasons.push('Catalog flow');
-        }
-        const priorityScore = config.catalogScoring?.priorityScores?.[flow.priority] ??
-            (flow.priority === 'P0' ? 10 : flow.priority === 'P1' ? 6 : 3);
-        const fileMatchWeight = config.catalogScoring?.fileMatchWeight ?? 1;
-        const score = priorityScore + matchedFiles.size * fileMatchWeight;
-        const matchedFilesList = Array.from(matchedFiles);
-        flows.push({
-            id: flow.id,
-            name: flow.name || flow.id,
-            kind: 'flow',
-            score,
-            priority: flow.priority,
-            reasons: uniqueTokens(reasons),
-            keywords: flow.keywords || [],
-            files: uniqueTokens(matchedFilesList),
-            audience: flow.audience,
-            flags: flow.flags,
-        });
-        if (flow.tests && flow.tests.length > 0) {
-            testsByFlow.set(flow.id, flow.tests.map((test) => normalizePath(test)));
-        }
-    }
-    if (flows.length === 0 && mode === 'impact') {
-        warnings.push('No flow catalog entries matched changed files.');
-    }
-    return { flows, testsByFlow, warnings };
-}

package/dist/esm/agent/framework.js

@@ -1,145 +0,0 @@
-// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
-// See LICENSE.txt for license information.
-import { existsSync, readFileSync } from 'fs';
-import { basename, join } from 'path';
-const PLAYWRIGHT_CONFIG_FILES = ['playwright.config.ts', 'playwright.config.js'];
-const CYPRESS_CONFIG_FILES = ['cypress.config.ts', 'cypress.config.js'];
-const SELENIUM_CONFIG_FILES = ['selenium.config.ts', 'selenium.config.js', 'wdio.conf.ts', 'wdio.conf.js'];
-function readPackageJson(appRoot) {
-    const pkgPath = join(appRoot, 'package.json');
-    if (!existsSync(pkgPath)) {
-        return undefined;
-    }
-    try {
-        return JSON.parse(readFileSync(pkgPath, 'utf-8'));
-    }
-    catch {
-        return undefined;
-    }
-}
-function hasDependency(pkg, dep) {
-    if (!pkg)
-        return false;
-    const dependencies = pkg.dependencies || {};
-    const devDependencies = pkg.devDependencies || {};
-    return Boolean(dependencies[dep] || devDependencies[dep]);
-}
-function findConfigFile(appRoot, candidates) {
-    for (const file of candidates) {
-        const fullPath = join(appRoot, file);
-        if (existsSync(fullPath)) {
-            return fullPath;
-        }
-    }
-    return undefined;
-}
-export function detectFramework(appRoot, explicitFramework) {
-    if (explicitFramework && explicitFramework !== 'auto') {
-        return {
-            framework: explicitFramework,
-            reason: 'explicit',
-        };
-    }
-    const playwrightConfig = findConfigFile(appRoot, PLAYWRIGHT_CONFIG_FILES);
-    if (playwrightConfig) {
-        return { framework: 'playwright', configPath: playwrightConfig, reason: 'config' };
-    }
-    const cypressConfig = findConfigFile(appRoot, CYPRESS_CONFIG_FILES);
-    if (cypressConfig) {
-        return { framework: 'cypress', configPath: cypressConfig, reason: 'config' };
-    }
-    const seleniumConfig = findConfigFile(appRoot, SELENIUM_CONFIG_FILES);
-    if (seleniumConfig) {
-        return { framework: 'selenium', configPath: seleniumConfig, reason: 'config' };
-    }
-    const pkg = readPackageJson(appRoot);
-    if (hasDependency(pkg, '@playwright/test') || hasDependency(pkg, 'playwright')) {
-        return { framework: 'playwright', reason: 'package.json' };
-    }
-    if (hasDependency(pkg, 'cypress')) {
-        return { framework: 'cypress', reason: 'package.json' };
-    }
-    if (hasDependency(pkg, 'selenium-webdriver') || hasDependency(pkg, 'webdriverio')) {
-        return { framework: 'selenium', reason: 'package.json' };
-    }
-    return { framework: 'unknown', reason: 'unknown' };
-}
-function extractQuotedStrings(value) {
-    const matches = value.match(/['"]([^'"]+)['"]/g);
-    if (!matches) {
-        return [];
-    }
-    return matches.map((match) => match.slice(1, -1)).filter(Boolean);
-}
-function parsePlaywrightPatterns(content) {
-    const testDirMatch = content.match(/testDir\s*:\s*['"]([^'"]+)['"]/);
-    if (testDirMatch) {
-        const testDir = testDirMatch[1];
-        return [
-            join(testDir, '**/*.spec.{ts,tsx,js,jsx}'),
-            join(testDir, '**/*.test.{ts,tsx,js,jsx}'),
-        ];
-    }
-    const testMatchMatch = content.match(/testMatch\s*:\s*(\[[^\]]+\]|['"][^'"]+['"])/);
-    if (testMatchMatch) {
-        const patterns = extractQuotedStrings(testMatchMatch[1]);
-        if (patterns.length > 0) {
-            return patterns;
-        }
-    }
-    return [];
-}
-function parseCypressPatterns(content) {
-    const specPatternMatch = content.match(/specPattern\s*:\s*(\[[^\]]+\]|['"][^'"]+['"])/);
-    if (specPatternMatch) {
-        const patterns = extractQuotedStrings(specPatternMatch[1]);
-        if (patterns.length > 0) {
-            return patterns;
-        }
-    }
-    return [];
-}
-export function resolveTestPatterns(appRoot, detection, explicitPatterns) {
-    if (explicitPatterns && explicitPatterns.length > 0) {
-        return { patterns: explicitPatterns, source: 'config' };
-    }
-    if (detection.configPath) {
-        try {
-            const configContent = readFileSync(detection.configPath, 'utf-8');
-            if (detection.framework === 'playwright') {
-                const parsed = parsePlaywrightPatterns(configContent);
-                if (parsed.length > 0) {
-                    return { patterns: parsed, source: basename(detection.configPath) };
-                }
-            }
-            if (detection.framework === 'cypress') {
-                const parsed = parseCypressPatterns(configContent);
-                if (parsed.length > 0) {
-                    return { patterns: parsed, source: basename(detection.configPath) };
-                }
-            }
-        }
-        catch {
-            // Fall through to defaults
-        }
-    }
-    if (detection.framework === 'playwright') {
-        return {
-            patterns: ['tests/**/*.{spec,test}.{ts,tsx,js,jsx}'],
-            source: 'default-playwright',
-        };
-    }
-    if (detection.framework === 'cypress') {
-        return {
-            patterns: ['cypress/e2e/**/*.cy.{js,jsx,ts,tsx}'],
-            source: 'default-cypress',
-        };
-    }
-    if (detection.framework === 'selenium') {
-        return {
-            patterns: ['tests/selenium/**/*.{spec,test}.{js,ts}'],
-            source: 'default-selenium',
-        };
-    }
-    return { patterns: [], source: 'none' };
-}

package/dist/esm/agent/gap_suggestions.js

@@ -1,98 +0,0 @@
-// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
-// See LICENSE.txt for license information.
-import { resolve } from 'path';
-import { isPathWithinRoot } from './utils.js';
-function inferTestDir(patterns) {
-    if (patterns.length === 0) {
-        return 'tests';
-    }
-    const pattern = patterns[0];
-    const wildcardIndex = pattern.search(/[*{]/);
-    const base = wildcardIndex === -1 ? pattern : pattern.slice(0, wildcardIndex);
-    const trimmed = base.replace(/\/+$/, '');
-    return trimmed || 'tests';
-}
-function inferExtension(patterns) {
-    const joined = patterns.join(' ');
-    if (joined.includes('.ts') || joined.includes('.tsx')) {
-        return 'ts';
-    }
-    return 'js';
-}
-function normalizeFramework(framework) {
-    if (framework === 'cypress' || framework === 'selenium') {
-        return framework;
-    }
-    return 'playwright';
-}
-function buildSkeleton(flow, sourceFiles, framework) {
-    const linkedFiles = sourceFiles.length > 0 ? sourceFiles.join(', ') : 'N/A';
-    if (framework === 'cypress') {
-        return [
-            `describe('Flow: ${flow.name}', () => {`,
-            `  it('${flow.priority}: critical coverage for ${flow.id}', () => {`,
-            "    cy.visit('/');",
-            `    // Linked code areas: ${linkedFiles}`,
-            '    // TODO: implement critical user path assertions',
-            '  });',
-            '});',
-            '',
-        ].join('\n');
-    }
-    if (framework === 'selenium') {
-        return [
-            "const {Builder} = require('selenium-webdriver');",
-            '',
-            '(async () => {',
-            "  const driver = await new Builder().forBrowser('chrome').build();",
-            '  try {',
-            "    await driver.get('http://localhost:3000');",
-            `    // Linked code areas: ${linkedFiles}`,
-            '    // TODO: implement critical user path assertions',
-            '  } finally {',
-            '    await driver.quit();',
-            '  }',
-            '})();',
-            '',
-        ].join('\n');
-    }
-    return [
-        "import {test, expect} from '@mattermost/playwright-lib';",
-        '',
-        `test('${flow.priority}: ${flow.name} critical path', {tag: '@ai-assisted'}, async ({pw}) => {`,
-        '  const {user, team} = await pw.initSetup();',
-        '  const {channelsPage} = await pw.testBrowser.login(user);',
-        "  await channelsPage.goto(team.name);",
-        `  // Linked code areas: ${linkedFiles}`,
-        '  // TODO: implement critical user path assertions',
-        '  await expect(channelsPage.page).toHaveURL(/.*/);',
-        '});',
-        '',
-    ].join('\n');
-}
-export function buildGapTestSuggestions(testsRoot, flowsWithGaps, framework, testPatterns) {
-    const testDir = inferTestDir(testPatterns);
-    const ext = inferExtension(testPatterns);
-    const resolvedFramework = normalizeFramework(framework);
-    return flowsWithGaps
-        .filter((flow) => flow.priority === 'P0' || flow.priority === 'P1')
-        .map((flow) => {
-        const fileName = resolvedFramework === 'cypress' ? `${flow.id}.cy.${ext}` : `${flow.id}.spec.${ext}`;
-        const candidatePath = resolve(testsRoot, testDir, fileName);
-        const suggestionPath = isPathWithinRoot(testsRoot, candidatePath)
-            ? candidatePath
-            : resolve(testsRoot, 'tests', fileName);
-        const sourceFiles = (flow.files || []).slice(0, 6);
-        const rationale = flow.reasons.length > 0 ? flow.reasons.join('; ') : 'High priority flow is currently uncovered';
-        return {
-            flowId: flow.id,
-            flowName: flow.name,
-            priority: flow.priority,
-            rationale,
-            sourceFiles,
-            suggestedTestPath: suggestionPath,
-            framework: resolvedFramework,
-            skeleton: buildSkeleton(flow, sourceFiles, resolvedFramework),
-        };
-    });
-}