@yasserkhanorg/e2e-agents 0.3.2

package/dist/agent/telemetry.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.TelemetryCollector = void 0;
+/**
+ * Telemetry Collection System (Phase A2)
+ *
+ * Tracks costs, performance, and success metrics for test generation operations.
+ * Provides visibility into:
+ * - Cost per operation (input/output tokens * model rate)
+ * - Model usage breakdown (Haiku, Sonnet, Opus)
+ * - Success rate by operation
+ * - Performance metrics (duration, tokens used)
+ *
+ * Data stored in: `.e2e-ai-agents/metrics/YYYY-MM-DD.json`
+ */
+const fs_1 = require("fs");
+const path_1 = require("path");
+const crypto_1 = require("crypto");
+const MODEL_RATES = {
+    'claude-haiku-4-0-20250430': 0.25 / 1000000, // per input token
+    'claude-sonnet-4-5-20250929': 3 / 1000000,
+    'claude-opus-4-6-20250820': 15 / 1000000,
+};
+class TelemetryCollector {
+    constructor(metricsDir = '.e2e-ai-agents/metrics') {
+        this.metrics = new Map();
+        this.metricsDir = metricsDir;
+        this.ensureMetricsDir();
+        this.loadTodayMetrics();
+    }
+    /**
+     * Ensure metrics directory exists
+     */
+    ensureMetricsDir() {
+        if (!(0, fs_1.existsSync)(this.metricsDir)) {
+            (0, fs_1.mkdirSync)(this.metricsDir, { recursive: true });
+        }
+    }
+    /**
+     * Get today's metrics file path
+     */
+    getTodayPath() {
+        const now = new Date();
+        const date = now.toISOString().split('T')[0]; // YYYY-MM-DD
+        return (0, path_1.join)(this.metricsDir, `${date}.json`);
+    }
+    /**
+     * Load metrics from disk
+     */
+    loadTodayMetrics() {
+        const path = this.getTodayPath();
+        if ((0, fs_1.existsSync)(path)) {
+            try {
+                const data = JSON.parse((0, fs_1.readFileSync)(path, 'utf-8'));
+                this.metrics.set(path, data);
+            }
+            catch (error) {
+                console.error(`Failed to load metrics from ${path}:`, error);
+            }
+        }
+    }
+    /**
+     * Track a metric
+     */
+    track(metric) {
+        const fullMetric = {
+            id: (0, crypto_1.randomUUID)().substring(0, 8),
+            ...metric,
+        };
+        const path = this.getTodayPath();
+        const metrics = this.metrics.get(path) || [];
+        metrics.push(fullMetric);
+        this.metrics.set(path, metrics);
+        // Persist to disk
+        this.saveMetrics();
+    }
+    /**
+     * Save metrics to disk
+     */
+    saveMetrics() {
+        this.metrics.forEach((metrics, path) => {
+            (0, fs_1.writeFileSync)(path, JSON.stringify(metrics, null, 2), 'utf-8');
+        });
+    }
+    /**
+     * Calculate cost for a metric
+     */
+    static calculateCost(model, tokensInput, tokensOutput) {
+        const inputRate = MODEL_RATES[model] || 0.003 / 1000000; // Default estimate
+        const outputRate = inputRate * 3; // Output usually 3x input cost
+        return tokensInput * inputRate + tokensOutput * outputRate;
+    }
+    /**
+     * Generate report for a date range
+     */
+    generateReport(since, until) {
+        const start = since || new Date(new Date().setDate(new Date().getDate() - 7)); // Default: last 7 days
+        const end = until || new Date();
+        // Collect all metrics in date range
+        const allMetrics = [];
+        this.metrics.forEach((metrics) => {
+            metrics.forEach((m) => {
+                const metricDate = new Date(m.timestamp);
+                if (metricDate >= start && metricDate <= end) {
+                    allMetrics.push(m);
+                }
+            });
+        });
+        // Calculate summary
+        const successCount = allMetrics.filter((m) => m.success).length;
+        const failureCount = allMetrics.length - successCount;
+        const totalCost = allMetrics.reduce((sum, m) => sum + m.costUsd, 0);
+        const avgCost = allMetrics.length > 0 ? totalCost / allMetrics.length : 0;
+        const totalTokens = allMetrics.reduce((sum, m) => sum + (m.tokensInput + m.tokensOutput), 0);
+        const avgDuration = allMetrics.length > 0 ? allMetrics.reduce((sum, m) => sum + m.durationMs, 0) / allMetrics.length / 1000 : 0;
+        // By model
+        const byModel = {};
+        allMetrics.forEach((m) => {
+            if (!byModel[m.model]) {
+                byModel[m.model] = { count: 0, totalCost: 0, successCount: 0 };
+            }
+            byModel[m.model].count += 1;
+            byModel[m.model].totalCost += m.costUsd;
+            if (m.success)
+                byModel[m.model].successCount += 1;
+        });
+        Object.keys(byModel).forEach((model) => {
+            const data = byModel[model];
+            byModel[model] = {
+                count: data.count,
+                totalCost: data.totalCost,
+                avgCost: data.totalCost / data.count,
+                successRate: (data.successCount / data.count) * 100,
+            };
+        });
+        // By operation
+        const byOperation = {};
+        allMetrics.forEach((m) => {
+            if (!byOperation[m.operation]) {
+                byOperation[m.operation] = { count: 0, totalCost: 0, totalDuration: 0, successCount: 0 };
+            }
+            byOperation[m.operation].count += 1;
+            byOperation[m.operation].totalCost += m.costUsd;
+            byOperation[m.operation].totalDuration += m.durationMs;
+            if (m.success)
+                byOperation[m.operation].successCount += 1;
+        });
+        Object.keys(byOperation).forEach((op) => {
+            const data = byOperation[op];
+            byOperation[op] = {
+                count: data.count,
+                totalCost: data.totalCost,
+                avgDuration: data.totalDuration / data.count / 1000,
+                successRate: (data.successCount / data.count) * 100,
+            };
+        });
+        return {
+            period: {
+                start: start.toISOString().split('T')[0],
+                end: end.toISOString().split('T')[0],
+            },
+            summary: {
+                totalOperations: allMetrics.length,
+                successCount,
+                failureCount,
+                successRate: allMetrics.length > 0 ? (successCount / allMetrics.length) * 100 : 0,
+                totalCost,
+                avgCost,
+                totalTokens,
+                avgDuration,
+            },
+            byModel,
+            byOperation,
+        };
+    }
+    /**
+     * Format report for console output
+     */
+    static formatReport(report) {
+        const lines = [
+            '',
+            '📊 Test Generation Metrics',
+            `Period: ${report.period.start} to ${report.period.end}`,
+            '═'.repeat(50),
+            '',
+            `Total Operations: ${report.summary.totalOperations}`,
+            `Success Rate: ${report.summary.successRate.toFixed(1)}% (${report.summary.successCount}/${report.summary.totalOperations})`,
+            `Total Cost: $${report.summary.totalCost.toFixed(2)}`,
+            `Avg Cost/Op: $${report.summary.avgCost.toFixed(4)}`,
+            `Avg Duration: ${report.summary.avgDuration.toFixed(1)}s`,
+            `Total Tokens: ${report.summary.totalTokens.toLocaleString()}`,
+            '',
+            'Model Usage:',
+        ];
+        Object.entries(report.byModel).forEach(([model, data]) => {
+            const shortName = model.includes('haiku') ? 'Haiku' : model.includes('sonnet') ? 'Sonnet' : 'Opus';
+            lines.push(`  ${shortName}: ${data.count} ops - $${data.totalCost.toFixed(2)} (avg $${data.avgCost.toFixed(4)}, ${data.successRate.toFixed(0)}% success)`);
+        });
+        lines.push('', 'By Operation:');
+        Object.entries(report.byOperation).forEach(([op, data]) => {
+            lines.push(`  ${op}: ${data.count} ops - $${data.totalCost.toFixed(2)} (${data.avgDuration.toFixed(1)}s avg, ${data.successRate.toFixed(0)}% success)`);
+        });
+        lines.push('');
+        return lines.join('\n');
+    }
+    /**
+     * Export metrics as JSON
+     */
+    exportJson(filepath) {
+        const allMetrics = [];
+        this.metrics.forEach((metrics) => {
+            allMetrics.push(...metrics);
+        });
+        (0, fs_1.writeFileSync)(filepath, JSON.stringify(allMetrics, null, 2), 'utf-8');
+        console.log(`  ✓ Exported ${allMetrics.length} metrics to ${filepath}`);
+    }
+}
+exports.TelemetryCollector = TelemetryCollector;

package/dist/agent/test_path.d.ts

@@ -0,0 +1,2 @@
+export declare function inferSubsystemFromTestPath(test: string): string;
+//# sourceMappingURL=test_path.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"test_path.d.ts","sourceRoot":"","sources":["../../src/agent/test_path.ts"],"names":[],"mappings":"AAOA,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAiB/D"}

package/dist/agent/test_path.js

@@ -0,0 +1,23 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferSubsystemFromTestPath = inferSubsystemFromTestPath;
+function normalizeTestName(test) {
+    return test.replace(/ \(flags:.*\)$/, '').trim();
+}
+function inferSubsystemFromTestPath(test) {
+    const normalized = normalizeTestName(test).replace(/^\/+/, '');
+    const parts = normalized.split('/').filter(Boolean);
+    if (parts.length === 0) {
+        return 'unknown';
+    }
+    const specsIdx = parts.findIndex((part) => part === 'specs' || part === 'tests');
+    if (specsIdx >= 0 && specsIdx + 1 < parts.length) {
+        return parts[specsIdx + 1] || 'unknown';
+    }
+    if (parts.length >= 2 && (parts[0] === 'e2e-tests' || parts[0] === 'playwright')) {
+        return parts[1] || 'unknown';
+    }
+    return parts[0] || 'unknown';
+}

package/dist/agent/tests.d.ts

@@ -0,0 +1,18 @@
+import type { FlowImpact } from './analysis.js';
+export interface TestFile {
+    path: string;
+    content: string | null;
+}
+export interface FlowCoverage {
+    flowId: string;
+    flowName: string;
+    priority: string;
+    coveredBy: string[];
+    score: number;
+    expectedTests?: string[];
+    source?: 'catalog' | 'traceability' | 'heuristic';
+}
+export declare function discoverTests(appRoot: string, patterns: string[]): TestFile[];
+export declare function mapTestsToFlows(flows: FlowImpact[], tests: TestFile[]): FlowCoverage[];
+export declare function mapCatalogTestsToFlows(flows: FlowImpact[], testsRoot: string, testsByFlow: Map<string, string[]>): FlowCoverage[];
+//# sourceMappingURL=tests.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tests.d.ts","sourceRoot":"","sources":["../../src/agent/tests.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAG9C,MAAM,WAAW,QAAQ;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,MAAM,WAAW,YAAY;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,MAAM,CAAC,EAAE,SAAS,GAAG,cAAc,GAAG,WAAW,CAAC;CACrD;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,QAAQ,EAAE,CAkB7E;AAUD,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,YAAY,EAAE,CAgCtF;AAaD,wBAAgB,sBAAsB,CAClC,KAAK,EAAE,UAAU,EAAE,EACnB,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GACnC,YAAY,EAAE,CA8BhB"}

package/dist/agent/tests.js

@@ -0,0 +1,106 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverTests = discoverTests;
+exports.mapTestsToFlows = mapTestsToFlows;
+exports.mapCatalogTestsToFlows = mapCatalogTestsToFlows;
+const fs_1 = require("fs");
+const glob_1 = require("glob");
+const path_1 = require("path");
+const utils_js_1 = require("./utils.js");
+function discoverTests(appRoot, patterns) {
+    const files = new Set();
+    for (const pattern of patterns) {
+        const matches = (0, glob_1.globSync)(pattern, {
+            cwd: appRoot,
+            ignore: ['**/node_modules/**', '**/.git/**'],
+            nodir: true,
+        });
+        for (const match of matches) {
+            files.add((0, utils_js_1.normalizePath)(match));
+        }
+    }
+    return Array.from(files).map((relativePath) => {
+        const fullPath = (0, path_1.join)(appRoot, relativePath);
+        const content = (0, utils_js_1.safeReadTextFile)(fullPath);
+        return { path: relativePath, content };
+    });
+}
+function buildFlowKeywords(flow) {
+    const tokens = [];
+    tokens.push(...(0, utils_js_1.tokenize)(flow.id));
+    tokens.push(...(0, utils_js_1.tokenize)(flow.name));
+    tokens.push(...flow.keywords);
+    return (0, utils_js_1.uniqueTokens)(tokens);
+}
+function mapTestsToFlows(flows, tests) {
+    const coverage = [];
+    for (const flow of flows) {
+        const keywords = buildFlowKeywords(flow);
+        const matched = [];
+        let score = 0;
+        for (const test of tests) {
+            const haystack = `${test.path} ${test.content || ''}`.toLowerCase();
+            let localScore = 0;
+            for (const keyword of keywords) {
+                if (keyword && haystack.includes(keyword.toLowerCase())) {
+                    localScore += 1;
+                }
+            }
+            if (localScore > 0) {
+                matched.push(test.path);
+                score += localScore;
+            }
+        }
+        coverage.push({
+            flowId: flow.id,
+            flowName: flow.name,
+            priority: flow.priority,
+            coveredBy: matched,
+            score,
+            source: 'heuristic',
+        });
+    }
+    return coverage;
+}
+function resolveExpectedTests(testsRoot, expectedTests) {
+    const resolved = [];
+    for (const entry of expectedTests) {
+        if (!entry) {
+            continue;
+        }
+        resolved.push((0, utils_js_1.normalizePath)(entry));
+    }
+    return resolved;
+}
+function mapCatalogTestsToFlows(flows, testsRoot, testsByFlow) {
+    return flows.map((flow) => {
+        const expectedTests = resolveExpectedTests(testsRoot, testsByFlow.get(flow.id) || []);
+        const coveredBy = [];
+        for (const expected of expectedTests) {
+            const isAbsolute = expected.startsWith('/');
+            const globTarget = isAbsolute ? expected : expected;
+            if (expected.includes('*') || expected.includes('?') || expected.includes('{')) {
+                const matches = (0, glob_1.globSync)(globTarget, { cwd: isAbsolute ? undefined : testsRoot, nodir: true });
+                if (matches.length > 0) {
+                    coveredBy.push(...matches.map((match) => (0, utils_js_1.normalizePath)(match)));
+                }
+                continue;
+            }
+            const fullPath = isAbsolute ? expected : (0, path_1.join)(testsRoot, expected);
+            if ((0, fs_1.existsSync)(fullPath)) {
+                coveredBy.push(isAbsolute ? (0, utils_js_1.normalizePath)(expected) : expected);
+            }
+        }
+        return {
+            flowId: flow.id,
+            flowName: flow.name,
+            priority: flow.priority,
+            coveredBy: Array.from(new Set(coveredBy)),
+            score: coveredBy.length,
+            expectedTests,
+            source: 'catalog',
+        };
+    });
+}

package/dist/agent/traceability.d.ts

@@ -0,0 +1,22 @@
+import type { FlowImpact } from './analysis.js';
+import type { TraceabilityImpactConfig } from './config.js';
+import type { FlowCoverage } from './tests.js';
+export interface TraceabilityStats {
+    source: 'manifest';
+    enabled: boolean;
+    manifestPath: string;
+    manifestFound: boolean;
+    manifestTests: number;
+    manifestEdges: number;
+    matchedFlows: number;
+    totalFlows: number;
+    matchedTests: number;
+    coverageRatio: number;
+}
+export interface TraceabilityMappingResult {
+    coverage: FlowCoverage[];
+    stats: TraceabilityStats;
+    warnings: string[];
+}
+export declare function mapTraceabilityToFlows(appRoot: string, config: TraceabilityImpactConfig, flows: FlowImpact[]): TraceabilityMappingResult;
+//# sourceMappingURL=traceability.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"traceability.d.ts","sourceRoot":"","sources":["../../src/agent/traceability.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAC9C,OAAO,KAAK,EAAC,wBAAwB,EAAC,MAAM,aAAa,CAAC;AAC1D,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,YAAY,CAAC;AAoB7C,MAAM,WAAW,iBAAiB;IAC9B,MAAM,EAAE,UAAU,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,OAAO,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,yBAAyB;IACtC,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,KAAK,EAAE,iBAAiB,CAAC;IACzB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACtB;AAsFD,wBAAgB,sBAAsB,CAClC,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,wBAAwB,EAChC,KAAK,EAAE,UAAU,EAAE,GACpB,yBAAyB,CAiH3B"}

package/dist/agent/traceability.js

@@ -0,0 +1,183 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapTraceabilityToFlows = mapTraceabilityToFlows;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const utils_js_1 = require("./utils.js");
+function ratio(numerator, denominator) {
+    if (denominator <= 0) {
+        return 0;
+    }
+    return Number((numerator / denominator).toFixed(4));
+}
+function resolveManifestPath(root, configuredPath) {
+    if ((0, path_1.isAbsolute)(configuredPath)) {
+        return configuredPath;
+    }
+    return (0, path_1.join)(root, configuredPath);
+}
+function safeReadManifest(path) {
+    if (!(0, fs_1.existsSync)(path)) {
+        return null;
+    }
+    try {
+        return JSON.parse((0, fs_1.readFileSync)(path, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeFiles(files) {
+    if (!files) {
+        return [];
+    }
+    return files.map((file) => (0, utils_js_1.normalizePath)(file)).filter(Boolean);
+}
+function normalizeTests(tests) {
+    if (!tests) {
+        return [];
+    }
+    return tests.map((test) => (0, utils_js_1.normalizePath)(test)).filter(Boolean);
+}
+function buildFileToTestsMap(manifest) {
+    const fileToTests = new Map();
+    const setMapping = (file, test) => {
+        if (!file || !test) {
+            return;
+        }
+        const key = (0, utils_js_1.normalizePath)(file);
+        const value = (0, utils_js_1.normalizePath)(test);
+        if (!fileToTests.has(key)) {
+            fileToTests.set(key, new Set());
+        }
+        fileToTests.get(key)?.add(value);
+    };
+    if (manifest.tests) {
+        for (const entry of manifest.tests) {
+            const files = normalizeFiles(entry.touchedFiles);
+            for (const file of files) {
+                setMapping(file, entry.test);
+            }
+        }
+    }
+    if (manifest.fileToTests) {
+        for (const [file, tests] of Object.entries(manifest.fileToTests)) {
+            const normalizedTests = normalizeTests(tests);
+            for (const test of normalizedTests) {
+                setMapping(file, test);
+            }
+        }
+    }
+    if (manifest.mappings) {
+        for (const entry of manifest.mappings) {
+            const normalizedTests = normalizeTests(entry.tests);
+            for (const test of normalizedTests) {
+                setMapping(entry.file, test);
+            }
+        }
+    }
+    return fileToTests;
+}
+function mapTraceabilityToFlows(appRoot, config, flows) {
+    const manifestPath = resolveManifestPath(appRoot, config.manifestPath);
+    const warnings = [];
+    const fallbackStats = {
+        source: 'manifest',
+        enabled: config.enabled,
+        manifestPath,
+        manifestFound: false,
+        manifestTests: 0,
+        manifestEdges: 0,
+        matchedFlows: 0,
+        totalFlows: flows.length,
+        matchedTests: 0,
+        coverageRatio: 0,
+    };
+    if (!config.enabled) {
+        return {
+            coverage: [],
+            warnings,
+            stats: fallbackStats,
+        };
+    }
+    const manifest = safeReadManifest(manifestPath);
+    if (!manifest) {
+        warnings.push(`Traceability manifest not found or invalid: ${manifestPath}`);
+        return {
+            coverage: [],
+            warnings,
+            stats: fallbackStats,
+        };
+    }
+    const fileToTests = buildFileToTestsMap(manifest);
+    let manifestEdges = 0;
+    for (const tests of fileToTests.values()) {
+        manifestEdges += tests.size;
+    }
+    const manifestTests = new Set();
+    const coverage = [];
+    const matchedTests = new Set();
+    let matchedFlows = 0;
+    for (const tests of fileToTests.values()) {
+        for (const test of tests) {
+            manifestTests.add(test);
+        }
+    }
+    for (const flow of flows) {
+        const signalCounts = new Map();
+        const files = flow.files.map((file) => (0, utils_js_1.normalizePath)(file));
+        for (const file of files) {
+            const tests = fileToTests.get(file);
+            if (!tests) {
+                continue;
+            }
+            for (const test of tests) {
+                signalCounts.set(test, (signalCounts.get(test) || 0) + 1);
+            }
+        }
+        const coveredBy = Array.from(signalCounts.entries())
+            .filter(([, count]) => count >= Math.max(1, config.minSignalsPerTest))
+            .map(([test]) => test)
+            .sort();
+        const score = Array.from(signalCounts.values()).reduce((acc, value) => acc + value, 0);
+        if (coveredBy.length > 0) {
+            matchedFlows += 1;
+            for (const test of coveredBy) {
+                matchedTests.add(test);
+            }
+        }
+        coverage.push({
+            flowId: flow.id,
+            flowName: flow.name,
+            priority: flow.priority,
+            coveredBy,
+            score,
+            source: 'traceability',
+        });
+    }
+    const stats = {
+        source: 'manifest',
+        enabled: config.enabled,
+        manifestPath,
+        manifestFound: true,
+        manifestTests: manifestTests.size,
+        manifestEdges,
+        matchedFlows,
+        totalFlows: flows.length,
+        matchedTests: matchedTests.size,
+        coverageRatio: ratio(matchedFlows, flows.length),
+    };
+    if (manifestEdges === 0) {
+        warnings.push(`Traceability manifest has no file-to-test mappings: ${manifestPath}`);
+    }
+    else if (stats.coverageRatio < 0.4) {
+        warnings.push(`Traceability coverage is low (${stats.matchedFlows}/${stats.totalFlows} flows mapped). Recommendations may require heuristic fallback.`);
+    }
+    return {
+        coverage,
+        warnings,
+        stats,
+    };
+}

package/dist/agent/traceability_capture.d.ts

@@ -0,0 +1,18 @@
+export interface TraceabilityCaptureOptions {
+    appPath: string;
+    testsRoot: string;
+    reportPath: string;
+    sinceRef: string;
+    outputPath?: string;
+    coverageMapPath?: string;
+    changedFilesPath?: string;
+}
+export interface TraceabilityCaptureResult {
+    outputPath: string;
+    testsSeen: number;
+    runsGenerated: number;
+    changedFilesUsed: number;
+    warnings: string[];
+}
+export declare function captureTraceabilityInput(options: TraceabilityCaptureOptions): TraceabilityCaptureResult;
+//# sourceMappingURL=traceability_capture.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"traceability_capture.d.ts","sourceRoot":"","sources":["../../src/agent/traceability_capture.ts"],"names":[],"mappings":"AAmCA,MAAM,WAAW,0BAA0B;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,yBAAyB;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACtB;AAgRD,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,0BAA0B,GAAG,yBAAyB,CAgFvG"}