@yasserkhanorg/e2e-agents 0.5.16 → 0.7.0

package/dist/engine/ai_enrichment.js

@@ -0,0 +1,235 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enrichImpactWithAI = enrichImpactWithAI;
+const diff_loader_js_1 = require("./diff_loader.js");
+const MAX_SPEC_LIST = 50;
+function normalizePriority(value) {
+    if (value === 'P0' || value === 'P1' || value === 'P2') {
+        return value;
+    }
+    return 'P2';
+}
+function buildPrompt(options) {
+    const { deterministicImpact, diffs, specList, manifestSummary } = options;
+    const { changedFiles, impactedFeatures, unboundFiles } = deterministicImpact;
+    const lines = [];
+    // Optional manifest summary
+    if (manifestSummary) {
+        lines.push('## Application Overview');
+        lines.push(manifestSummary);
+        lines.push('');
+    }
+    // Changed files section
+    lines.push(`## Changed Files (${changedFiles.length} total)`);
+    for (const f of changedFiles) {
+        lines.push(`- ${f}`);
+    }
+    lines.push('');
+    // Diffs section
+    lines.push('## Code Diffs');
+    lines.push((0, diff_loader_js_1.formatDiffsForPrompt)(diffs));
+    lines.push('');
+    // Deterministic features summary
+    lines.push('## Deterministic Impact Analysis');
+    lines.push('The following features/flows have been deterministically identified as impacted:');
+    lines.push('');
+    for (const feature of impactedFeatures) {
+        const featureIdPart = feature.featureId ? `featureId=${feature.featureId}` : 'featureId=undefined';
+        const specCount = feature.playwrightSpecs.length + feature.cypressSpecs.length;
+        const specList2 = [...feature.playwrightSpecs, ...feature.cypressSpecs];
+        const specsDisplay = specList2.length > 0 ? specList2.join(', ') : 'none';
+        lines.push(`- familyId=${feature.familyId} ${featureIdPart} (${feature.priority}): ${specCount} files, coverage=${feature.coverageStatus}, specs=[${specsDisplay}]`);
+    }
+    lines.push('');
+    // Unbound files
+    if (unboundFiles.length > 0) {
+        lines.push('## Unbound Files (not mapped to any feature)');
+        for (const f of unboundFiles) {
+            lines.push(`- ${f}`);
+        }
+        lines.push('');
+    }
+    // Spec list (capped at 50)
+    if (specList.length > 0) {
+        const cappedSpecs = specList.slice(0, MAX_SPEC_LIST);
+        lines.push(`## Available Test Specs (showing ${cappedSpecs.length} of ${specList.length})`);
+        for (const s of cappedSpecs) {
+            lines.push(`- ${s}`);
+        }
+        lines.push('');
+    }
+    // Instructions
+    lines.push('## Instructions');
+    lines.push('Return ONLY valid JSON (no markdown fences, no explanation) in this exact shape:');
+    lines.push('');
+    lines.push(JSON.stringify({
+        impactedFlows: [
+            {
+                id: '<featureId or familyId from the deterministic list above>',
+                name: '<human-readable flow name>',
+                priority: 'P0|P1|P2',
+                reasons: ['<specific reason why this flow is impacted by the changes>'],
+                coveredBy: ['<spec file paths that cover this flow>'],
+                missingScenarios: ['<specific test scenarios that are missing or should be added>'],
+            },
+        ],
+        unboundFileAnalysis: [
+            {
+                file: '<path to unbound file>',
+                likelyFeature: '<best guess at which feature/family this affects>',
+                reason: '<why you think this file belongs to that feature>',
+            },
+        ],
+    }, null, 2));
+    return lines.join('\n');
+}
+function extractJSON(text) {
+    // Try markdown fenced block first
+    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) {
+            return candidate.slice(start, end + 1).trim();
+        }
+    }
+    // Fallback: return trimmed text
+    return text.trim();
+}
+function toEnrichedFeature(det, aiFlow) {
+    return {
+        familyId: det.familyId,
+        featureId: det.featureId,
+        priority: normalizePriority(det.priority),
+        changedFiles: det.changedFiles,
+        coverageStatus: det.coverageStatus,
+        playwrightSpecs: det.playwrightSpecs,
+        cypressSpecs: det.cypressSpecs,
+        userFlows: det.userFlows,
+        aiReasons: aiFlow?.reasons ?? [],
+        aiMissingScenarios: aiFlow?.missingScenarios ?? [],
+        aiCoveredBy: aiFlow?.coveredBy ?? [],
+    };
+}
+/**
+ * Enriches a deterministic impact result with AI-generated reasons,
+ * missing test scenarios, and coverage insights.
+ */
+async function enrichImpactWithAI(options) {
+    const { deterministicImpact, provider } = options;
+    const warnings = [];
+    let tokenUsage = { input: 0, output: 0 };
+    const prompt = buildPrompt(options);
+    let aiResponse = null;
+    let unboundFileInsights = [];
+    try {
+        const response = await provider.generateText(prompt, {
+            maxTokens: 4000,
+            temperature: 0,
+            timeout: 45000,
+            systemPrompt: 'You are an expert E2E test analyst. Return only valid JSON.',
+        });
+        tokenUsage = {
+            input: response.usage?.inputTokens ?? 0,
+            output: response.usage?.outputTokens ?? 0,
+        };
+        const rawJSON = extractJSON(response.text);
+        try {
+            const parsed = JSON.parse(rawJSON);
+            // Validate that impactedFlows is an array
+            if (!Array.isArray(parsed.impactedFlows)) {
+                warnings.push('AI response parsed but impactedFlows is not an array; returning empty enrichedFeatures');
+                return {
+                    enrichedFeatures: [],
+                    unboundFileInsights: [],
+                    warnings,
+                    providerName: provider.name,
+                    tokenUsage,
+                };
+            }
+            aiResponse = parsed;
+            unboundFileInsights = (parsed.unboundFileAnalysis ?? []).map((item) => ({
+                file: item.file,
+                likelyFeature: item.likelyFeature,
+                reason: item.reason,
+            }));
+        }
+        catch (parseErr) {
+            warnings.push(`Failed to parse AI response as JSON: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`);
+            return {
+                enrichedFeatures: [],
+                unboundFileInsights: [],
+                warnings,
+                providerName: provider.name,
+                tokenUsage,
+            };
+        }
+    }
+    catch (err) {
+        warnings.push(`AI provider error: ${err instanceof Error ? err.message : String(err)}`);
+        return {
+            enrichedFeatures: [],
+            unboundFileInsights: [],
+            warnings,
+            providerName: provider.name,
+            tokenUsage,
+        };
+    }
+    // Build a map of AI flows by id (featureId or familyId)
+    const aiFlowMap = new Map();
+    if (aiResponse?.impactedFlows) {
+        for (const flow of aiResponse.impactedFlows) {
+            aiFlowMap.set(flow.id, flow);
+        }
+    }
+    // Build a set of all deterministic ids for unmatched-flow detection
+    const deterministicIds = new Set();
+    for (const det of deterministicImpact.impactedFeatures) {
+        if (det.featureId) {
+            deterministicIds.add(det.featureId);
+        }
+        deterministicIds.add(det.familyId);
+    }
+    // Warn on AI flows that don't match any deterministic feature
+    for (const flow of aiFlowMap.values()) {
+        if (!deterministicIds.has(flow.id)) {
+            warnings.push(`AI returned flow '${flow.id}' with no matching deterministic feature (using as-is)`);
+        }
+    }
+    // Merge deterministic features with AI data
+    const enrichedFeatures = deterministicImpact.impactedFeatures.map((det) => {
+        // Match by featureId first, then by familyId
+        const aiFlow = det.featureId
+            ? (aiFlowMap.get(det.featureId) ?? aiFlowMap.get(det.familyId))
+            : aiFlowMap.get(det.familyId);
+        return toEnrichedFeature(det, aiFlow);
+    });
+    // Include AI flows that had no deterministic match (as-is, with empty deterministic fields)
+    for (const flow of aiFlowMap.values()) {
+        if (!deterministicIds.has(flow.id)) {
+            enrichedFeatures.push({
+                familyId: flow.id,
+                featureId: undefined,
+                priority: normalizePriority(flow.priority),
+                changedFiles: [],
+                coverageStatus: 'uncovered',
+                playwrightSpecs: [],
+                cypressSpecs: [],
+                userFlows: [],
+                aiReasons: flow.reasons ?? [],
+                aiMissingScenarios: flow.missingScenarios ?? [],
+                aiCoveredBy: flow.coveredBy ?? [],
+            });
+        }
+    }
+    return {
+        enrichedFeatures,
+        unboundFileInsights,
+        warnings,
+        providerName: provider.name,
+        tokenUsage,
+    };
+}

package/dist/engine/diff_loader.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Loads git diffs for the given changed files relative to the given since ref.
+ * Uses `git merge-base` to find the accurate base ref first.
+ * Individual diffs are truncated at 8000 chars and total output is capped at 60000 chars.
+ */
+export declare function loadDiffs(appRoot: string, since: string, changedFiles: string[]): Map<string, string>;
+/**
+ * Formats a diffs map into a human-readable string suitable for an AI prompt.
+ */
+export declare function formatDiffsForPrompt(diffs: Map<string, string>): string;
+//# sourceMappingURL=diff_loader.d.ts.map

package/dist/engine/diff_loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff_loader.d.ts","sourceRoot":"","sources":["../../src/engine/diff_loader.ts"],"names":[],"mappings":"AAqBA;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CA0CrG;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAUvE"}

package/dist/engine/diff_loader.js

@@ -0,0 +1,74 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadDiffs = loadDiffs;
+exports.formatDiffsForPrompt = formatDiffsForPrompt;
+const child_process_1 = require("child_process");
+const MAX_DIFF_CHARS = 8000;
+const MAX_TOTAL_CHARS = 60000;
+const TRUNCATION_NOTICE = '\n... (diff truncated)';
+function runGitRaw(args, cwd) {
+    const result = (0, child_process_1.spawnSync)('git', args, {
+        cwd,
+        encoding: 'utf-8',
+        timeout: 30000,
+    });
+    if (result.error || result.status !== 0) {
+        return null;
+    }
+    return result.stdout;
+}
+/**
+ * Loads git diffs for the given changed files relative to the given since ref.
+ * Uses `git merge-base` to find the accurate base ref first.
+ * Individual diffs are truncated at 8000 chars and total output is capped at 60000 chars.
+ */
+function loadDiffs(appRoot, since, changedFiles) {
+    const result = new Map();
+    if (changedFiles.length === 0) {
+        return result;
+    }
+    // Try to get accurate merge base
+    let baseRef = since;
+    const mergeBaseOutput = runGitRaw(['merge-base', since, 'HEAD'], appRoot);
+    if (mergeBaseOutput) {
+        const candidate = mergeBaseOutput
+            .split('\n')
+            .map((line) => line.trim())
+            .find(Boolean);
+        if (candidate) {
+            baseRef = candidate;
+        }
+    }
+    let totalChars = 0;
+    for (const file of changedFiles) {
+        if (totalChars >= MAX_TOTAL_CHARS) {
+            break;
+        }
+        const diffOutput = runGitRaw(['diff', `${baseRef}..HEAD`, '--', file], appRoot);
+        if (diffOutput === null) {
+            continue;
+        }
+        let diff = diffOutput;
+        if (diff.length > MAX_DIFF_CHARS) {
+            diff = diff.slice(0, MAX_DIFF_CHARS) + TRUNCATION_NOTICE;
+        }
+        result.set(file, diff);
+        totalChars += diff.length;
+    }
+    return result;
+}
+/**
+ * Formats a diffs map into a human-readable string suitable for an AI prompt.
+ */
+function formatDiffsForPrompt(diffs) {
+    if (diffs.size === 0) {
+        return 'No diffs available.';
+    }
+    const sections = [];
+    for (const [file, diff] of diffs) {
+        sections.push(`--- ${file} ---\n${diff}`);
+    }
+    return sections.join('\n\n');
+}

package/dist/engine/impact_engine.d.ts

@@ -0,0 +1,36 @@
+import type { FeaturePriority } from '../knowledge/route_families.js';
+import type { RouteFamiliesConfig } from '../agent/config.js';
+export type CoverageStatus = 'covered' | 'partial' | 'uncovered';
+export interface ImpactedFeature {
+    familyId: string;
+    featureId?: string;
+    priority: FeaturePriority;
+    changedFiles: string[];
+    playwrightSpecs: string[];
+    cypressSpecs: string[];
+    userFlows: string[];
+    coverageStatus: CoverageStatus;
+}
+export interface ImpactResult {
+    changedFiles: string[];
+    expandedFiles: string[];
+    impactedFeatures: ImpactedFeature[];
+    unboundFiles: string[];
+    warnings: string[];
+}
+export interface ImpactEngineOptions {
+    testsRoot: string;
+    cypressRoot?: string;
+    routeFamilies?: RouteFamiliesConfig;
+    expandedFiles?: string[];
+}
+export declare function analyzeImpact(changedFiles: string[], options: ImpactEngineOptions): ImpactResult;
+/**
+ * Get gaps: P0/P1 features with 'uncovered' status.
+ */
+export declare function getGaps(result: ImpactResult): ImpactedFeature[];
+/**
+ * Get partial gaps: P0/P1 features with 'partial' status (advisory).
+ */
+export declare function getPartialGaps(result: ImpactResult): ImpactedFeature[];
+//# sourceMappingURL=impact_engine.d.ts.map

package/dist/engine/impact_engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"impact_engine.d.ts","sourceRoot":"","sources":["../../src/engine/impact_engine.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAGR,eAAe,EAClB,MAAM,gCAAgC,CAAC;AASxC,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,oBAAoB,CAAC;AAE5D,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,CAAC;AAEjE,MAAM,WAAW,eAAe;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,eAAe,CAAC;IAC1B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,cAAc,EAAE,cAAc,CAAC;CAClC;AAED,MAAM,WAAW,YAAY;IACzB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,gBAAgB,EAAE,eAAe,EAAE,CAAC;IACpC,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,mBAAmB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,mBAAmB,CAAC;IACpC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B;AAuGD,wBAAgB,aAAa,CACzB,YAAY,EAAE,MAAM,EAAE,EACtB,OAAO,EAAE,mBAAmB,GAC7B,YAAY,CA2Ed;AAYD;;GAEG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,YAAY,GAAG,eAAe,EAAE,CAI/D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY,GAAG,eAAe,EAAE,CAItE"}

package/dist/engine/impact_engine.js

@@ -0,0 +1,196 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeImpact = analyzeImpact;
+exports.getGaps = getGaps;
+exports.getPartialGaps = getPartialGaps;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const route_families_js_1 = require("../knowledge/route_families.js");
+function scanDirForSpecs(baseDir, specDir, extension) {
+    const fullDir = (0, path_1.join)(baseDir, specDir);
+    if (!(0, fs_1.existsSync)(fullDir)) {
+        return [];
+    }
+    const specs = [];
+    try {
+        const items = (0, fs_1.readdirSync)(fullDir, { withFileTypes: true });
+        for (const item of items) {
+            const itemPath = (0, path_1.join)(fullDir, item.name);
+            if (item.isDirectory()) {
+                specs.push(...scanDirForSpecsRecursive(itemPath, extension));
+            }
+            else if (item.name.endsWith(extension)) {
+                specs.push((0, path_1.join)(specDir, item.name));
+            }
+        }
+    }
+    catch {
+        // Directory not readable
+    }
+    return specs;
+}
+function scanDirForSpecsRecursive(dir, extension) {
+    const specs = [];
+    try {
+        const items = (0, fs_1.readdirSync)(dir, { withFileTypes: true });
+        for (const item of items) {
+            const fullPath = (0, path_1.join)(dir, item.name);
+            if (item.isDirectory()) {
+                specs.push(...scanDirForSpecsRecursive(fullPath, extension));
+            }
+            else if (item.name.endsWith(extension)) {
+                specs.push(fullPath);
+            }
+        }
+    }
+    catch {
+        // Directory not readable
+    }
+    return specs;
+}
+function resolvePlaywrightSpecs(testsRoot, specDirs) {
+    const specs = [];
+    for (const dir of specDirs) {
+        specs.push(...scanDirForSpecs(testsRoot, dir, '.spec.ts'));
+    }
+    return specs;
+}
+function resolveCypressSpecs(cypressRoot, specDirs) {
+    const specs = [];
+    for (const dir of specDirs) {
+        // cypressSpecDirs are relative to testsRoot (e.g. ../cypress/tests/integration/channels/search/)
+        // Resolve them relative to the cypress root
+        const resolvedDir = (0, path_1.join)(cypressRoot, dir.replace(/^\.\.\/cypress\//, ''));
+        if (!(0, fs_1.existsSync)(resolvedDir)) {
+            continue;
+        }
+        const found = scanDirForSpecsRecursive(resolvedDir, '.js');
+        const tsFound = scanDirForSpecsRecursive(resolvedDir, '.ts');
+        specs.push(...found, ...tsFound);
+    }
+    return specs;
+}
+function computeCoverageStatus(pwSpecs, cySpecs) {
+    const hasPw = pwSpecs.length > 0;
+    const hasCy = cySpecs.length > 0;
+    if (hasPw && hasCy) {
+        return 'covered';
+    }
+    if (hasPw || hasCy) {
+        return 'partial';
+    }
+    return 'uncovered';
+}
+/**
+ * Group file bindings into a deduplicated map of family/feature → changed files.
+ */
+function groupBindings(fileBindings) {
+    const groups = new Map();
+    for (const fb of fileBindings) {
+        for (const binding of fb.bindings) {
+            const key = binding.feature || binding.family;
+            const existing = groups.get(key);
+            if (existing) {
+                if (!existing.files.includes(fb.file)) {
+                    existing.files.push(fb.file);
+                }
+            }
+            else {
+                groups.set(key, {
+                    familyId: binding.family,
+                    featureId: binding.feature,
+                    files: [fb.file],
+                });
+            }
+        }
+    }
+    return groups;
+}
+function analyzeImpact(changedFiles, options) {
+    const { testsRoot, routeFamilies } = options;
+    const warnings = [];
+    // Load manifest
+    const manifest = (0, route_families_js_1.loadRouteFamilyManifest)(testsRoot, routeFamilies);
+    if (!manifest) {
+        return {
+            changedFiles,
+            expandedFiles: options.expandedFiles || [],
+            impactedFeatures: [],
+            unboundFiles: [...changedFiles],
+            warnings: ['Route family manifest not found. All files are unbound.'],
+        };
+    }
+    // Combine original + expanded files
+    const allFiles = [...new Set([...changedFiles, ...(options.expandedFiles || [])])];
+    // Bind files to families
+    const fileBindings = (0, route_families_js_1.bindFilesToFamilies)(allFiles, manifest);
+    // Find unbound files
+    const unboundFiles = fileBindings
+        .filter((fb) => fb.bindings.length === 0)
+        .map((fb) => fb.file);
+    // Group bindings into features
+    const groups = groupBindings(fileBindings.filter((fb) => fb.bindings.length > 0));
+    // Determine cypress root
+    const cypressRoot = options.cypressRoot || inferCypressRoot(testsRoot);
+    // Resolve specs and compute coverage for each feature
+    const impactedFeatures = [];
+    for (const group of groups.values()) {
+        const binding = { family: group.familyId, feature: group.featureId };
+        const specDirs = (0, route_families_js_1.getSpecDirsForBinding)(manifest, binding);
+        const cypressSpecDirs = (0, route_families_js_1.getCypressSpecDirsForBinding)(manifest, binding);
+        const priority = (0, route_families_js_1.getPriorityForBinding)(manifest, binding);
+        const userFlows = (0, route_families_js_1.getUserFlowsForBinding)(manifest, binding);
+        const playwrightSpecs = resolvePlaywrightSpecs(testsRoot, specDirs);
+        const cypressSpecs = cypressRoot ? resolveCypressSpecs(cypressRoot, cypressSpecDirs) : [];
+        const coverageStatus = computeCoverageStatus(playwrightSpecs, cypressSpecs);
+        impactedFeatures.push({
+            familyId: group.familyId,
+            featureId: group.featureId,
+            priority,
+            changedFiles: group.files,
+            playwrightSpecs,
+            cypressSpecs,
+            userFlows,
+            coverageStatus,
+        });
+    }
+    // Sort by priority (P0 first, then P1, then P2)
+    const priorityOrder = { P0: 0, P1: 1, P2: 2 };
+    impactedFeatures.sort((a, b) => priorityOrder[a.priority] - priorityOrder[b.priority]);
+    if (unboundFiles.length > 0 && unboundFiles.length <= 5) {
+        warnings.push(`${unboundFiles.length} file(s) not mapped to any route family: ${unboundFiles.join(', ')}`);
+    }
+    else if (unboundFiles.length > 5) {
+        warnings.push(`${unboundFiles.length} file(s) not mapped to any route family`);
+    }
+    return {
+        changedFiles,
+        expandedFiles: options.expandedFiles || [],
+        impactedFeatures,
+        unboundFiles,
+        warnings,
+    };
+}
+function inferCypressRoot(testsRoot) {
+    // testsRoot is typically the Playwright tests directory
+    // Cypress tests are at a sibling path: e2e-tests/cypress/tests/integration/channels/
+    const candidate = (0, path_1.join)(testsRoot, '..', 'cypress');
+    if ((0, fs_1.existsSync)(candidate)) {
+        return candidate;
+    }
+    return undefined;
+}
+/**
+ * Get gaps: P0/P1 features with 'uncovered' status.
+ */
+function getGaps(result) {
+    return result.impactedFeatures.filter((f) => (f.priority === 'P0' || f.priority === 'P1') && f.coverageStatus === 'uncovered');
+}
+/**
+ * Get partial gaps: P0/P1 features with 'partial' status (advisory).
+ */
+function getPartialGaps(result) {
+    return result.impactedFeatures.filter((f) => (f.priority === 'P0' || f.priority === 'P1') && f.coverageStatus === 'partial');
+}

package/dist/engine/plan_builder.d.ts

@@ -0,0 +1,10 @@
+import type { PolicyConfig } from '../agent/config.js';
+import type { ImpactResult } from './impact_engine.js';
+import type { AIEnrichmentResult } from './ai_enrichment.js';
+import type { PlanReport, GapDetail, CoveredFlowSummary } from '../agent/plan.js';
+export type { PlanReport, GapDetail, CoveredFlowSummary };
+export declare function buildPlanFromImpact(impact: ImpactResult, policyOverride?: Partial<PolicyConfig>, aiEnrichment?: AIEnrichmentResult): PlanReport;
+export declare function writePlanReport(appRoot: string, plan: PlanReport): string;
+export declare function renderCiSummaryMarkdown(plan: PlanReport): string;
+export declare function writeCiSummary(appRoot: string, markdown: string, relativePath?: string): string;
+//# sourceMappingURL=plan_builder.d.ts.map

package/dist/engine/plan_builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan_builder.d.ts","sourceRoot":"","sources":["../../src/engine/plan_builder.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAC,YAAY,EAAkB,MAAM,oBAAoB,CAAC;AAEtE,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AAG3D,OAAO,KAAK,EACR,UAAU,EACV,SAAS,EACT,kBAAkB,EAIrB,MAAM,kBAAkB,CAAC;AAE1B,YAAY,EAAC,UAAU,EAAE,SAAS,EAAE,kBAAkB,EAAC,CAAC;AAqOxD,wBAAgB,mBAAmB,CAC/B,MAAM,EAAE,YAAY,EACpB,cAAc,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,EACtC,YAAY,CAAC,EAAE,kBAAkB,GAClC,UAAU,CA8HZ;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CAMzE;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAoDhE;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,YAAY,SAAiC,GAAG,MAAM,CAMvH"}