@yasserkhanorg/e2e-agents 0.3.2

package/dist/agent/dependency_graph.js

@@ -0,0 +1,227 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandByDependencyGraph = expandByDependencyGraph;
+const glob_1 = require("glob");
+const path_1 = require("path");
+const utils_js_1 = require("./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 = (0, glob_1.globSync)(pattern, {
+            cwd: appRoot,
+            nodir: true,
+            ignore: cfg.excludePatterns,
+        });
+        for (const match of matches) {
+            files.add((0, utils_js_1.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 = (0, utils_js_1.normalizePath)(pattern);
+    const normalizedTarget = (0, utils_js_1.normalizePath)(target);
+    const normalizedSpecifier = (0, utils_js_1.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 ? (0, utils_js_1.normalizePath)(`${targetPrefix}/${suffix}`) : (0, utils_js_1.normalizePath)(targetPrefix);
+            }
+            return (0, utils_js_1.normalizePath)(normalizedTarget);
+        }
+        return null;
+    }
+    if (normalizedPattern === normalizedSpecifier) {
+        if (normalizedTarget.endsWith('/*')) {
+            return (0, utils_js_1.normalizePath)(normalizedTarget.slice(0, -2));
+        }
+        return (0, utils_js_1.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 = (0, path_1.dirname)(fromFile);
+        const relativeCandidate = (0, utils_js_1.normalizePath)((0, path_1.normalize)((0, path_1.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 = (0, utils_js_1.normalizePath)((0, path_1.normalize)((0, path_1.join)(root, specifier)));
+        const resolved = resolveWithCandidates(rootedCandidate, fileSet);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    const directCandidate = (0, utils_js_1.normalizePath)(specifier);
+    return resolveWithCandidates(directCandidate, fileSet);
+}
+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 = (0, path_1.join)(appRoot, file);
+        const content = (0, utils_js_1.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) => (0, utils_js_1.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,
+    };
+}

package/dist/agent/feedback.d.ts

@@ -0,0 +1,55 @@
+export interface RecommendationFeedbackEntry {
+    timestamp: string;
+    runSet: 'smoke' | 'targeted' | 'full';
+    recommendedTests: string[];
+    executedTests: string[];
+    failedTests: string[];
+    escapedFailures?: string[];
+}
+export interface CalibrationSummary {
+    schemaVersion: '1.1.0';
+    generatedAt: string;
+    samples: number;
+    overall: {
+        precision: number;
+        recall: number;
+        falseNegativeRate: number;
+    };
+    recent7d: {
+        precision: number;
+        recall: number;
+        falseNegativeRate: number;
+        samples: number;
+    };
+    recent30d: {
+        precision: number;
+        recall: number;
+        falseNegativeRate: number;
+        samples: number;
+    };
+    bySubsystem: Record<string, {
+        precision: number;
+        recall: number;
+        falseNegativeRate: number;
+        samples: number;
+        recent7d: {
+            precision: number;
+            recall: number;
+            falseNegativeRate: number;
+            samples: number;
+        };
+        recent30d: {
+            precision: number;
+            recall: number;
+            falseNegativeRate: number;
+            samples: number;
+        };
+    }>;
+}
+export declare function appendFeedbackAndRecompute(appRoot: string, input: RecommendationFeedbackEntry): {
+    feedbackPath: string;
+    calibrationPath: string;
+    calibration: CalibrationSummary;
+};
+export declare function readCalibration(appRoot: string): CalibrationSummary | null;
+//# sourceMappingURL=feedback.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feedback.d.ts","sourceRoot":"","sources":["../../src/agent/feedback.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,2BAA2B;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,OAAO,GAAG,UAAU,GAAG,MAAM,CAAC;IACtC,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B;AAED,MAAM,WAAW,kBAAkB;IAC/B,aAAa,EAAE,OAAO,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE;QACL,SAAS,EAAE,MAAM,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;QACf,iBAAiB,EAAE,MAAM,CAAC;KAC7B,CAAC;IACF,QAAQ,EAAE;QACN,SAAS,EAAE,MAAM,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;QACf,iBAAiB,EAAE,MAAM,CAAC;QAC1B,OAAO,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,SAAS,EAAE;QACP,SAAS,EAAE,MAAM,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;QACf,iBAAiB,EAAE,MAAM,CAAC;QAC1B,OAAO,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,WAAW,EAAE,MAAM,CACnB,MAAM,EACN;QACI,SAAS,EAAE,MAAM,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;QACf,iBAAiB,EAAE,MAAM,CAAC;QAC1B,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,EAAE;YACN,SAAS,EAAE,MAAM,CAAC;YAClB,MAAM,EAAE,MAAM,CAAC;YACf,iBAAiB,EAAE,MAAM,CAAC;YAC1B,OAAO,EAAE,MAAM,CAAC;SACnB,CAAC;QACF,SAAS,EAAE;YACP,SAAS,EAAE,MAAM,CAAC;YAClB,MAAM,EAAE,MAAM,CAAC;YACf,iBAAiB,EAAE,MAAM,CAAC;YAC1B,OAAO,EAAE,MAAM,CAAC;SACnB,CAAC;KACL,CACA,CAAC;CACL;AAkSD,wBAAgB,0BAA0B,CACtC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,2BAA2B,GACnC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,kBAAkB,CAAA;CAAC,CAwBlF;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CAE1E"}

package/dist/agent/feedback.js

@@ -0,0 +1,257 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendFeedbackAndRecompute = appendFeedbackAndRecompute;
+exports.readCalibration = readCalibration;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const test_path_js_1 = require("./test_path.js");
+function readJson(path) {
+    if (!(0, fs_1.existsSync)(path)) {
+        return null;
+    }
+    try {
+        return JSON.parse((0, fs_1.readFileSync)(path, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeTestName(test) {
+    return test.replace(/ \(flags:.*\)$/, '').trim();
+}
+function asSet(values) {
+    return new Set(values.map(normalizeTestName).filter(Boolean));
+}
+function ratio(numerator, denominator) {
+    if (denominator <= 0) {
+        return 0;
+    }
+    return Number((numerator / denominator).toFixed(4));
+}
+function subsystemForTest(test) {
+    return (0, test_path_js_1.inferSubsystemFromTestPath)(test);
+}
+function parseTimestamp(value) {
+    const time = Date.parse(value);
+    if (Number.isNaN(time)) {
+        return null;
+    }
+    return time;
+}
+function filterRecent(entries, days) {
+    const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+    return entries.filter((entry) => {
+        const time = parseTimestamp(entry.timestamp);
+        return time !== null && time >= cutoff;
+    });
+}
+function aggregateMetrics(entries) {
+    let truePositives = 0;
+    let recommendedTotal = 0;
+    let failuresTotal = 0;
+    let escapedTotal = 0;
+    for (const entry of entries) {
+        const recommended = asSet(entry.recommendedTests || []);
+        const failed = asSet(entry.failedTests || []);
+        const escaped = asSet(entry.escapedFailures || []);
+        const tp = Array.from(recommended).filter((test) => failed.has(test)).length;
+        truePositives += tp;
+        recommendedTotal += recommended.size;
+        failuresTotal += failed.size;
+        escapedTotal += escaped.size;
+    }
+    return {
+        precision: ratio(truePositives, recommendedTotal),
+        recall: ratio(truePositives, failuresTotal),
+        falseNegativeRate: ratio(escapedTotal, failuresTotal + escapedTotal),
+        samples: entries.length,
+    };
+}
+function aggregate(entries) {
+    const subsystemAcc = new Map();
+    for (const entry of entries) {
+        const recommended = asSet(entry.recommendedTests || []);
+        const failed = asSet(entry.failedTests || []);
+        const escaped = asSet(entry.escapedFailures || []);
+        const allSubsystems = new Set([
+            ...Array.from(recommended).map(subsystemForTest),
+            ...Array.from(failed).map(subsystemForTest),
+            ...Array.from(escaped).map(subsystemForTest),
+        ]);
+        for (const subsystem of allSubsystems) {
+            const bucket = subsystemAcc.get(subsystem) || { entries: [] };
+            bucket.entries.push({
+                ...entry,
+                recommendedTests: Array.from(recommended).filter((test) => subsystemForTest(test) === subsystem),
+                executedTests: (entry.executedTests || []).filter((test) => subsystemForTest(test) === subsystem),
+                failedTests: Array.from(failed).filter((test) => subsystemForTest(test) === subsystem),
+                escapedFailures: Array.from(escaped).filter((test) => subsystemForTest(test) === subsystem),
+            });
+            subsystemAcc.set(subsystem, bucket);
+        }
+    }
+    const bySubsystem = {};
+    for (const [subsystem, bucket] of subsystemAcc.entries()) {
+        const all = aggregateMetrics(bucket.entries);
+        const recent7d = aggregateMetrics(filterRecent(bucket.entries, 7));
+        const recent30d = aggregateMetrics(filterRecent(bucket.entries, 30));
+        bySubsystem[subsystem] = {
+            precision: all.precision,
+            recall: all.recall,
+            falseNegativeRate: all.falseNegativeRate,
+            samples: all.samples,
+            recent7d,
+            recent30d,
+        };
+    }
+    const overall = aggregateMetrics(entries);
+    const recent7d = aggregateMetrics(filterRecent(entries, 7));
+    const recent30d = aggregateMetrics(filterRecent(entries, 30));
+    return {
+        schemaVersion: '1.1.0',
+        generatedAt: new Date().toISOString(),
+        samples: entries.length,
+        overall,
+        recent7d,
+        recent30d,
+        bySubsystem,
+    };
+}
+function rateFor(runs, failed) {
+    return runs > 0 ? Number((failed / runs).toFixed(4)) : 0;
+}
+function trendFor(rate7d, rate30d) {
+    if (rate7d - rate30d >= 0.08) {
+        return 'up';
+    }
+    if (rate30d - rate7d >= 0.08) {
+        return 'down';
+    }
+    return 'stable';
+}
+function loadOwners(appRoot) {
+    const path = (0, path_1.join)(appRoot, '.e2e-ai-agents', 'subsystem-owners.json');
+    const manifest = readJson(path);
+    if (!manifest) {
+        return {};
+    }
+    if (manifest.ownersBySubsystem) {
+        return manifest.ownersBySubsystem;
+    }
+    if (manifest.subsystems) {
+        return manifest.subsystems;
+    }
+    return {};
+}
+function daysSince(value) {
+    if (!value) {
+        return null;
+    }
+    const time = parseTimestamp(value);
+    if (time === null) {
+        return null;
+    }
+    return (Date.now() - time) / (24 * 60 * 60 * 1000);
+}
+function aggregateFlaky(entries, appRoot) {
+    const acc = new Map();
+    const cutoff7 = Date.now() - 7 * 24 * 60 * 60 * 1000;
+    const cutoff30 = Date.now() - 30 * 24 * 60 * 60 * 1000;
+    const ownersBySubsystem = loadOwners(appRoot);
+    for (const entry of entries) {
+        const executed = asSet(entry.executedTests || []);
+        const failed = asSet(entry.failedTests || []);
+        const time = parseTimestamp(entry.timestamp);
+        for (const test of executed) {
+            const bucket = acc.get(test) || {
+                runs: 0,
+                failed: 0,
+                runs7d: 0,
+                failed7d: 0,
+                runs30d: 0,
+                failed30d: 0,
+                lastFailureAt: undefined,
+            };
+            bucket.runs += 1;
+            if (time !== null && time >= cutoff7) {
+                bucket.runs7d += 1;
+            }
+            if (time !== null && time >= cutoff30) {
+                bucket.runs30d += 1;
+            }
+            if (failed.has(test)) {
+                bucket.failed += 1;
+                bucket.lastFailureAt = entry.timestamp;
+                if (time !== null && time >= cutoff7) {
+                    bucket.failed7d += 1;
+                }
+                if (time !== null && time >= cutoff30) {
+                    bucket.failed30d += 1;
+                }
+            }
+            acc.set(test, bucket);
+        }
+    }
+    const tests = Array.from(acc.entries())
+        .map(([test, bucket]) => {
+        const flakeRate = rateFor(bucket.runs, bucket.failed);
+        const flakeRate7d = rateFor(bucket.runs7d, bucket.failed7d);
+        const flakeRate30d = rateFor(bucket.runs30d, bucket.failed30d);
+        const trend = trendFor(flakeRate7d, flakeRate30d);
+        const quarantine = (bucket.runs30d >= 5 && flakeRate30d >= 0.35) || (bucket.runs >= 8 && flakeRate >= 0.4);
+        const daysFromLastFailure = daysSince(bucket.lastFailureAt);
+        const quarantineState = quarantine
+            ? (daysFromLastFailure !== null && daysFromLastFailure >= 14 && flakeRate7d <= 0.05 ? 'retire-candidate' : 'active')
+            : 'none';
+        const subsystem = subsystemForTest(test);
+        const owners = ownersBySubsystem[subsystem] || [];
+        return {
+            test,
+            subsystem,
+            owners,
+            flakeRate,
+            flakeRate7d,
+            flakeRate30d,
+            trend,
+            quarantine,
+            quarantineState,
+            lastFailureAt: bucket.lastFailureAt,
+            samples: bucket.runs,
+            samples7d: bucket.runs7d,
+            samples30d: bucket.runs30d,
+        };
+    })
+        .filter((entry) => entry.flakeRate > 0)
+        .sort((a, b) => (b.flakeRate30d || b.flakeRate) - (a.flakeRate30d || a.flakeRate));
+    return {
+        schemaVersion: '1.1.0',
+        generatedAt: new Date().toISOString(),
+        tests,
+    };
+}
+function appendFeedbackAndRecompute(appRoot, input) {
+    const baseDir = (0, path_1.join)(appRoot, '.e2e-ai-agents');
+    (0, fs_1.mkdirSync)(baseDir, { recursive: true });
+    const feedbackPath = (0, path_1.join)(baseDir, 'feedback.json');
+    const existing = readJson(feedbackPath) || { schemaVersion: '1.0.0', entries: [] };
+    existing.entries.push({
+        ...input,
+        recommendedTests: input.recommendedTests || [],
+        executedTests: input.executedTests || [],
+        failedTests: input.failedTests || [],
+        escapedFailures: input.escapedFailures || [],
+    });
+    (0, fs_1.writeFileSync)(feedbackPath, JSON.stringify(existing, null, 2), 'utf-8');
+    const calibration = aggregate(existing.entries);
+    const calibrationPath = (0, path_1.join)(baseDir, 'calibration.json');
+    (0, fs_1.writeFileSync)(calibrationPath, JSON.stringify(calibration, null, 2), 'utf-8');
+    const flaky = aggregateFlaky(existing.entries, appRoot);
+    const flakyPath = (0, path_1.join)(baseDir, 'flaky-tests.json');
+    (0, fs_1.writeFileSync)(flakyPath, JSON.stringify(flaky, null, 2), 'utf-8');
+    return { feedbackPath, calibrationPath, calibration };
+}
+function readCalibration(appRoot) {
+    return readJson((0, path_1.join)(appRoot, '.e2e-ai-agents', 'calibration.json'));
+}

package/dist/agent/flags.d.ts

@@ -0,0 +1,23 @@
+import type { AgentConfig, AudienceRole, FlagState } from './config.js';
+export type FlagSource = 'featureFlag' | 'configFlag' | 'testGate';
+export interface FlagHit {
+    name: string;
+    source: FlagSource;
+    defaultState: FlagState;
+}
+export interface BlastRadius {
+    audience: AudienceRole[];
+    flags: FlagHit[];
+    summary: string;
+    scoreDelta: number;
+}
+export declare function normalizeRole(role: string): AudienceRole | null;
+export declare function normalizeRoles(roles: string[], fallback: AudienceRole[]): AudienceRole[];
+export declare function normalizeFlagSource(source?: string): FlagSource;
+export declare function normalizeFlagState(value: string | undefined, fallback: FlagState): FlagState;
+export declare function mergeFlags(flags: FlagHit[], defaultState: FlagState): FlagHit[];
+export declare function extractFlagHits(content: string | null, config: AgentConfig): FlagHit[];
+export declare function inferAudienceFromPath(relativePath: string, config: AgentConfig): AudienceRole[];
+export declare function formatFlags(flags: FlagHit[]): string;
+export declare function computeBlastRadius(audience: AudienceRole[], flags: FlagHit[], config: AgentConfig): BlastRadius;
+//# sourceMappingURL=flags.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flags.d.ts","sourceRoot":"","sources":["../../src/agent/flags.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,WAAW,EAAE,YAAY,EAAE,SAAS,EAAC,MAAM,aAAa,CAAC;AAEtE,MAAM,MAAM,UAAU,GAAG,aAAa,GAAG,YAAY,GAAG,UAAU,CAAC;AAEnE,MAAM,WAAW,OAAO;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,UAAU,CAAC;IACnB,YAAY,EAAE,SAAS,CAAC;CAC3B;AAED,MAAM,WAAW,WAAW;IACxB,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACtB;AAkCD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAG/D;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,YAAY,EAAE,CAOxF;AAED,wBAAgB,mBAAmB,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,UAAU,CAe/D;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,QAAQ,EAAE,SAAS,GAAG,SAAS,CAS5F;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,YAAY,EAAE,SAAS,GAAG,OAAO,EAAE,CAY/E;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,EAAE,CAiCtF;AAED,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,YAAY,EAAE,CAa/F;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,MAAM,CAKpD;AAED,wBAAgB,kBAAkB,CAC9B,QAAQ,EAAE,YAAY,EAAE,EACxB,KAAK,EAAE,OAAO,EAAE,EAChB,MAAM,EAAE,WAAW,GACpB,WAAW,CAqCb"}