@yasserkhanorg/e2e-agents 0.3.8 → 0.4.0

package/dist/knowledge/route_families.d.ts

@@ -0,0 +1,48 @@
+export interface RouteFeature {
+    id: string;
+    routes?: string[];
+    webappPaths?: string[];
+    serverPaths?: string[];
+    specDirs?: string[];
+    tags?: string[];
+}
+export interface RouteFamily {
+    id: string;
+    routes: string[];
+    pageObjects?: string[];
+    components?: string[];
+    webappPaths?: string[];
+    serverPaths?: string[];
+    specDirs?: string[];
+    tags?: string[];
+    features?: RouteFeature[];
+}
+export interface RouteFamilyManifest {
+    families: RouteFamily[];
+    source: string;
+}
+export interface FileBinding {
+    file: string;
+    bindings: Array<{
+        family: string;
+        feature?: string;
+    }>;
+}
+export interface RouteFamilyConfig {
+    manifestPath?: string;
+    strict?: boolean;
+}
+export declare function loadRouteFamilyManifest(testsRoot: string, config?: RouteFamilyConfig): RouteFamilyManifest | null;
+export declare function bindFilesToFamilies(changedFiles: string[], manifest: RouteFamilyManifest): FileBinding[];
+export declare function getFamilyById(manifest: RouteFamilyManifest, familyId: string): RouteFamily | undefined;
+export declare function getFeatureById(family: RouteFamily, featureId: string): RouteFeature | undefined;
+export declare function getSpecDirsForBinding(manifest: RouteFamilyManifest, binding: {
+    family: string;
+    feature?: string;
+}): string[];
+export declare function getRoutesForBinding(manifest: RouteFamilyManifest, binding: {
+    family: string;
+    feature?: string;
+}): string[];
+export declare function clearManifestCache(): void;
+//# sourceMappingURL=route_families.d.ts.map

package/dist/knowledge/route_families.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route_families.d.ts","sourceRoot":"","sources":["../../src/knowledge/route_families.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,YAAY;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,CAAC,EAAE,YAAY,EAAE,CAAC;CAC7B;AAED,MAAM,WAAW,mBAAmB;IAChC,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,KAAK,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;CACvD;AAED,MAAM,WAAW,iBAAiB;IAC9B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,OAAO,CAAC;CACpB;AA6GD,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,iBAAiB,GAAG,mBAAmB,GAAG,IAAI,CAyCjH;AAED,wBAAgB,mBAAmB,CAAC,YAAY,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,mBAAmB,GAAG,WAAW,EAAE,CAsCxG;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAEtG;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAE/F;AAED,wBAAgB,qBAAqB,CACjC,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,EAAE;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAC,GAC5C,MAAM,EAAE,CAYV;AAED,wBAAgB,mBAAmB,CAC/B,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,EAAE;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAC,GAC5C,MAAM,EAAE,CAYV;AAED,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC"}

package/dist/knowledge/route_families.js

@@ -0,0 +1,220 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRouteFamilyManifest = loadRouteFamilyManifest;
+exports.bindFilesToFamilies = bindFilesToFamilies;
+exports.getFamilyById = getFamilyById;
+exports.getFeatureById = getFeatureById;
+exports.getSpecDirsForBinding = getSpecDirsForBinding;
+exports.getRoutesForBinding = getRoutesForBinding;
+exports.clearManifestCache = clearManifestCache;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const manifestCache = new Map();
+function matchesGlob(filePath, pattern) {
+    const normalized = filePath.replace(/\\/g, '/');
+    const parts = pattern.replace(/\\/g, '/').split('*');
+    if (parts.length === 1) {
+        return normalized === parts[0] || normalized.startsWith(parts[0]);
+    }
+    let pos = 0;
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (part === '') {
+            continue;
+        }
+        const idx = normalized.indexOf(part, pos);
+        if (idx < 0) {
+            return false;
+        }
+        if (i === 0 && idx !== 0) {
+            return false;
+        }
+        pos = idx + part.length;
+    }
+    return true;
+}
+function matchesAnyPattern(filePath, patterns) {
+    return patterns.some((pattern) => matchesGlob(filePath, pattern));
+}
+function validateFamily(family) {
+    if (!family || typeof family !== 'object') {
+        return null;
+    }
+    const obj = family;
+    if (typeof obj.id !== 'string' || !obj.id.trim()) {
+        return null;
+    }
+    if (!Array.isArray(obj.routes) || obj.routes.length === 0) {
+        return null;
+    }
+    const routes = obj.routes.filter((r) => typeof r === 'string');
+    if (routes.length === 0) {
+        return null;
+    }
+    const result = {
+        id: obj.id.trim(),
+        routes,
+    };
+    if (Array.isArray(obj.pageObjects)) {
+        result.pageObjects = obj.pageObjects.filter((v) => typeof v === 'string');
+    }
+    if (Array.isArray(obj.components)) {
+        result.components = obj.components.filter((v) => typeof v === 'string');
+    }
+    if (Array.isArray(obj.webappPaths)) {
+        result.webappPaths = obj.webappPaths.filter((v) => typeof v === 'string');
+    }
+    if (Array.isArray(obj.serverPaths)) {
+        result.serverPaths = obj.serverPaths.filter((v) => typeof v === 'string');
+    }
+    if (Array.isArray(obj.specDirs)) {
+        result.specDirs = obj.specDirs.filter((v) => typeof v === 'string');
+    }
+    if (Array.isArray(obj.tags)) {
+        result.tags = obj.tags.filter((v) => typeof v === 'string');
+    }
+    if (Array.isArray(obj.features)) {
+        result.features = obj.features
+            .map((f) => validateFeature(f))
+            .filter((f) => f !== null);
+    }
+    return result;
+}
+function validateFeature(feature) {
+    if (!feature || typeof feature !== 'object') {
+        return null;
+    }
+    const obj = feature;
+    if (typeof obj.id !== 'string' || !obj.id.trim()) {
+        return null;
+    }
+    const result = { id: obj.id.trim() };
+    if (Array.isArray(obj.routes)) {
+        result.routes = obj.routes.filter((v) => typeof v === 'string');
+    }
+    if (Array.isArray(obj.webappPaths)) {
+        result.webappPaths = obj.webappPaths.filter((v) => typeof v === 'string');
+    }
+    if (Array.isArray(obj.serverPaths)) {
+        result.serverPaths = obj.serverPaths.filter((v) => typeof v === 'string');
+    }
+    if (Array.isArray(obj.specDirs)) {
+        result.specDirs = obj.specDirs.filter((v) => typeof v === 'string');
+    }
+    if (Array.isArray(obj.tags)) {
+        result.tags = obj.tags.filter((v) => typeof v === 'string');
+    }
+    return result;
+}
+function loadRouteFamilyManifest(testsRoot, config) {
+    const candidates = [];
+    if (config?.manifestPath) {
+        candidates.push(config.manifestPath);
+    }
+    candidates.push((0, path_1.join)(testsRoot, '.e2e-ai-agents', 'route-families.json'));
+    for (const candidate of candidates) {
+        try {
+            if (!(0, fs_1.existsSync)(candidate)) {
+                continue;
+            }
+            const mtimeMs = (0, fs_1.statSync)(candidate).mtimeMs;
+            const cached = manifestCache.get(candidate);
+            if (cached && cached.mtimeMs === mtimeMs && cached.manifest) {
+                return cached.manifest;
+            }
+            const raw = JSON.parse((0, fs_1.readFileSync)(candidate, 'utf-8'));
+            if (!raw.families || !Array.isArray(raw.families)) {
+                manifestCache.set(candidate, { mtimeMs, manifest: null });
+                continue;
+            }
+            const families = raw.families
+                .map((f) => validateFamily(f))
+                .filter((f) => f !== null);
+            if (families.length === 0) {
+                manifestCache.set(candidate, { mtimeMs, manifest: null });
+                continue;
+            }
+            const manifest = { families, source: candidate };
+            manifestCache.set(candidate, { mtimeMs, manifest });
+            return manifest;
+        }
+        catch {
+            continue;
+        }
+    }
+    if (config?.strict) {
+        throw new Error('Route family manifest is required but not found. Create .e2e-ai-agents/route-families.json');
+    }
+    return null;
+}
+function bindFilesToFamilies(changedFiles, manifest) {
+    return changedFiles.map((file) => {
+        const normalized = file.replace(/\\/g, '/');
+        const bindings = [];
+        for (const family of manifest.families) {
+            const featureBindings = [];
+            // Check feature-level first (more specific)
+            if (family.features) {
+                for (const feature of family.features) {
+                    const featurePatterns = [
+                        ...(feature.webappPaths || []),
+                        ...(feature.serverPaths || []),
+                    ];
+                    if (featurePatterns.length > 0 && matchesAnyPattern(normalized, featurePatterns)) {
+                        featureBindings.push({ family: family.id, feature: feature.id });
+                    }
+                }
+            }
+            if (featureBindings.length > 0) {
+                bindings.push(...featureBindings);
+                continue;
+            }
+            // Fall back to family-level patterns
+            const familyPatterns = [
+                ...(family.webappPaths || []),
+                ...(family.serverPaths || []),
+            ];
+            if (familyPatterns.length > 0 && matchesAnyPattern(normalized, familyPatterns)) {
+                bindings.push({ family: family.id });
+            }
+        }
+        return { file: normalized, bindings };
+    });
+}
+function getFamilyById(manifest, familyId) {
+    return manifest.families.find((f) => f.id === familyId);
+}
+function getFeatureById(family, featureId) {
+    return family.features?.find((f) => f.id === featureId);
+}
+function getSpecDirsForBinding(manifest, binding) {
+    const family = getFamilyById(manifest, binding.family);
+    if (!family) {
+        return [];
+    }
+    if (binding.feature) {
+        const feature = getFeatureById(family, binding.feature);
+        if (feature?.specDirs && feature.specDirs.length > 0) {
+            return feature.specDirs;
+        }
+    }
+    return family.specDirs || [];
+}
+function getRoutesForBinding(manifest, binding) {
+    const family = getFamilyById(manifest, binding.family);
+    if (!family) {
+        return [];
+    }
+    if (binding.feature) {
+        const feature = getFeatureById(family, binding.feature);
+        if (feature?.routes && feature.routes.length > 0) {
+            return feature.routes;
+        }
+    }
+    return family.routes;
+}
+function clearManifestCache() {
+    manifestCache.clear();
+}

package/dist/knowledge/spec_index.d.ts

@@ -0,0 +1,18 @@
+import type { RouteFamilyManifest } from './route_families.js';
+export interface SpecEntry {
+    path: string;
+    relativePath: string;
+    testTitles: string[];
+    tags: string[];
+    familyId?: string;
+    featureId?: string;
+}
+export interface SpecIndex {
+    specs: SpecEntry[];
+    indexedAt: string;
+}
+export declare function buildSpecIndex(testsRoot: string, _specPatterns?: string[], manifest?: RouteFamilyManifest | null): SpecIndex;
+export declare function getSpecsForFamily(index: SpecIndex, familyId: string, featureId?: string): SpecEntry[];
+export declare function getSpecByPath(index: SpecIndex, relativePath: string): SpecEntry | undefined;
+export declare function formatSpecsForPrompt(specs: SpecEntry[]): string;
+//# sourceMappingURL=spec_index.d.ts.map

package/dist/knowledge/spec_index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec_index.d.ts","sourceRoot":"","sources":["../../src/knowledge/spec_index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,qBAAqB,CAAC;AAE7D,MAAM,WAAW,SAAS;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,SAAS;IACtB,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACrB;AAwFD,wBAAgB,cAAc,CAC1B,SAAS,EAAE,MAAM,EACjB,aAAa,CAAC,EAAE,MAAM,EAAE,EACxB,QAAQ,CAAC,EAAE,mBAAmB,GAAG,IAAI,GACtC,SAAS,CAcX;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,EAAE,CAUrG;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAE3F;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,MAAM,CAQ/D"}

package/dist/knowledge/spec_index.js

@@ -0,0 +1,128 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSpecIndex = buildSpecIndex;
+exports.getSpecsForFamily = getSpecsForFamily;
+exports.getSpecByPath = getSpecByPath;
+exports.formatSpecsForPrompt = formatSpecsForPrompt;
+const fs_1 = require("fs");
+const path_1 = require("path");
+function extractTestTitles(content) {
+    const titles = [];
+    const testRe = /\btest\s*\(\s*(['"`])((?:(?!\1).|\\.)*)\1/g;
+    let match;
+    while ((match = testRe.exec(content)) !== null) {
+        const title = match[2].trim();
+        if (title) {
+            titles.push(title);
+        }
+    }
+    return titles;
+}
+function extractTags(content) {
+    const tags = new Set();
+    const singleTagRe = /\btag:\s*['"`](@[\w-]+)['"`]/g;
+    let match;
+    while ((match = singleTagRe.exec(content)) !== null) {
+        tags.add(match[1]);
+    }
+    const arrayTagRe = /\btag:\s*\[([^\]]*)\]/g;
+    while ((match = arrayTagRe.exec(content)) !== null) {
+        const inner = match[1];
+        const tagRe = /['"`](@[\w-]+)['"`]/g;
+        let tagMatch;
+        while ((tagMatch = tagRe.exec(inner)) !== null) {
+            tags.add(tagMatch[1]);
+        }
+    }
+    return Array.from(tags);
+}
+function scanSpecDir(dir, testsRoot) {
+    const entries = [];
+    if (!(0, fs_1.existsSync)(dir)) {
+        return entries;
+    }
+    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()) {
+            entries.push(...scanSpecDir(fullPath, testsRoot));
+            continue;
+        }
+        if (!item.name.endsWith('.spec.ts') && !item.name.endsWith('.spec.tsx')) {
+            continue;
+        }
+        try {
+            const content = (0, fs_1.readFileSync)(fullPath, 'utf-8');
+            entries.push({
+                path: fullPath,
+                relativePath: (0, path_1.relative)(testsRoot, fullPath).replace(/\\/g, '/'),
+                testTitles: extractTestTitles(content),
+                tags: extractTags(content),
+            });
+        }
+        catch {
+            continue;
+        }
+    }
+    return entries;
+}
+function bindSpecToFamily(spec, manifest) {
+    const specPath = spec.relativePath;
+    for (const family of manifest.families) {
+        if (family.features) {
+            for (const feature of family.features) {
+                if (feature.specDirs?.some((dir) => specPath.startsWith(dir))) {
+                    spec.familyId = family.id;
+                    spec.featureId = feature.id;
+                    return;
+                }
+            }
+        }
+        if (family.specDirs?.some((dir) => specPath.startsWith(dir))) {
+            spec.familyId = family.id;
+            return;
+        }
+        if (family.tags && spec.tags.some((t) => family.tags.includes(t))) {
+            spec.familyId = family.id;
+            return;
+        }
+    }
+}
+function buildSpecIndex(testsRoot, _specPatterns, manifest) {
+    const specsDir = (0, path_1.join)(testsRoot, 'specs');
+    const specs = scanSpecDir(specsDir, testsRoot);
+    if (manifest) {
+        for (const spec of specs) {
+            bindSpecToFamily(spec, manifest);
+        }
+    }
+    return {
+        specs,
+        indexedAt: new Date().toISOString(),
+    };
+}
+function getSpecsForFamily(index, familyId, featureId) {
+    return index.specs.filter((s) => {
+        if (s.familyId !== familyId) {
+            return false;
+        }
+        if (featureId && s.featureId && s.featureId !== featureId) {
+            return false;
+        }
+        return true;
+    });
+}
+function getSpecByPath(index, relativePath) {
+    return index.specs.find((s) => s.relativePath === relativePath);
+}
+function formatSpecsForPrompt(specs) {
+    return specs
+        .map((s) => {
+        const titles = s.testTitles.map((t) => `  - ${t}`).join('\n');
+        const tagsStr = s.tags.length > 0 ? ` [${s.tags.join(', ')}]` : '';
+        return `${s.relativePath}${tagsStr}\n${titles}`;
+    })
+        .join('\n\n');
+}

package/dist/pipeline/orchestrator.d.ts

@@ -0,0 +1,26 @@
+import { type ImpactConfig } from './stage1_impact.js';
+import { type CoverageConfig } from './stage2_coverage.js';
+import { type GenerationConfig, type GeneratedSpec } from './stage3_generation.js';
+import { type FlowDecisionReport } from '../validation/output_schema.js';
+import type { RouteFamilyConfig } from '../knowledge/route_families.js';
+import type { ApiSurfaceConfig } from '../knowledge/api_surface.js';
+export interface PipelineConfig {
+    appPath: string;
+    testsRoot: string;
+    gitSince: string;
+    gitIncludeUncommitted?: boolean;
+    routeFamilies?: RouteFamilyConfig;
+    apiSurface?: ApiSurfaceConfig;
+    impact?: ImpactConfig;
+    coverage?: CoverageConfig;
+    generation?: GenerationConfig;
+    stages?: Array<'preprocess' | 'impact' | 'coverage' | 'generation'>;
+}
+export interface PipelineResult {
+    report: FlowDecisionReport;
+    reportPath: string;
+    warnings: string[];
+    generated?: GeneratedSpec[];
+}
+export declare function runPipeline(config: PipelineConfig): Promise<PipelineResult>;
+//# sourceMappingURL=orchestrator.d.ts.map

package/dist/pipeline/orchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["../../src/pipeline/orchestrator.ts"],"names":[],"mappings":"AAOA,OAAO,EAAiB,KAAK,YAAY,EAAC,MAAM,oBAAoB,CAAC;AACrE,OAAO,EAAmB,KAAK,cAAc,EAAC,MAAM,sBAAsB,CAAC;AAC3E,OAAO,EAAqB,KAAK,gBAAgB,EAAE,KAAK,aAAa,EAAC,MAAM,wBAAwB,CAAC;AACrG,OAAO,EAAe,KAAK,kBAAkB,EAAoB,MAAM,gCAAgC,CAAC;AAExG,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,gCAAgC,CAAC;AACtE,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,6BAA6B,CAAC;AAElE,MAAM,WAAW,cAAc;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAClC,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,MAAM,CAAC,EAAE,KAAK,CAAC,YAAY,GAAG,QAAQ,GAAG,UAAU,GAAG,YAAY,CAAC,CAAC;CACvE;AAED,MAAM,WAAW,cAAc;IAC3B,MAAM,EAAE,kBAAkB,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,CAAC,EAAE,aAAa,EAAE,CAAC;CAC/B;AAoBD,wBAAsB,WAAW,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CA6GjF"}

package/dist/pipeline/orchestrator.js

@@ -0,0 +1,202 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPipeline = runPipeline;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const git_js_1 = require("../agent/git.js");
+const stage0_preprocess_js_1 = require("./stage0_preprocess.js");
+const stage1_impact_js_1 = require("./stage1_impact.js");
+const stage2_coverage_js_1 = require("./stage2_coverage.js");
+const stage3_generation_js_1 = require("./stage3_generation.js");
+const output_schema_js_1 = require("../validation/output_schema.js");
+const guardrails_js_1 = require("../validation/guardrails.js");
+function createRunId() {
+    const ciRunId = process.env.GITHUB_RUN_ID;
+    const entropy = Math.random().toString(36).slice(2, 8);
+    const ts = Date.now().toString(36);
+    if (ciRunId) {
+        return `pipeline-gh-${ciRunId}-${ts}-${entropy}`;
+    }
+    return `pipeline-local-${ts}-${entropy}`;
+}
+function isTestFile(file) {
+    const normalized = file.replace(/\\/g, '/');
+    return /\.(spec|test)\.(ts|tsx|js|jsx)$/.test(normalized) ||
+        normalized.includes('__tests__/') ||
+        normalized.includes('/tests/') ||
+        normalized.includes('/test/');
+}
+async function runPipeline(config) {
+    const runId = createRunId();
+    const startedAt = new Date().toISOString();
+    const allWarnings = [];
+    const stages = config.stages || ['preprocess', 'impact', 'coverage'];
+    let generatedSpecs;
+    // Step 1: Get changed files
+    const gitResult = (0, git_js_1.getChangedFiles)(config.appPath, config.gitSince, {
+        includeUncommitted: config.gitIncludeUncommitted,
+    });
+    if (gitResult.error) {
+        allWarnings.push(`Git diff warning: ${gitResult.error}`);
+    }
+    const changedFiles = gitResult.files
+        .map((f) => f.replace(/\\/g, '/'))
+        .filter((f) => !isTestFile(f));
+    if (changedFiles.length === 0) {
+        allWarnings.push('No changed application files detected.');
+        const emptyReport = {
+            runId,
+            timestamp: startedAt,
+            gitRef: config.gitSince,
+            summary: (0, output_schema_js_1.buildSummary)([]),
+            decisions: [],
+            warnings: allWarnings,
+            model: {},
+        };
+        const reportPath = writeReport(config.testsRoot, emptyReport);
+        return { report: emptyReport, reportPath, warnings: allWarnings };
+    }
+    // Step 2: Preprocess — deterministic file classification + route family binding
+    const preprocessResult = (0, stage0_preprocess_js_1.preprocess)(changedFiles, {
+        appPath: config.appPath,
+        testsRoot: config.testsRoot,
+        routeFamilies: config.routeFamilies,
+        apiSurface: config.apiSurface,
+    });
+    allWarnings.push(...preprocessResult.warnings);
+    let decisions = [];
+    // Step 3: Impact stage — AI-powered flow identification per family
+    if (stages.includes('impact')) {
+        const impactResult = await (0, stage1_impact_js_1.runImpactStage)(preprocessResult.familyGroups, preprocessResult.manifest, preprocessResult.specIndex, preprocessResult.apiSurface, preprocessResult.context, config.impact || {});
+        decisions = impactResult.decisions;
+        allWarnings.push(...impactResult.warnings);
+        // Check cannot_determine ratio
+        const cannotDetermineRatio = (0, guardrails_js_1.computeCannotDetermineRatio)(decisions);
+        if (cannotDetermineRatio > 0.3) {
+            allWarnings.push(`High cannot_determine ratio (${(cannotDetermineRatio * 100).toFixed(0)}%). Consider updating route-families.json or running with MCP exploration.`);
+        }
+    }
+    // Step 4: Coverage stage — AI-powered spec coverage evaluation
+    if (stages.includes('coverage') && decisions.length > 0) {
+        const coverageResult = await (0, stage2_coverage_js_1.runCoverageStage)(decisions, preprocessResult.specIndex, preprocessResult.context, config.testsRoot, config.coverage || {});
+        decisions = coverageResult.decisions;
+        allWarnings.push(...coverageResult.warnings);
+    }
+    // Step 5: Generation stage — AI-powered spec generation for create_spec / add_scenarios
+    if (stages.includes('generation') && decisions.length > 0) {
+        const generationResult = await (0, stage3_generation_js_1.runGenerationStage)(decisions, preprocessResult.apiSurface, config.testsRoot, config.generation || {});
+        generatedSpecs = generationResult.generated;
+        allWarnings.push(...generationResult.warnings);
+    }
+    // Build report
+    const report = {
+        runId,
+        timestamp: startedAt,
+        gitRef: config.gitSince,
+        summary: (0, output_schema_js_1.buildSummary)(decisions),
+        decisions,
+        warnings: allWarnings,
+        model: {
+            impactAgent: config.impact?.provider || 'auto',
+            coverageAgent: config.coverage?.provider || 'auto',
+            generationAgent: stages.includes('generation') ? (config.generation?.provider || 'auto') : undefined,
+        },
+    };
+    const reportPath = writeReport(config.testsRoot, report);
+    return { report, reportPath, warnings: allWarnings, generated: generatedSpecs };
+}
+function writeReport(testsRoot, report) {
+    const outputDir = (0, path_1.join)(testsRoot, '.e2e-ai-agents');
+    if (!(0, fs_1.existsSync)(outputDir)) {
+        (0, fs_1.mkdirSync)(outputDir, { recursive: true });
+    }
+    const jsonPath = (0, path_1.join)(outputDir, 'pipeline-report.json');
+    (0, fs_1.writeFileSync)(jsonPath, JSON.stringify(report, null, 2), 'utf-8');
+    const mdPath = (0, path_1.join)(outputDir, 'pipeline-report.md');
+    (0, fs_1.writeFileSync)(mdPath, renderMarkdown(report), 'utf-8');
+    return jsonPath;
+}
+function renderMarkdown(report) {
+    const lines = [
+        `# Impact Analysis Pipeline Report`,
+        '',
+        `**Run ID:** ${report.runId}`,
+        `**Timestamp:** ${report.timestamp}`,
+        `**Git Ref:** ${report.gitRef}`,
+        '',
+        `## Summary`,
+        '',
+        `| Metric | Value |`,
+        `|--------|-------|`,
+        `| Changed Files | ${report.summary.changedFiles} |`,
+        `| Route Families Impacted | ${report.summary.routeFamiliesImpacted.join(', ') || 'none'} |`,
+        `| Flows Identified | ${report.summary.flowsIdentified} |`,
+        `| Covered | ${report.summary.flowsCovered} |`,
+        `| Partial | ${report.summary.flowsPartial} |`,
+        `| Uncovered | ${report.summary.flowsUncovered} |`,
+        `| Cannot Determine | ${report.summary.actionsRequired.cannot_determine} |`,
+        `| Overall Confidence | ${report.summary.overallConfidence} |`,
+        '',
+    ];
+    if (report.decisions.length > 0) {
+        lines.push('## Decisions', '');
+        for (const d of report.decisions) {
+            lines.push(`### ${d.flowName} (${d.priority})`);
+            lines.push('');
+            lines.push(`- **Action:** ${d.action}`);
+            lines.push(`- **Route Family:** ${d.routeFamily}${d.featureId ? ` / ${d.featureId}` : ''}`);
+            if (d.specificRoute) {
+                lines.push(`- **Route:** ${d.specificRoute}`);
+            }
+            lines.push(`- **Confidence:** ${d.confidence}%`);
+            lines.push(`- **Evidence:** ${d.evidence}`);
+            lines.push(`- **Changed Files:** ${d.changedFiles.join(', ')}`);
+            if (d.userActions.length > 0) {
+                lines.push(`- **User Actions:** ${d.userActions.join('; ')}`);
+            }
+            if (d.existingSpecs.length > 0) {
+                lines.push('- **Existing Coverage:**');
+                for (const spec of d.existingSpecs) {
+                    lines.push(`  - ${spec.path} (${spec.coverageLevel})`);
+                    if (spec.testTitles.length > 0) {
+                        for (const title of spec.testTitles) {
+                            lines.push(`    - \`${title}\``);
+                        }
+                    }
+                    if (spec.missingScenarios && spec.missingScenarios.length > 0) {
+                        lines.push('    - Missing:');
+                        for (const scenario of spec.missingScenarios) {
+                            lines.push(`      - ${scenario}`);
+                        }
+                    }
+                }
+            }
+            if (d.scenariosToAdd && d.scenariosToAdd.length > 0) {
+                lines.push('- **Scenarios to Add:**');
+                for (const s of d.scenariosToAdd) {
+                    lines.push(`  - ${s}`);
+                }
+            }
+            if (d.targetSpec) {
+                lines.push(`- **Target Spec:** ${d.targetSpec}`);
+            }
+            if (d.newSpecPath) {
+                lines.push(`- **New Spec Path:** ${d.newSpecPath}`);
+            }
+            if (d.blockingReason) {
+                lines.push(`- **Blocking Reason:** ${d.blockingReason}`);
+            }
+            lines.push('');
+        }
+    }
+    if (report.warnings.length > 0) {
+        lines.push('## Warnings', '');
+        for (const w of report.warnings) {
+            lines.push(`- ${w}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}