@yasserkhanorg/e2e-agents 0.3.2

package/dist/agent/flags.js

@@ -0,0 +1,171 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeRole = normalizeRole;
+exports.normalizeRoles = normalizeRoles;
+exports.normalizeFlagSource = normalizeFlagSource;
+exports.normalizeFlagState = normalizeFlagState;
+exports.mergeFlags = mergeFlags;
+exports.extractFlagHits = extractFlagHits;
+exports.inferAudienceFromPath = inferAudienceFromPath;
+exports.formatFlags = formatFlags;
+exports.computeBlastRadius = computeBlastRadius;
+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',
+};
+function normalizeRole(role) {
+    const key = role.trim().toLowerCase();
+    return ROLE_ALIASES[key] ?? null;
+}
+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));
+}
+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';
+}
+function normalizeFlagState(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    const lowered = value.trim().toLowerCase();
+    if (lowered === 'on' || lowered === 'off' || lowered === 'unknown') {
+        return lowered;
+    }
+    return fallback;
+}
+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());
+}
+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);
+}
+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);
+}
+function formatFlags(flags) {
+    if (flags.length === 0) {
+        return 'none';
+    }
+    return flags.map((flag) => `${flag.name} (${flag.defaultState})`).join(', ');
+}
+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/agent/flow_catalog.d.ts

@@ -0,0 +1,25 @@
+import type { AgentConfig, AudienceRole } from './config.js';
+import type { FlowPriority } from './analysis.js';
+import { type FlagHit } from './flags.js';
+export interface FlowCatalogFlag {
+    name: string;
+    source?: string;
+    defaultState?: string;
+}
+export interface FlowCatalogEntry {
+    id: string;
+    name?: string;
+    priority: FlowPriority;
+    keywords?: string[];
+    paths?: string[];
+    tests?: string[];
+    description?: string;
+    audience?: AudienceRole[];
+    flags?: FlagHit[];
+}
+export interface FlowCatalog {
+    flows: FlowCatalogEntry[];
+    source: string;
+}
+export declare function loadFlowCatalog(config: AgentConfig): FlowCatalog | null;
+//# sourceMappingURL=flow_catalog.d.ts.map

package/dist/agent/flow_catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow_catalog.d.ts","sourceRoot":"","sources":["../../src/agent/flow_catalog.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,WAAW,EAAE,YAAY,EAAC,MAAM,aAAa,CAAC;AAC3D,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAChD,OAAO,EAA0D,KAAK,OAAO,EAAC,MAAM,YAAY,CAAC;AAGjG,MAAM,WAAW,eAAe;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,YAAY,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,YAAY,EAAE,CAAC;IAC1B,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,WAAW;IACxB,KAAK,EAAE,gBAAgB,EAAE,CAAC;IAC1B,MAAM,EAAE,MAAM,CAAC;CAClB;AA8FD,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,GAAG,IAAI,CAiBvE"}

package/dist/agent/flow_catalog.js

@@ -0,0 +1,106 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadFlowCatalog = loadFlowCatalog;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const flags_js_1 = require("./flags.js");
+const utils_js_1 = require("./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 = (0, flags_js_1.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: (0, flags_js_1.normalizeFlagSource)(flag.source),
+                defaultState: (0, flags_js_1.normalizeFlagState)(flag.defaultState, config.flags.defaultState),
+            });
+        }
+    }
+    return {
+        ...entry,
+        id: (0, utils_js_1.normalizePath)(entry.id),
+        name: entry.name || (0, utils_js_1.titleCase)(entry.id),
+        priority,
+        keywords: (entry.keywords || []).map((keyword) => keyword.toLowerCase()),
+        paths: (entry.paths || []).map((path) => (0, utils_js_1.normalizePath)(path)),
+        tests: (entry.tests || []).map((path) => (0, utils_js_1.normalizePath)(path)),
+        audience: normalizedAudience,
+        flags: normalizedFlags,
+    };
+}
+function readCatalog(path, config) {
+    try {
+        if (!(0, fs_1.existsSync)(path)) {
+            return null;
+        }
+        const mtimeMs = (0, fs_1.statSync)(path).mtimeMs;
+        const cached = catalogCache.get(path);
+        if (cached && cached.mtimeMs === mtimeMs) {
+            return cached.catalog;
+        }
+        const raw = JSON.parse((0, fs_1.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;
+    }
+}
+function loadFlowCatalog(config) {
+    const candidates = [];
+    if (config.flowCatalogPath) {
+        candidates.push(config.flowCatalogPath);
+    }
+    const testsRoot = config.testsRoot || config.path;
+    candidates.push((0, path_1.join)(testsRoot, '.e2e-ai-agents', 'flows.json'));
+    candidates.push((0, path_1.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/agent/flow_mapping.d.ts

@@ -0,0 +1,10 @@
+import type { FlowImpact } from './analysis.js';
+import type { AgentConfig } from './config.js';
+import type { FlowCatalog } from './flow_catalog.js';
+export interface CatalogMappingResult {
+    flows: FlowImpact[];
+    testsByFlow: Map<string, string[]>;
+    warnings: string[];
+}
+export declare function mapChangesToCatalogFlows(catalog: FlowCatalog, changedFiles: string[], mode: 'impact' | 'gap', config: AgentConfig): CatalogMappingResult;
+//# sourceMappingURL=flow_mapping.d.ts.map

package/dist/agent/flow_mapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow_mapping.d.ts","sourceRoot":"","sources":["../../src/agent/flow_mapping.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,mBAAmB,CAAC;AAGnD,MAAM,WAAW,oBAAoB;IACjC,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACnC,QAAQ,EAAE,MAAM,EAAE,CAAC;CACtB;AAqBD,wBAAgB,wBAAwB,CACpC,OAAO,EAAE,WAAW,EACpB,YAAY,EAAE,MAAM,EAAE,EACtB,IAAI,EAAE,QAAQ,GAAG,KAAK,EACtB,MAAM,EAAE,WAAW,GACpB,oBAAoB,CAuEtB"}

package/dist/agent/flow_mapping.js

@@ -0,0 +1,84 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapChangesToCatalogFlows = mapChangesToCatalogFlows;
+const utils_js_1 = require("./utils.js");
+function pathMatches(patterns, filePath) {
+    for (const pattern of patterns) {
+        if ((0, utils_js_1.matchGlob)(filePath, pattern)) {
+            return pattern;
+        }
+    }
+    return null;
+}
+function keywordMatches(keywords, filePath) {
+    const tokens = (0, utils_js_1.tokenize)(filePath);
+    for (const keyword of keywords) {
+        if (tokens.includes(keyword.toLowerCase())) {
+            return keyword;
+        }
+    }
+    return null;
+}
+function mapChangesToCatalogFlows(catalog, changedFiles, mode, config) {
+    const warnings = [];
+    const flows = [];
+    const testsByFlow = new Map();
+    const normalizedChanges = Array.from(new Set(changedFiles.map((file) => (0, utils_js_1.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: (0, utils_js_1.uniqueTokens)(reasons),
+            keywords: flow.keywords || [],
+            files: (0, utils_js_1.uniqueTokens)(matchedFilesList),
+            audience: flow.audience,
+            flags: flow.flags,
+        });
+        if (flow.tests && flow.tests.length > 0) {
+            testsByFlow.set(flow.id, flow.tests.map((test) => (0, utils_js_1.normalizePath)(test)));
+        }
+    }
+    if (flows.length === 0 && mode === 'impact') {
+        warnings.push('No flow catalog entries matched changed files.');
+    }
+    return { flows, testsByFlow, warnings };
+}

package/dist/agent/framework.d.ts

@@ -0,0 +1,13 @@
+import type { FrameworkType } from './config.js';
+export interface FrameworkDetection {
+    framework: FrameworkType;
+    configPath?: string;
+    reason: string;
+}
+export interface TestPatternResolution {
+    patterns: string[];
+    source: string;
+}
+export declare function detectFramework(appRoot: string, explicitFramework?: FrameworkType): FrameworkDetection;
+export declare function resolveTestPatterns(appRoot: string, detection: FrameworkDetection, explicitPatterns?: string[]): TestPatternResolution;
+//# sourceMappingURL=framework.d.ts.map

package/dist/agent/framework.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"framework.d.ts","sourceRoot":"","sources":["../../src/agent/framework.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,aAAa,CAAC;AAE/C,MAAM,WAAW,kBAAkB;IAC/B,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,qBAAqB;IAClC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAClB;AAmCD,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,iBAAiB,CAAC,EAAE,aAAa,GAAG,kBAAkB,CAmCtG;AA0CD,wBAAgB,mBAAmB,CAC/B,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,kBAAkB,EAC7B,gBAAgB,CAAC,EAAE,MAAM,EAAE,GAC5B,qBAAqB,CA+CvB"}

package/dist/agent/framework.js

@@ -0,0 +1,149 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectFramework = detectFramework;
+exports.resolveTestPatterns = resolveTestPatterns;
+const fs_1 = require("fs");
+const path_1 = require("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 = (0, path_1.join)(appRoot, 'package.json');
+    if (!(0, fs_1.existsSync)(pkgPath)) {
+        return undefined;
+    }
+    try {
+        return JSON.parse((0, fs_1.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 = (0, path_1.join)(appRoot, file);
+        if ((0, fs_1.existsSync)(fullPath)) {
+            return fullPath;
+        }
+    }
+    return undefined;
+}
+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 [
+            (0, path_1.join)(testDir, '**/*.spec.{ts,tsx,js,jsx}'),
+            (0, path_1.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 [];
+}
+function resolveTestPatterns(appRoot, detection, explicitPatterns) {
+    if (explicitPatterns && explicitPatterns.length > 0) {
+        return { patterns: explicitPatterns, source: 'config' };
+    }
+    if (detection.configPath) {
+        try {
+            const configContent = (0, fs_1.readFileSync)(detection.configPath, 'utf-8');
+            if (detection.framework === 'playwright') {
+                const parsed = parsePlaywrightPatterns(configContent);
+                if (parsed.length > 0) {
+                    return { patterns: parsed, source: (0, path_1.basename)(detection.configPath) };
+                }
+            }
+            if (detection.framework === 'cypress') {
+                const parsed = parseCypressPatterns(configContent);
+                if (parsed.length > 0) {
+                    return { patterns: parsed, source: (0, path_1.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/agent/gap_suggestions.d.ts

@@ -0,0 +1,14 @@
+import type { FrameworkType } from './config.js';
+import type { FlowImpact } from './analysis.js';
+export interface GapTestSuggestion {
+    flowId: string;
+    flowName: string;
+    priority: string;
+    rationale: string;
+    sourceFiles: string[];
+    suggestedTestPath: string;
+    framework: Exclude<FrameworkType, 'auto' | 'unknown'>;
+    skeleton: string;
+}
+export declare function buildGapTestSuggestions(testsRoot: string, flowsWithGaps: FlowImpact[], framework: FrameworkType, testPatterns: string[]): GapTestSuggestion[];
+//# sourceMappingURL=gap_suggestions.d.ts.map

package/dist/agent/gap_suggestions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gap_suggestions.d.ts","sourceRoot":"","sources":["../../src/agent/gap_suggestions.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,aAAa,CAAC;AAC/C,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAG9C,MAAM,WAAW,iBAAiB;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,SAAS,EAAE,OAAO,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;IACtD,QAAQ,EAAE,MAAM,CAAC;CACpB;AA0ED,wBAAgB,uBAAuB,CACnC,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,UAAU,EAAE,EAC3B,SAAS,EAAE,aAAa,EACxB,YAAY,EAAE,MAAM,EAAE,GACvB,iBAAiB,EAAE,CA0BrB"}