@yasserkhanorg/e2e-agents 0.3.2

package/dist/esm/agent/flow_catalog.js

@@ -0,0 +1,103 @@
+// 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)) {
+            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) {
+            catalogCache.set(path, { mtimeMs, catalog: null });
+            return null;
+        }
+        const catalog = { flows, source: path };
+        catalogCache.set(path, { mtimeMs, catalog });
+        return catalog;
+    }
+    catch {
+        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

@@ -0,0 +1,81 @@
+// 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

@@ -0,0 +1,145 @@
+// 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

@@ -0,0 +1,98 @@
+// 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),
+        };
+    });
+}

package/dist/esm/agent/generator.js

@@ -0,0 +1,112 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join, 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 inferTestExtension(patterns, framework) {
+    const joined = patterns.join(' ');
+    if (joined.includes('.ts') || joined.includes('.tsx')) {
+        return 'ts';
+    }
+    return 'js';
+}
+function createPlaywrightTest(flow, testIds) {
+    const idsComment = testIds.length > 0 ? `// Suggested data-testid: ${testIds.join(', ')}` : '// TODO: add data-testid selectors';
+    return [
+        "import {test, expect} from '@mattermost/playwright-lib';",
+        '',
+        '/**',
+        ` * @objective Validate ${flow.name} flow`,
+        ' */',
+        `test('${flow.priority}: ${flow.name} basic flow', {tag: '@ai-assisted'}, async ({pw}) => {`,
+        '  const {user, team} = await pw.initSetup();',
+        '  const {channelsPage} = await pw.testBrowser.login(user);',
+        "  await channelsPage.goto(team.name);",
+        `  ${idsComment}`,
+        '  // # TODO: implement steps',
+        '  // * TODO: implement assertions',
+        '  await expect(channelsPage.page).toHaveURL(/.*/);',
+        '});',
+        '',
+    ].join('\n');
+}
+function createCypressTest(flow, testIds) {
+    const idsComment = testIds.length > 0 ? `// Suggested data-testid: ${testIds.join(', ')}` : '// TODO: add data-testid selectors';
+    return [
+        `describe('Flow: ${flow.name}', () => {`,
+        `  it('${flow.priority}: ${flow.name} basic flow', () => {`,
+        "    cy.visit('/');",
+        `    ${idsComment}`,
+        '    // TODO: implement steps',
+        '    cy.url().should(\'match\', /.*/);',
+        '  });',
+        '});',
+        '',
+    ].join('\n');
+}
+function createSeleniumTest(flow, testIds) {
+    const idsComment = testIds.length > 0 ? `// Suggested data-testid: ${testIds.join(', ')}` : '// TODO: add data-testid selectors';
+    return [
+        "const {Builder, By, until} = require('selenium-webdriver');",
+        '',
+        `(async () => {`,
+        "  const driver = await new Builder().forBrowser('chrome').build();",
+        '  try {',
+        "    await driver.get('http://localhost:3000');",
+        `    ${idsComment}`,
+        '    // TODO: implement steps',
+        '    await driver.wait(until.titleIs(\'\'), 5000);',
+        '  } finally {',
+        '    await driver.quit();',
+        '  }',
+        '})();',
+        '',
+    ].join('\n');
+}
+export function generateTests(appRoot, flows, framework, testPatterns, testIdsByFlow) {
+    const inferredTestDir = inferTestDir(testPatterns);
+    const safeTestDir = isPathWithinRoot(appRoot, resolve(appRoot, inferredTestDir)) ? inferredTestDir : 'tests';
+    const testDir = safeTestDir;
+    const extension = inferTestExtension(testPatterns, framework);
+    const generated = [];
+    for (const flow of flows) {
+        if (flow.priority !== 'P0' && flow.priority !== 'P1') {
+            continue;
+        }
+        const testIds = testIdsByFlow.get(flow.id) || [];
+        const fileName = framework === 'cypress' ? `${flow.id}.cy.${extension}` : `${flow.id}.spec.${extension}`;
+        const fullPath = resolve(appRoot, testDir, fileName);
+        if (!isPathWithinRoot(appRoot, fullPath)) {
+            generated.push({ path: fullPath, flowId: flow.id, created: false, reason: 'outside-root' });
+            continue;
+        }
+        if (existsSync(fullPath)) {
+            generated.push({ path: fullPath, flowId: flow.id, created: false, reason: 'exists' });
+            continue;
+        }
+        mkdirSync(join(appRoot, testDir), { recursive: true });
+        let content = '';
+        if (framework === 'cypress') {
+            content = createCypressTest(flow, testIds);
+        }
+        else if (framework === 'selenium') {
+            content = createSeleniumTest(flow, testIds);
+        }
+        else {
+            content = createPlaywrightTest(flow, testIds);
+        }
+        writeFileSync(fullPath, content, 'utf-8');
+        generated.push({ path: fullPath, flowId: flow.id, created: true });
+    }
+    return generated;
+}

package/dist/esm/agent/git.js

@@ -0,0 +1,87 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+import { spawnSync } from 'child_process';
+import { normalizePath } from './utils.js';
+function runGitRaw(args, cwd) {
+    const result = spawnSync('git', args, {
+        cwd,
+        encoding: 'utf-8',
+        timeout: 30000,
+    });
+    if (result.error || result.status !== 0) {
+        return null;
+    }
+    return result.stdout;
+}
+function runGit(args, cwd) {
+    const output = runGitRaw(args, cwd);
+    if (output === null) {
+        return null;
+    }
+    return output
+        .split('\n')
+        .map((file) => file.trim())
+        .filter(Boolean)
+        .map((file) => normalizePath(file));
+}
+function parseStatusLines(lines) {
+    const files = [];
+    for (const line of lines) {
+        if (!line)
+            continue;
+        if (line.length < 4)
+            continue;
+        const pathPart = line.slice(3).trim();
+        if (!pathPart)
+            continue;
+        if (pathPart.includes('->')) {
+            const parts = pathPart.split('->').map((part) => part.trim());
+            const target = parts[parts.length - 1];
+            if (target) {
+                files.push(normalizePath(target));
+            }
+        }
+        else {
+            files.push(normalizePath(pathPart));
+        }
+    }
+    return files;
+}
+export function getChangedFiles(appRoot, since, options) {
+    try {
+        const files = new Set();
+        let baseRef = since;
+        let baseStrategy = 'direct';
+        const mergeBase = runGitRaw(['merge-base', since, 'HEAD'], appRoot);
+        if (mergeBase) {
+            const candidate = mergeBase
+                .split('\n')
+                .map((line) => line.trim())
+                .find(Boolean);
+            if (candidate) {
+                baseRef = candidate;
+                baseStrategy = 'merge-base';
+            }
+        }
+        const diffFiles = runGit(['diff', '--name-only', `${baseRef}..HEAD`, '--', '.'], appRoot);
+        if (!diffFiles) {
+            return { files: [], error: 'git diff failed' };
+        }
+        diffFiles.forEach((file) => files.add(file));
+        if (options?.includeUncommitted) {
+            const staged = runGit(['diff', '--name-only', '--cached', '--', '.'], appRoot) || [];
+            staged.forEach((file) => files.add(file));
+            const unstaged = runGit(['diff', '--name-only', '--', '.'], appRoot) || [];
+            unstaged.forEach((file) => files.add(file));
+            const statusOutput = runGitRaw(['status', '--porcelain', '--', '.'], appRoot);
+            if (statusOutput) {
+                const statusLines = statusOutput.split('\n').filter(Boolean);
+                parseStatusLines(statusLines).forEach((file) => files.add(file));
+            }
+        }
+        return { files: Array.from(files), baseRef, baseStrategy };
+    }
+    catch {
+        return { files: [], error: 'git diff failed' };
+    }
+}