@yasserkhanorg/e2e-agents 0.5.16 → 0.6.0

package/dist/esm/agent/analysis.js

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

@@ -1,34 +0,0 @@
-// 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/dependency_graph.js

@@ -1,224 +0,0 @@
-// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
-// See LICENSE.txt for license information.
-import { globSync } from 'glob';
-import { dirname, join, normalize } from 'path';
-import { normalizePath, safeReadTextFile } from './utils.js';
-const IMPORT_REGEXES = [
-    /import\s+[\s\S]*?\s+from\s+['"]([^'"]+)['"]/g,
-    /import\s+['"]([^'"]+)['"]/g,
-    /export\s+[\s\S]*?\s+from\s+['"]([^'"]+)['"]/g,
-    /require\(\s*['"]([^'"]+)['"]\s*\)/g,
-    /import\(\s*['"]([^'"]+)['"]\s*\)/g,
-];
-const RESOLVABLE_EXTENSIONS = ['ts', 'tsx', 'js', 'jsx', 'mjs', 'cjs'];
-function extractImportSpecifiers(content) {
-    const imports = [];
-    for (const regex of IMPORT_REGEXES) {
-        regex.lastIndex = 0;
-        let match = regex.exec(content);
-        while (match) {
-            const specifier = match[1];
-            if (specifier) {
-                imports.push(specifier);
-            }
-            match = regex.exec(content);
-        }
-    }
-    return Array.from(new Set(imports));
-}
-function listCandidateFiles(appRoot, cfg) {
-    const files = new Set();
-    for (const pattern of cfg.filePatterns) {
-        const matches = globSync(pattern, {
-            cwd: appRoot,
-            nodir: true,
-            ignore: cfg.excludePatterns,
-        });
-        for (const match of matches) {
-            files.add(normalizePath(match));
-        }
-    }
-    return Array.from(files);
-}
-function resolveWithCandidates(candidateBase, fileSet) {
-    if (fileSet.has(candidateBase)) {
-        return candidateBase;
-    }
-    for (const ext of RESOLVABLE_EXTENSIONS) {
-        const withExt = `${candidateBase}.${ext}`;
-        if (fileSet.has(withExt)) {
-            return withExt;
-        }
-    }
-    for (const ext of RESOLVABLE_EXTENSIONS) {
-        const indexPath = `${candidateBase}/index.${ext}`;
-        if (fileSet.has(indexPath)) {
-            return indexPath;
-        }
-    }
-    return null;
-}
-function expandAliasTarget(pattern, target, specifier) {
-    const normalizedPattern = normalizePath(pattern);
-    const normalizedTarget = normalizePath(target);
-    const normalizedSpecifier = normalizePath(specifier);
-    if (normalizedPattern.endsWith('/*')) {
-        const prefix = normalizedPattern.slice(0, -2);
-        if (normalizedSpecifier === prefix || normalizedSpecifier.startsWith(`${prefix}/`)) {
-            const suffix = normalizedSpecifier === prefix ? '' : normalizedSpecifier.slice(prefix.length + 1);
-            if (normalizedTarget.endsWith('/*')) {
-                const targetPrefix = normalizedTarget.slice(0, -2);
-                return suffix ? normalizePath(`${targetPrefix}/${suffix}`) : normalizePath(targetPrefix);
-            }
-            return normalizePath(normalizedTarget);
-        }
-        return null;
-    }
-    if (normalizedPattern === normalizedSpecifier) {
-        if (normalizedTarget.endsWith('/*')) {
-            return normalizePath(normalizedTarget.slice(0, -2));
-        }
-        return normalizePath(normalizedTarget);
-    }
-    return null;
-}
-function resolvePathAliasImport(specifier, fileSet, cfg) {
-    for (const [pattern, targets] of Object.entries(cfg.pathAliases)) {
-        for (const target of targets) {
-            const aliasPath = expandAliasTarget(pattern, target, specifier);
-            if (!aliasPath) {
-                continue;
-            }
-            const resolved = resolveWithCandidates(aliasPath, fileSet);
-            if (resolved) {
-                return resolved;
-            }
-        }
-    }
-    return null;
-}
-function resolveImport(fromFile, specifier, fileSet, cfg) {
-    if (specifier.startsWith('.')) {
-        const fromDir = dirname(fromFile);
-        const relativeCandidate = normalizePath(normalize(join(fromDir, specifier)));
-        return resolveWithCandidates(relativeCandidate, fileSet);
-    }
-    const aliasResolved = resolvePathAliasImport(specifier, fileSet, cfg);
-    if (aliasResolved) {
-        return aliasResolved;
-    }
-    for (const root of cfg.aliasRoots) {
-        const rootedCandidate = normalizePath(normalize(join(root, specifier)));
-        const resolved = resolveWithCandidates(rootedCandidate, fileSet);
-        if (resolved) {
-            return resolved;
-        }
-    }
-    const directCandidate = normalizePath(specifier);
-    return resolveWithCandidates(directCandidate, fileSet);
-}
-export function expandByDependencyGraph(appRoot, changedFiles, cfg) {
-    const warnings = [];
-    if (!cfg.enabled) {
-        return {
-            source: 'static-dependency-graph',
-            seedFiles: [],
-            impactedFiles: [],
-            expandedFiles: [],
-            analyzedFiles: 0,
-            analyzedEdges: 0,
-            maxDepth: 0,
-            truncated: false,
-            warnings,
-        };
-    }
-    const candidates = listCandidateFiles(appRoot, cfg);
-    const fileSet = new Set(candidates);
-    if (candidates.length === 0) {
-        warnings.push('Dependency graph found no candidate source files.');
-    }
-    const reverse = new Map();
-    let analyzedEdges = 0;
-    for (const file of candidates) {
-        const fullPath = join(appRoot, file);
-        const content = safeReadTextFile(fullPath);
-        if (!content) {
-            continue;
-        }
-        const imports = extractImportSpecifiers(content);
-        for (const specifier of imports) {
-            const resolved = resolveImport(file, specifier, fileSet, cfg);
-            if (!resolved) {
-                continue;
-            }
-            if (!reverse.has(resolved)) {
-                reverse.set(resolved, new Set());
-            }
-            reverse.get(resolved)?.add(file);
-            analyzedEdges += 1;
-        }
-    }
-    const seeds = Array.from(new Set(changedFiles
-        .map((file) => normalizePath(file))
-        .filter((file) => fileSet.has(file))));
-    if (seeds.length === 0) {
-        warnings.push('No changed files were found in dependency graph candidates.');
-        return {
-            source: 'static-dependency-graph',
-            seedFiles: [],
-            impactedFiles: [],
-            expandedFiles: [],
-            analyzedFiles: candidates.length,
-            analyzedEdges,
-            maxDepth: cfg.maxDepth,
-            truncated: false,
-            warnings,
-        };
-    }
-    const impacted = new Set(seeds);
-    const queue = seeds.map((file) => ({ file, depth: 0 }));
-    let truncated = false;
-    while (queue.length > 0) {
-        const next = queue.shift();
-        if (!next) {
-            continue;
-        }
-        if (next.depth >= cfg.maxDepth) {
-            continue;
-        }
-        const dependents = reverse.get(next.file);
-        if (!dependents) {
-            continue;
-        }
-        for (const dependent of dependents) {
-            if (impacted.has(dependent)) {
-                continue;
-            }
-            if (impacted.size - seeds.length >= cfg.maxExpandedFiles) {
-                truncated = true;
-                break;
-            }
-            impacted.add(dependent);
-            queue.push({ file: dependent, depth: next.depth + 1 });
-        }
-        if (truncated) {
-            break;
-        }
-    }
-    const impactedFiles = Array.from(impacted);
-    const expandedFiles = impactedFiles.filter((file) => !seeds.includes(file));
-    if (truncated) {
-        warnings.push(`Dependency expansion was truncated at maxExpandedFiles=${cfg.maxExpandedFiles}.`);
-    }
-    return {
-        source: 'static-dependency-graph',
-        seedFiles: seeds,
-        impactedFiles,
-        expandedFiles,
-        analyzedFiles: candidates.length,
-        analyzedEdges,
-        maxDepth: cfg.maxDepth,
-        truncated,
-        warnings,
-    };
-}