@yasserkhanorg/e2e-agents 0.3.3 → 0.3.5

package/README.md

@@ -134,6 +134,7 @@ Run AI-driven impact analysis or gap analysis on any frontend repo.
 npx e2e-ai-agents impact --path /path/to/webapp
 npx e2e-ai-agents gap --path /path/to/webapp
 npx e2e-ai-agents plan --path /path/to/webapp
+npx e2e-ai-agents suggest --path /path/to/webapp --mattermost
 npx e2e-ai-agents generate --path /path/to/webapp --pipeline
 npx e2e-ai-agents heal --path /path/to/webapp --traceability-report ./playwright-report.json
 npx e2e-ai-agents suggest --path /path/to/webapp
@@ -144,6 +145,26 @@ npx e2e-ai-agents traceability-capture --path /path/to/webapp --traceability-rep
 npx e2e-ai-agents traceability-ingest --path /path/to/webapp --traceability-input ./traceability-input.json
 ```
 
+Local approval workflow (dev/QA + AI) with one review artifact:
+
+```bash
+# 1) Suggest and generate local review + pending approval JSON
+node scripts/local-impact-workflow.js suggest --config ./e2e-ai-agents.config.json --since master
+
+# 2) Approve or reject after review
+node scripts/local-impact-workflow.js approve --config ./e2e-ai-agents.config.json --decision approve --note "QA approved"
+
+# 3) Generate/heal only after approval
+node scripts/local-impact-workflow.js generate --config ./e2e-ai-agents.config.json --since master --pipeline-dry-run
+# Generates in MCP-only mode by default (AI generation/healing only).
+# Optional: tune MCP timeout per call:
+# node scripts/local-impact-workflow.js generate --config ./e2e-ai-agents.config.json --since master --pipeline-mcp-timeout-ms 120000
+```
+
+Generated local artifacts:
+- `<tests-root>/.e2e-ai-agents/local-impact-review.md`
+- `<tests-root>/.e2e-ai-agents/local-impact-approval.json`
+
 If tests live outside the app root:
 
 ```bash
@@ -155,6 +176,7 @@ Optional config file `e2e-ai-agents.config.json` (JSON):
 ```json
 {
   "path": ".",
+  "profile": "default",
   "testsRoot": ".",
   "flowCatalogPath": ".e2e-ai-agents/flows.json",
   "mode": "impact",
@@ -195,6 +217,31 @@ Optional config file `e2e-ai-agents.config.json` (JSON):
       "enabled": false,
       "mapPath": ".e2e-ai-agents/subsystem-risk-map.json",
       "maxRulesPerFile": 4
+    },
+    "aiFlow": {
+      "enabled": true,
+      "strict": true,
+      "provider": "anthropic",
+      "contextFiles": [
+        "CLAUDE.OPTIONAL.md",
+        ".claude/CLAUDE.OPTIONAL.md"
+      ],
+      "maxFilesPerRequest": 220,
+      "maxFlowsPerRequest": 80,
+      "maxTokens": 4000,
+      "temperature": 0
+    },
+    "aiMapping": {
+      "enabled": false,
+      "provider": "anthropic",
+      "contextFiles": [
+        "CLAUDE.OPTIONAL.md",
+        ".claude/CLAUDE.OPTIONAL.md"
+      ],
+      "maxFlowsPerRequest": 30,
+      "maxCandidateTests": 400,
+      "maxTokens": 4000,
+      "temperature": 0
     }
   },
   "pipeline": {
@@ -203,7 +250,10 @@ Optional config file `e2e-ai-agents.config.json` (JSON):
     "outputDir": "specs/functional/ai-assisted",
     "heal": true,
     "mcp": false,
-    "mcpAllowFallback": false
+    "mcpAllowFallback": false,
+    "mcpOnly": false,
+    "mcpCommandTimeoutMs": 180000,
+    "mcpRetries": 1
   },
   "llm": { "provider": "anthropic", "fallback": "ollama" },
   "policy": {
@@ -212,7 +262,9 @@ Optional config file `e2e-ai-agents.config.json` (JSON):
     "forceFullOnWarningsAtOrAbove": 2,
     "forceFullOnP0WithGaps": true,
     "forceFullOnRiskyFiles": true,
-    "riskyFilePatterns": ["**/auth/**", "**/permissions/**", "**/security/**", "**/*.sql"]
+    "riskyFilePatterns": ["**/auth/**", "**/permissions/**", "**/security/**", "**/*.sql"],
+    "enforcementMode": "advisory",
+    "blockOnActions": ["must-add-tests"]
   },
   "flags": { "defaultState": "on" },
   "audience": { "defaultRoles": ["member"] },
@@ -233,6 +285,8 @@ Notes:
 - Impact mode expects a git diff; use `--since` or add `"impact": { "allowFallback": true }` to fall back to scanning.
 - Impact analysis now uses static reverse dependency graph expansion (configurable via `impact.dependencyGraph`) to propagate changed-file impact, including alias imports via `aliasRoots` and `pathAliases`.
 - Impact analysis can use coverage-style traceability manifests (`impact.traceability`) for file->test mapping with heuristic fallback for uncovered flows.
+- Impact analysis can run AI-first flow mapping (`impact.aiFlow`) so impacted flows and priorities come from LLM reasoning rather than heuristic scoring.
+- Impact analysis can use optional Anthropic-powered AI mapping (`impact.aiMapping`) to map impacted flows to existing tests when traceability is missing/low; context is loaded from optional markdown files such as `CLAUDE.OPTIONAL.md`.
 - Impact analysis can apply subsystem-aware risk boosts and priority floors from a map (`impact.subsystemRisk`) to capture known high-blast-radius areas.
 - Diffing is computed from `merge-base(<since>, HEAD)` when available, which is the standard PR-impact baseline.
 - Reports are written under `testsRoot/.e2e-ai-agents/reports` (or app root if `testsRoot` is not set).
@@ -240,6 +294,8 @@ Notes:
 - Selector/data-testid patches are only applied when `--apply` is passed.
 - `plan` is a direct alias for `suggest`.
 - `generate` is a direct alias for `approve-and-generate`.
+- Mattermost-first strict mode is available with `--mattermost` (or `"profile": "mattermost"` in config).
+- In Mattermost mode, heuristic-only test mapping is treated as insufficient evidence and recommendations are escalated to broad runs.
 - `heal` targets flaky/failed specs from a Playwright JSON report (`--traceability-report`).
 - `--apply` remains available as a legacy shortcut for direct `gap` execution.
 - Use `--pipeline` to run the Playwright generation pipeline.
@@ -252,17 +308,22 @@ Notes:
 - In MCP mode, fallback is strict by default: if official agent setup fails, generation stops instead of silently degrading.
 - Use `--pipeline-mcp-allow-fallback` (or config `pipeline.mcpAllowFallback=true`) only when you explicitly want fallback generation.
 - MCP prerequisites: Playwright config in `testsRoot` and Claude CLI installed/authenticated.
+- Use `--pipeline-mcp-timeout-ms` (or config `pipeline.mcpCommandTimeoutMs`) to limit per-command MCP wait time and fail fast in strict mode.
+- Use `--pipeline-mcp-retries` (or config `pipeline.mcpRetries`) to retry transient MCP failures while staying in AI-only mode.
 - Official MCP outputs are validated against discovered local API surface (`pw.*`, `pw.testBrowser.*`, `channelsPage.*`) to block invented methods (for example `pw.mainClient.*`).
 - If fallback is enabled and official MCP agent execution is unavailable, pipeline falls back to `e2e-test-gen` (if present) or package-native generation with warnings in report output.
 - `impact/gap` pipeline output now includes `pipeline.mcp` (`requested`, `active`, `backend`) so MCP activation is explicit.
 - `suggest` writes `.e2e-ai-agents/plan.json` with `runSet` (`smoke|targeted|full`) and confidence.
 - `suggest` also writes `.e2e-ai-agents/ci-summary.md` with CI status: `run-now`, `must-add-tests`, or `safe-to-merge`.
-- CLI policy overrides: `--policy-min-confidence`, `--policy-safe-merge-confidence`, `--policy-force-full-on-warnings`, `--policy-risky-patterns`.
+- CLI policy overrides: `--policy-min-confidence`, `--policy-safe-merge-confidence`, `--policy-force-full-on-warnings`, `--policy-risky-patterns`, `--policy-enforcement-mode`, `--policy-block-actions`.
 - GitHub Actions output wiring: `--github-output $GITHUB_OUTPUT`.
 - Optional merge gating: `--fail-on-must-add-tests` exits non-zero when uncovered P0/P1 gaps are detected. Leave this flag unset for advisory-only mode.
+- `suggest` now appends run metrics to `.e2e-ai-agents/metrics.jsonl` and writes aggregated `.e2e-ai-agents/metrics-summary.json`.
 - `impact/gap` now include actionable `testSuggestions` with linked source files and skeleton test code.
 - `impact/gap` now include `impactModel` metadata (`flowMapping`, `testMapping`, `confidenceClass`, traceability stats, dependency graph stats).
+- `impact/gap` now include `runMetadata` (run id/timestamps/duration/since ref) for auditability.
 - `impact/gap` now include optional `impactModel.subsystemRisk` stats (map status, matched files/rules, boosted flows).
+- `impact/gap` pipeline result rows now include failure taxonomy (`failureCategory`, `failureCode`) when generation/heal fails.
 - `feedback` appends outcomes to `.e2e-ai-agents/feedback.json` and recomputes `.e2e-ai-agents/calibration.json`.
 - `feedback` also computes intelligent flaky scores into `.e2e-ai-agents/flaky-tests.json`.
 - `traceability-capture` converts Playwright JSON execution report + optional coverage map into `.e2e-ai-agents/traceability-input.json`.
@@ -360,6 +421,8 @@ CI integration template:
 - Subsystem risk map schema: [schemas/subsystem-risk-map.schema.json](schemas/subsystem-risk-map.schema.json)
 - Subsystem risk map example: [examples/subsystem-risk-map.sample.json](examples/subsystem-risk-map.sample.json)
 - End-to-end verification steps: [examples/verification/README.md](examples/verification/README.md)
+- Impact checklist playbook: [examples/verification/IMPACT_ANALYSIS_CHECKLIST.md](examples/verification/IMPACT_ANALYSIS_CHECKLIST.md)
+- Checklist validator command: `npm run impact:checklist -- --root <tests-root>`
 
 Traceability manifest example (`.e2e-ai-agents/traceability.json`):
 

package/dist/agent/ai_flow_analysis.d.ts

@@ -0,0 +1,12 @@
+import type { FileAnalysis, FlowImpact } from './analysis.js';
+import type { AIFlowImpactConfig } from './config.js';
+export interface AIFlowAnalysisResult {
+    enabled: boolean;
+    used: boolean;
+    provider: string;
+    flowCount: number;
+    warnings: string[];
+    flows: FlowImpact[];
+}
+export declare function mapAIFlowsFromFiles(appRoot: string, testsRoot: string, config: AIFlowImpactConfig, files: FileAnalysis[], changedFiles: string[]): Promise<AIFlowAnalysisResult>;
+//# sourceMappingURL=ai_flow_analysis.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ai_flow_analysis.d.ts","sourceRoot":"","sources":["../../src/agent/ai_flow_analysis.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,YAAY,EAAE,UAAU,EAAe,MAAM,eAAe,CAAC;AAC1E,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,aAAa,CAAC;AAkBpD,MAAM,WAAW,oBAAoB;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,KAAK,EAAE,UAAU,EAAE,CAAC;CACvB;AA2JD,wBAAsB,mBAAmB,CACrC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,kBAAkB,EAC1B,KAAK,EAAE,YAAY,EAAE,EACrB,YAAY,EAAE,MAAM,EAAE,GACvB,OAAO,CAAC,oBAAoB,CAAC,CA+L/B"}

package/dist/agent/ai_flow_analysis.js

@@ -0,0 +1,326 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapAIFlowsFromFiles = mapAIFlowsFromFiles;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const provider_factory_js_1 = require("../provider_factory.js");
+const utils_js_1 = require("./utils.js");
+function extractJson(text) {
+    const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    const candidates = fenced ? [fenced[1], text] : [text];
+    for (const candidate of candidates) {
+        const start = candidate.indexOf('{');
+        const end = candidate.lastIndexOf('}');
+        if (start < 0 || end <= start) {
+            continue;
+        }
+        const raw = candidate.slice(start, end + 1);
+        try {
+            const parsed = JSON.parse(raw);
+            if (parsed && Array.isArray(parsed.flows)) {
+                return parsed;
+            }
+        }
+        catch {
+            // Ignore parse failure and keep trying other candidates.
+        }
+    }
+    return null;
+}
+function resolveContextFiles(appRoot, testsRoot, files) {
+    const resolved = [];
+    const seen = new Set();
+    const maxCharsPerFile = 12000;
+    const maxTotalChars = 32000;
+    let totalChars = 0;
+    for (const file of files) {
+        const candidates = (0, path_1.isAbsolute)(file)
+            ? [file]
+            : [(0, path_1.join)(testsRoot, file), (0, path_1.join)(appRoot, file)];
+        for (const candidate of candidates) {
+            const normalized = (0, utils_js_1.normalizePath)(candidate);
+            if (seen.has(normalized) || !(0, fs_1.existsSync)(candidate)) {
+                continue;
+            }
+            const content = (0, fs_1.readFileSync)(candidate, 'utf-8');
+            const trimmed = content.trim();
+            if (!trimmed) {
+                seen.add(normalized);
+                continue;
+            }
+            const remaining = Math.max(0, maxTotalChars - totalChars);
+            if (remaining <= 0) {
+                return resolved;
+            }
+            const clipped = trimmed.slice(0, Math.min(maxCharsPerFile, remaining));
+            resolved.push({ path: normalized, content: clipped });
+            seen.add(normalized);
+            totalChars += clipped.length;
+            break;
+        }
+    }
+    return resolved;
+}
+function priorityFromEntry(entry) {
+    if (entry.priority === 'P0' || entry.priority === 'P1' || entry.priority === 'P2') {
+        return entry.priority;
+    }
+    const score = typeof entry.score === 'number' ? entry.score : 0;
+    if (score >= 8) {
+        return 'P0';
+    }
+    if (score >= 5) {
+        return 'P1';
+    }
+    return 'P2';
+}
+function normalizeFlowId(value) {
+    return (0, utils_js_1.normalizePath)(value)
+        .replace(/[^a-zA-Z0-9/_-]+/g, '_')
+        .replace(/\/{2,}/g, '/')
+        .replace(/^\/+/, '')
+        .replace(/\/+$/, '')
+        .trim();
+}
+function sanitizeReasons(reasons, fallback) {
+    if (!Array.isArray(reasons)) {
+        return [fallback];
+    }
+    const cleaned = reasons.filter((entry) => typeof entry === 'string').map((entry) => entry.trim()).filter(Boolean);
+    return cleaned.length > 0 ? cleaned : [fallback];
+}
+function sanitizeKeywords(keywords, fallbackTokens) {
+    if (!Array.isArray(keywords)) {
+        return (0, utils_js_1.uniqueTokens)(fallbackTokens).slice(0, 20);
+    }
+    const fromAI = keywords.filter((entry) => typeof entry === 'string').flatMap((entry) => (0, utils_js_1.tokenize)(entry));
+    return (0, utils_js_1.uniqueTokens)([...fromAI, ...fallbackTokens]).slice(0, 20);
+}
+function summarizeFiles(files, changedFileSet, maxFiles) {
+    const sorted = [...files].sort((a, b) => {
+        const aChanged = changedFileSet.has(a.relativePath) ? 1 : 0;
+        const bChanged = changedFileSet.has(b.relativePath) ? 1 : 0;
+        if (aChanged !== bChanged) {
+            return bChanged - aChanged;
+        }
+        const aSignals = (a.isUI ? 1 : 0) + (a.isScreen ? 1 : 0) + (a.isState ? 1 : 0) + (a.hasInteractions ? 1 : 0);
+        const bSignals = (b.isUI ? 1 : 0) + (b.isScreen ? 1 : 0) + (b.isState ? 1 : 0) + (b.hasInteractions ? 1 : 0);
+        if (aSignals !== bSignals) {
+            return bSignals - aSignals;
+        }
+        return a.relativePath.localeCompare(b.relativePath);
+    }).slice(0, Math.max(20, maxFiles));
+    return sorted.map((file) => ({
+        path: file.relativePath,
+        changed: changedFileSet.has(file.relativePath),
+        isUI: file.isUI,
+        isScreen: file.isScreen,
+        isComponent: file.isComponent,
+        isState: file.isState,
+        isStyle: file.isStyle,
+        hasInteractions: file.hasInteractions,
+        keywords: file.keywords.slice(0, 20),
+        audience: file.audience,
+        flags: file.flags?.map((flag) => ({ name: flag.name, source: flag.source, defaultState: flag.defaultState })),
+    }));
+}
+function mergeFlow(existing, candidate) {
+    if (!existing) {
+        return candidate;
+    }
+    const priorityOrder = { P0: 0, P1: 1, P2: 2 };
+    const priority = priorityOrder[candidate.priority] < priorityOrder[existing.priority]
+        ? candidate.priority
+        : existing.priority;
+    return {
+        ...existing,
+        name: existing.name || candidate.name,
+        kind: existing.kind || candidate.kind,
+        score: Math.max(existing.score, candidate.score),
+        priority,
+        reasons: (0, utils_js_1.uniqueTokens)([...(existing.reasons || []), ...(candidate.reasons || [])]),
+        keywords: (0, utils_js_1.uniqueTokens)([...(existing.keywords || []), ...(candidate.keywords || [])]),
+        files: (0, utils_js_1.uniqueTokens)([...(existing.files || []), ...(candidate.files || [])]),
+        audience: (0, utils_js_1.uniqueTokens)([...(existing.audience || []), ...(candidate.audience || [])]),
+        flags: [...(existing.flags || []), ...(candidate.flags || [])],
+    };
+}
+async function mapAIFlowsFromFiles(appRoot, testsRoot, config, files, changedFiles) {
+    const providerName = config.provider === 'auto' ? 'auto' : config.provider;
+    const warnings = [];
+    if (!config.enabled) {
+        return {
+            enabled: false,
+            used: false,
+            provider: providerName,
+            flowCount: 0,
+            warnings,
+            flows: [],
+        };
+    }
+    if (files.length === 0) {
+        warnings.push('AI flow analysis skipped: no analyzable files were found.');
+        return {
+            enabled: true,
+            used: false,
+            provider: providerName,
+            flowCount: 0,
+            warnings,
+            flows: [],
+        };
+    }
+    const changedFileSet = new Set(changedFiles.map((entry) => (0, utils_js_1.normalizePath)(entry)));
+    const summarizedFiles = summarizeFiles(files, changedFileSet, config.maxFilesPerRequest);
+    const allowedFiles = new Set(files.map((entry) => entry.relativePath));
+    const fileByPath = new Map(files.map((entry) => [entry.relativePath, entry]));
+    const contextFiles = resolveContextFiles(appRoot, testsRoot, config.contextFiles || []);
+    const contextBlock = contextFiles.length > 0
+        ? contextFiles.map((entry) => `### Context: ${entry.path}\n${entry.content}`).join('\n\n')
+        : 'No optional markdown context files were found.';
+    if (contextFiles.length === 0) {
+        warnings.push('AI flow analysis context files were not found; continuing without optional markdown context.');
+    }
+    let provider;
+    try {
+        provider = config.provider === 'auto'
+            ? await provider_factory_js_1.LLMProviderFactory.createFromEnv()
+            : provider_factory_js_1.LLMProviderFactory.createFromString(config.provider);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        warnings.push(`AI flow analysis unavailable (${providerName}): ${message}`);
+        return {
+            enabled: true,
+            used: false,
+            provider: providerName,
+            flowCount: 0,
+            warnings,
+            flows: [],
+        };
+    }
+    const prompt = [
+        'You are an expert frontend impact analyst for Mattermost.',
+        'Build impacted user flows from changed frontend files.',
+        'This must be flow-centric, not file-centric.',
+        '',
+        'Return strict JSON only with this exact shape:',
+        '{"flows":[{"id":"<flow_id>","name":"<name>","kind":"flow|screen","priority":"P0|P1|P2","score":10,"reasons":["..."],"keywords":["..."],"files":["relative/path.tsx"]}]}',
+        '',
+        'Rules:',
+        '- Use only file paths listed in FILES.',
+        '- Every flow must have at least one file.',
+        '- Keep IDs stable and lowercase with underscores when possible.',
+        '- Prioritize true user-impacting flows; avoid low-value internal buckets.',
+        '- Keep at most 6 file paths per flow.',
+        `- Keep at most ${Math.max(1, config.maxFlowsPerRequest)} flows.`,
+        '',
+        `CHANGED_FILES (${changedFileSet.size}):`,
+        JSON.stringify(Array.from(changedFileSet), null, 2),
+        '',
+        `FILES (${summarizedFiles.length}):`,
+        JSON.stringify(summarizedFiles, null, 2),
+        '',
+        contextBlock,
+    ].join('\n');
+    let parsed = null;
+    try {
+        const response = await provider.generateText(prompt, {
+            maxTokens: Math.max(800, config.maxTokens),
+            temperature: Math.max(0, Math.min(1, config.temperature)),
+            systemPrompt: 'Return only valid JSON. Do not include markdown fences unless necessary.',
+        });
+        parsed = extractJson(response.text);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        warnings.push(`AI flow analysis request failed (${provider.name}): ${message}`);
+        return {
+            enabled: true,
+            used: false,
+            provider: provider.name,
+            flowCount: 0,
+            warnings,
+            flows: [],
+        };
+    }
+    if (!parsed) {
+        warnings.push(`AI flow analysis returned invalid JSON (${provider.name}).`);
+        return {
+            enabled: true,
+            used: false,
+            provider: provider.name,
+            flowCount: 0,
+            warnings,
+            flows: [],
+        };
+    }
+    const flowsById = new Map();
+    for (const entry of parsed.flows) {
+        if (!entry || !Array.isArray(entry.files)) {
+            continue;
+        }
+        const validFiles = Array.from(new Set(entry.files
+            .filter((value) => typeof value === 'string')
+            .map((value) => (0, utils_js_1.normalizePath)(value))
+            .filter((value) => allowedFiles.has(value)))).slice(0, 6);
+        if (validFiles.length === 0) {
+            continue;
+        }
+        const rawId = typeof entry.id === 'string' && entry.id.trim()
+            ? entry.id
+            : (typeof entry.name === 'string' && entry.name.trim() ? entry.name : validFiles[0]);
+        const id = normalizeFlowId(rawId);
+        if (!id) {
+            continue;
+        }
+        const fallbackTokens = (0, utils_js_1.uniqueTokens)([
+            ...(0, utils_js_1.tokenize)(id),
+            ...(typeof entry.name === 'string' ? (0, utils_js_1.tokenize)(entry.name) : []),
+            ...validFiles.flatMap((value) => (0, utils_js_1.tokenize)(value)),
+        ]);
+        const linkedFiles = validFiles.map((path) => fileByPath.get(path)).filter(Boolean);
+        const audience = (0, utils_js_1.uniqueTokens)(linkedFiles.flatMap((file) => file.audience || []));
+        const flags = linkedFiles.flatMap((file) => file.flags || []);
+        const score = typeof entry.score === 'number' && Number.isFinite(entry.score)
+            ? Math.max(1, Math.min(20, Math.round(entry.score)))
+            : Math.max(4, validFiles.length * 2);
+        const flow = {
+            id,
+            name: typeof entry.name === 'string' && entry.name.trim() ? entry.name.trim() : id.replace(/[_/.-]+/g, ' '),
+            kind: entry.kind === 'screen' ? 'screen' : 'flow',
+            score,
+            priority: priorityFromEntry(entry),
+            reasons: sanitizeReasons(entry.reasons, 'AI flow analysis identified impacted behavior'),
+            keywords: sanitizeKeywords(entry.keywords, fallbackTokens),
+            files: validFiles,
+            audience,
+            flags,
+        };
+        flowsById.set(id, mergeFlow(flowsById.get(id), flow));
+        if (flowsById.size >= Math.max(1, config.maxFlowsPerRequest)) {
+            break;
+        }
+    }
+    const flows = Array.from(flowsById.values());
+    if (flows.length === 0) {
+        warnings.push('AI flow analysis did not return any valid flows linked to changed files.');
+        return {
+            enabled: true,
+            used: false,
+            provider: provider.name,
+            flowCount: 0,
+            warnings,
+            flows: [],
+        };
+    }
+    return {
+        enabled: true,
+        used: true,
+        provider: provider.name,
+        flowCount: flows.length,
+        warnings,
+        flows,
+    };
+}

package/dist/agent/ai_mapping.d.ts

@@ -0,0 +1,14 @@
+import type { FlowImpact } from './analysis.js';
+import type { AIMappingImpactConfig } from './config.js';
+import type { FlowCoverage, TestFile } from './tests.js';
+export interface AIMappingResult {
+    enabled: boolean;
+    used: boolean;
+    provider: string;
+    mappedFlows: number;
+    matchedTests: number;
+    coverage: FlowCoverage[];
+    warnings: string[];
+}
+export declare function mapAITestsToFlows(appRoot: string, testsRoot: string, config: AIMappingImpactConfig, flows: FlowImpact[], tests: TestFile[]): Promise<AIMappingResult>;
+//# sourceMappingURL=ai_mapping.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ai_mapping.d.ts","sourceRoot":"","sources":["../../src/agent/ai_mapping.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAC,qBAAqB,EAAC,MAAM,aAAa,CAAC;AACvD,OAAO,KAAK,EAAC,YAAY,EAAE,QAAQ,EAAC,MAAM,YAAY,CAAC;AA2BvD,MAAM,WAAW,eAAe;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACtB;AAoND,wBAAsB,iBAAiB,CACnC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,qBAAqB,EAC7B,KAAK,EAAE,UAAU,EAAE,EACnB,KAAK,EAAE,QAAQ,EAAE,GAClB,OAAO,CAAC,eAAe,CAAC,CA8L1B"}