@yasserkhanorg/e2e-agents 0.3.2

package/dist/agent/impact-analyzer.js

@@ -0,0 +1,557 @@
+"use strict";
+/**
+ * Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+ * See LICENSE.txt for license information.
+ *
+ * Impact Analysis Engine
+ *
+ * Analyzes code changes and identifies which user flows are affected,
+ * then maps those flows to test coverage gaps.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectComparisonBase = detectComparisonBase;
+exports.getGitChanges = getGitChanges;
+exports.loadFlowCatalog = loadFlowCatalog;
+exports.matchFlowToChanges = matchFlowToChanges;
+exports.findExistingTests = findExistingTests;
+exports.identifyTestGaps = identifyTestGaps;
+exports.analyzeImpact = analyzeImpact;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const minimatch_1 = require("minimatch");
+// =============================================================================
+// GIT CHANGE DETECTION
+// =============================================================================
+/**
+ * Intelligently detect the best git reference for comparison:
+ * - If on feature branch: use origin/master, origin/main, or master
+ * - If on main branch: use HEAD~1
+ * Returns the best available reference to compare against
+ */
+function detectComparisonBase() {
+    try {
+        const gitRoot = findGitRoot();
+        // Get current branch
+        const currentBranch = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', {
+            encoding: 'utf-8',
+            cwd: gitRoot,
+        }).trim();
+        // If on main branch, just check last commit
+        if (currentBranch === 'master' || currentBranch === 'main') {
+            return 'HEAD~1';
+        }
+        // On feature branch: try to find the main branch
+        // Try origin/master first, then origin/main, then master
+        const candidates = ['origin/master', 'origin/main', 'master'];
+        for (const candidate of candidates) {
+            try {
+                (0, child_process_1.execSync)(`git rev-parse ${candidate}`, {
+                    encoding: 'utf-8',
+                    cwd: gitRoot,
+                    stdio: 'ignore',
+                });
+                return candidate;
+            }
+            catch {
+                // Try next candidate
+            }
+        }
+        // Fallback if none found
+        return 'HEAD~1';
+    }
+    catch {
+        // If git commands fail, default to HEAD~1
+        return 'HEAD~1';
+    }
+}
+/**
+ * Check if a file path is a frontend file
+ * Frontend includes: webapp and e2e-tests directories
+ */
+function isFrontendFile(filePath) {
+    return filePath.startsWith('webapp/') || filePath.startsWith('e2e-tests/');
+}
+/**
+ * Get git changes since a given reference
+ * Filters to only include frontend files (webapp and e2e-tests)
+ */
+function getGitChanges(since = 'HEAD~1') {
+    try {
+        const gitRoot = findGitRoot();
+        const result = (0, child_process_1.execSync)(`git diff --name-status ${since}...HEAD`, {
+            encoding: 'utf-8',
+            cwd: gitRoot,
+        });
+        return result
+            .trim()
+            .split('\n')
+            .filter((line) => line.length > 0)
+            .map((line) => {
+            const [status, path] = line.split('\t');
+            return {
+                path,
+                status: status,
+                ref: since,
+            };
+        })
+            .filter((change) => isFrontendFile(change.path));
+    }
+    catch (error) {
+        console.warn(`⚠️  Could not get git changes: ${error.message}`);
+        return [];
+    }
+}
+/**
+ * Get git diff stats for a file
+ */
+function getFileDiffStats(filePath, since = 'HEAD~1') {
+    try {
+        const gitRoot = findGitRoot();
+        const result = (0, child_process_1.execSync)(`git diff --numstat ${since}...HEAD -- ${filePath}`, {
+            encoding: 'utf-8',
+            cwd: gitRoot,
+        });
+        const match = result.match(/(\d+)\s+(\d+)/);
+        if (match) {
+            return {
+                linesAdded: parseInt(match[1], 10),
+                linesRemoved: parseInt(match[2], 10),
+            };
+        }
+    }
+    catch (error) {
+        // Ignore errors
+    }
+    return { linesAdded: 0, linesRemoved: 0 };
+}
+// =============================================================================
+// FLOW CATALOG LOADING
+// =============================================================================
+/**
+ * Load flow catalog from flows.json
+ */
+function loadFlowCatalog(catalogPath) {
+    let path = catalogPath;
+    if (!path) {
+        // Try multiple possible paths for flows.json
+        const possiblePaths = [
+            // If running from e2e-tests/playwright directory
+            (0, path_1.join)(process.cwd(), '.e2e-ai-agents/flows.json'),
+            // If running from monorepo root
+            (0, path_1.join)(process.cwd(), 'e2e-tests/playwright/.e2e-ai-agents/flows.json'),
+        ];
+        // Find the first path that exists
+        path = possiblePaths.find((p) => (0, fs_1.existsSync)(p));
+        if (!path) {
+            throw new Error(`Flow catalog not found. Tried:\n${possiblePaths.map((p) => `  - ${p}`).join('\n')}`);
+        }
+    }
+    if (!(0, fs_1.existsSync)(path)) {
+        throw new Error(`Flow catalog not found at ${path}`);
+    }
+    const content = (0, fs_1.readFileSync)(path, 'utf-8');
+    const data = JSON.parse(content);
+    return data.flows || [];
+}
+// =============================================================================
+// FLOW MATCHING
+// =============================================================================
+/**
+ * Check if a file path matches a glob pattern
+ */
+function pathMatches(filePath, pattern) {
+    // Normalize patterns
+    const normalizedPattern = pattern.replace(/\\/g, '/');
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    // Handle ** wildcards
+    if (normalizedPattern.includes('**')) {
+        // Convert ** pattern to regex
+        // Use placeholder to avoid escaping issues with **
+        const placeholder = '___DOUBLE_STAR___';
+        let regexPattern = normalizedPattern.replace(/\*\*/g, placeholder);
+        // Escape regex special chars
+        regexPattern = regexPattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+        // Replace placeholder with .* (matches anything including /)
+        regexPattern = regexPattern.replace(new RegExp(placeholder, 'g'), '.*');
+        // Replace remaining * with [^/]* (matches anything except /)
+        regexPattern = regexPattern.replace(/\*/g, '[^/]*');
+        // Replace ? with [^/]
+        regexPattern = regexPattern.replace(/\?/g, '[^/]');
+        return new RegExp(`^${regexPattern}$`).test(normalizedPath);
+    }
+    return (0, minimatch_1.minimatch)(normalizedPath, normalizedPattern, { matchBase: true });
+}
+/**
+ * Calculate confidence score based on match type and quality
+ */
+function calculateConfidence(matchType, matchQuality) {
+    const typeWeights = {
+        path_exact: 100,
+        path_pattern: 85,
+        keyword_multiple: 75,
+        keyword_single: 60,
+        import: 50,
+    };
+    return Math.min(100, typeWeights[matchType] || 50);
+}
+/**
+ * Match a flow to changed files
+ */
+function matchFlowToChanges(flow, changes) {
+    const reasons = [];
+    const affectedFiles = [];
+    let matchType = 'path';
+    let confidence = 0;
+    // Check path matching
+    const pathMatchedFiles = changes.filter((change) => flow.paths.some((pattern) => pathMatches(change.file, pattern)));
+    if (pathMatchedFiles.length > 0) {
+        affectedFiles.push(...pathMatchedFiles.map((c) => c.file));
+        confidence = Math.max(confidence, 90);
+        matchType = 'path';
+        reasons.push(`${pathMatchedFiles.length} file(s) match flow paths: ${pathMatchedFiles.map((c) => c.file).join(', ')}`);
+    }
+    // Check keyword matching
+    const flowKeywords = flow.keywords.map((k) => k.toLowerCase());
+    const keywordMatches = [];
+    for (const change of changes) {
+        const changeContent = [
+            ...change.functions,
+            ...change.classes,
+            ...change.imports.flatMap((i) => [i.from, ...i.names]),
+        ]
+            .join(' ')
+            .toLowerCase();
+        for (const keyword of flowKeywords) {
+            if (changeContent.includes(keyword)) {
+                keywordMatches.push(change.file);
+                break;
+            }
+        }
+    }
+    if (keywordMatches.length > 0) {
+        affectedFiles.push(...keywordMatches.filter((f) => !affectedFiles.includes(f)));
+        confidence = Math.max(confidence, keywordMatches.length > 1 ? 75 : 60);
+        if (pathMatches.length === 0) {
+            matchType = 'keyword';
+        }
+        else {
+            matchType = 'combined';
+        }
+        reasons.push(`${keywordMatches.length} file(s) contain keywords: ${flowKeywords.slice(0, 3).join(', ')}`);
+    }
+    // Check import matching
+    const importMatches = [];
+    const flowPaths = flow.paths.map((p) => p.replace(/\*\*/g, '').toLowerCase());
+    for (const change of changes) {
+        for (const imp of change.imports) {
+            const impFrom = imp.from.toLowerCase();
+            for (const flowPath of flowPaths) {
+                if (impFrom.includes(flowPath.replace(/[\/\\]/g, ''))) {
+                    importMatches.push(change.file);
+                    break;
+                }
+            }
+        }
+    }
+    if (importMatches.length > 0) {
+        affectedFiles.push(...importMatches.filter((f) => !affectedFiles.includes(f)));
+        confidence = Math.max(confidence, 50);
+        if (pathMatches.length === 0 && keywordMatches.length === 0) {
+            matchType = 'import';
+        }
+        else {
+            matchType = 'combined';
+        }
+    }
+    // Return null if no matches
+    if (confidence === 0) {
+        return null;
+    }
+    return {
+        flow,
+        matchType,
+        confidence: Math.min(100, confidence),
+        affectedFiles: [...new Set(affectedFiles)],
+        existingTests: [],
+        testGaps: [],
+        reasons,
+    };
+}
+// =============================================================================
+// TEST ANALYSIS
+// =============================================================================
+/**
+ * Find existing tests for a flow
+ */
+function findExistingTests(flow, repoRoot) {
+    const root = repoRoot || findGitRoot();
+    const tests = [];
+    // Use tests array from flow definition
+    if (flow.tests && flow.tests.length > 0) {
+        for (const testPath of flow.tests) {
+            const fullPath = (0, path_1.join)(root, testPath);
+            if ((0, fs_1.existsSync)(fullPath)) {
+                tests.push(testPath);
+            }
+        }
+    }
+    return tests;
+}
+/**
+ * Identify test coverage gaps for a flow
+ */
+function identifyTestGaps(flow, existingTests) {
+    const gaps = [];
+    // If no existing tests, all scenarios are gaps
+    if (existingTests.length === 0) {
+        gaps.push(`No existing tests for ${flow.name}`);
+        // Suggest specific test scenarios based on audience and keywords
+        const audiences = flow.audience || [];
+        const keywords = flow.keywords || [];
+        if (audiences.length > 0) {
+            gaps.push(`Missing scenarios for audiences: ${audiences.slice(0, 2).join(', ')}`);
+        }
+        if (keywords.length > 0) {
+            gaps.push(`Missing tests for: ${keywords.slice(0, 2).join(', ')}`);
+        }
+    }
+    // Check for specific audience coverage
+    const audiences = flow.audience || [];
+    if (audiences.length > 1) {
+        // Suggest multi-audience testing
+        gaps.push('Consider testing with different user roles');
+    }
+    // Check for edge cases based on flow type
+    if (flow.keywords.includes('realtime') || flow.keywords.includes('websocket')) {
+        gaps.push('Consider testing offline/reconnection scenarios');
+    }
+    if (flow.keywords.includes('edit') || flow.keywords.includes('delete')) {
+        gaps.push('Consider testing permissions/authorization edge cases');
+    }
+    return gaps;
+}
+// =============================================================================
+// MAIN ANALYSIS
+// =============================================================================
+/**
+ * Analyze code impact and return comprehensive report
+ */
+async function analyzeImpact(changes, flows, options = {}) {
+    const repoRoot = options.repoRoot || findGitRoot();
+    // Analyze each changed file
+    const analyses = [];
+    for (const change of changes) {
+        const analysis = analyzeFile(change.path, change.status);
+        if (analysis) {
+            analyses.push(analysis);
+        }
+    }
+    if (options.verbose) {
+        console.log(`📊 Analyzed ${analyses.length} changed files`);
+    }
+    // Match changes to flows
+    const impactedFlows = [];
+    for (const flow of flows) {
+        const impact = matchFlowToChanges(flow, analyses);
+        if (impact && impact.confidence > 0) {
+            // Find existing tests
+            impact.existingTests = findExistingTests(flow, repoRoot);
+            // Identify test gaps
+            impact.testGaps = identifyTestGaps(flow, impact.existingTests);
+            impactedFlows.push(impact);
+        }
+    }
+    // Sort by priority and confidence
+    impactedFlows.sort((a, b) => {
+        const priorityOrder = { P0: 0, P1: 1, P2: 2 };
+        const aPriority = priorityOrder[a.flow.priority];
+        const bPriority = priorityOrder[b.flow.priority];
+        if (aPriority !== bPriority) {
+            return aPriority - bPriority;
+        }
+        return b.confidence - a.confidence;
+    });
+    if (options.verbose) {
+        console.log(`🎯 Found ${impactedFlows.length} affected flows`);
+    }
+    // Generate recommendations
+    const recommendations = generateRecommendations(impactedFlows);
+    // Group flows by relationships
+    const { groups, ungrouped } = groupFlowsByRelationships(impactedFlows, flows);
+    return {
+        timestamp: new Date().toISOString(),
+        gitRef: changes[0]?.ref || 'HEAD',
+        totalChanges: changes.length,
+        affectedFlows: impactedFlows,
+        flowGroups: groups,
+        ungroupedFlows: ungrouped,
+        priorityBreakdown: {
+            p0: impactedFlows.filter((f) => f.flow.priority === 'P0').length,
+            p1: impactedFlows.filter((f) => f.flow.priority === 'P1').length,
+            p2: impactedFlows.filter((f) => f.flow.priority === 'P2').length,
+        },
+        testCoverage: {
+            total: impactedFlows.length,
+            covered: impactedFlows.filter((f) => f.existingTests.length > 0).length,
+            gaps: impactedFlows.filter((f) => f.testGaps.length > 0).length,
+        },
+        recommendations,
+        hasP0Impact: impactedFlows.some((f) => f.flow.priority === 'P0'),
+    };
+}
+// =============================================================================
+// HELPER FUNCTIONS
+// =============================================================================
+/**
+ * Load flow groups from flows.json
+ */
+function loadFlowGroups() {
+    const possiblePaths = [
+        // If running from e2e-tests/playwright directory
+        (0, path_1.join)(process.cwd(), '.e2e-ai-agents/flows.json'),
+        // If running from monorepo root
+        (0, path_1.join)(process.cwd(), 'e2e-tests/playwright/.e2e-ai-agents/flows.json'),
+    ];
+    const path = possiblePaths.find((p) => (0, fs_1.existsSync)(p));
+    if (!path) {
+        return {}; // Return empty object if flows.json not found
+    }
+    try {
+        const content = (0, fs_1.readFileSync)(path, 'utf-8');
+        const data = JSON.parse(content);
+        return data.flowGroups || {};
+    }
+    catch (error) {
+        return {}; // Return empty object on parse error
+    }
+}
+/**
+ * Group related flows into test journeys based on flowGroup metadata
+ */
+function groupFlowsByRelationships(impactedFlows, flowCatalog) {
+    const groups = [];
+    const grouped = new Set();
+    // Load flow group definitions from flows.json
+    const flowGroupDefs = loadFlowGroups();
+    // For each flow group definition
+    for (const [groupId, groupDef] of Object.entries(flowGroupDefs)) {
+        const groupFlows = groupDef.flows || [];
+        // Find which flows in this group are impacted
+        const affectedInGroup = impactedFlows.filter((impact) => groupFlows.includes(impact.flow.id));
+        if (affectedInGroup.length > 0) {
+            groups.push({
+                id: groupId,
+                name: groupDef.name || groupId,
+                description: groupDef.description || '',
+                flows: groupFlows,
+                testStrategy: groupDef.testStrategy || 'mixed',
+                priority: groupDef.priority || 'P1',
+                affectedFlows: affectedInGroup,
+            });
+            // Mark as grouped
+            affectedInGroup.forEach((impact) => grouped.add(impact.flow.id));
+        }
+    }
+    // Remaining ungrouped flows
+    const ungrouped = impactedFlows.filter((impact) => !grouped.has(impact.flow.id));
+    return { groups, ungrouped };
+}
+/**
+ * Analyze a single file to extract functions, classes, and imports
+ */
+/**
+ * Find the git repository root directory
+ */
+function findGitRoot() {
+    let currentDir = process.cwd();
+    const root = (0, path_1.resolve)('/');
+    while (currentDir !== root) {
+        if ((0, fs_1.existsSync)((0, path_1.join)(currentDir, '.git'))) {
+            return currentDir;
+        }
+        currentDir = (0, path_1.resolve)(currentDir, '..');
+    }
+    // Fallback to process.cwd()
+    return process.cwd();
+}
+function analyzeFile(filePath, status) {
+    const repoRoot = findGitRoot();
+    const fullPath = (0, path_1.join)(repoRoot, filePath);
+    const stats = getFileDiffStats(filePath);
+    // Extract imports, functions, and classes from the file
+    const functions = [];
+    const classes = [];
+    const imports = [];
+    try {
+        const content = (0, fs_1.readFileSync)(fullPath, 'utf-8');
+        // Extract imports (handles: import X from 'Y', import * as X from 'Y', etc.)
+        const importRegex = /import\s+(?:{([^}]+)}|(?:\*\s+as\s+)?(\w+))\s+from\s+['"]([^'"]+)['"]/g;
+        let importMatch;
+        while ((importMatch = importRegex.exec(content)) !== null) {
+            const namedImports = importMatch[1]?.split(',').map((s) => s.trim().split(/\s+as\s+/)[0]) || [];
+            const defaultImport = importMatch[2] ? [importMatch[2]] : [];
+            const allNames = [...namedImports, ...defaultImport].filter(Boolean);
+            if (allNames.length > 0) {
+                imports.push({
+                    from: importMatch[3],
+                    names: allNames,
+                });
+            }
+        }
+        // Extract function declarations (handles: function X, const X = () => {}, export function X)
+        const functionRegex = /(?:export\s+)?(?:async\s+)?(?:function\s+(\w+)|const\s+(\w+)\s*=)/g;
+        let functionMatch;
+        const seenFunctions = new Set();
+        while ((functionMatch = functionRegex.exec(content)) !== null) {
+            const funcName = functionMatch[1] || functionMatch[2];
+            if (funcName && !seenFunctions.has(funcName)) {
+                functions.push(funcName);
+                seenFunctions.add(funcName);
+            }
+        }
+        // Extract class declarations
+        const classRegex = /(?:export\s+)?class\s+(\w+)/g;
+        let classMatch;
+        while ((classMatch = classRegex.exec(content)) !== null) {
+            if (classMatch[1]) {
+                classes.push(classMatch[1]);
+            }
+        }
+    }
+    catch {
+        // If file doesn't exist or can't be read, continue with empty arrays
+    }
+    return {
+        file: filePath,
+        status: status,
+        linesAdded: stats.linesAdded,
+        linesRemoved: stats.linesRemoved,
+        functions,
+        classes,
+        imports,
+    };
+}
+/**
+ * Generate actionable recommendations based on impact
+ */
+function generateRecommendations(impactedFlows) {
+    const recommendations = [];
+    const p0Flows = impactedFlows.filter((f) => f.flow.priority === 'P0');
+    const p1Flows = impactedFlows.filter((f) => f.flow.priority === 'P1');
+    if (p0Flows.length > 0) {
+        recommendations.push(`✅ Run critical (P0) flow tests immediately: ${p0Flows.map((f) => f.flow.id).join(', ')}`);
+    }
+    if (p1Flows.length > 0) {
+        recommendations.push(`🟡 Run high-priority (P1) flow tests: ${p1Flows.map((f) => f.flow.id).join(', ')}`);
+    }
+    const gapFlows = impactedFlows.filter((f) => f.testGaps.length > 0);
+    if (gapFlows.length > 0) {
+        recommendations.push(`📝 Generate tests to cover ${gapFlows.length} flow(s) with test gaps`);
+    }
+    const lowConfidenceFlows = impactedFlows.filter((f) => f.confidence < 60);
+    if (lowConfidenceFlows.length > 0) {
+        recommendations.push(`🔍 Review ${lowConfidenceFlows.length} flow(s) with low confidence matches (< 60%)`);
+    }
+    return recommendations;
+}

package/dist/agent/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Agent Module Exports
+ *
+ * Centralizes all agent-related functionality including:
+ * - Impact analysis (detecting affected flows from code changes)
+ * - Model routing (intelligent LLM model selection for cost optimization)
+ * - Telemetry (metrics collection and reporting)
+ * - Report generation (formatted output)
+ * - Spec building (test specification generation)
+ */
+export { analyzeImpact, detectComparisonBase, getGitChanges, loadFlowCatalog, matchFlowToChanges, findExistingTests, identifyTestGaps, } from './impact-analyzer.js';
+export type { GitChange, ChangeAnalysis, Flow, FlowImpact, FlowGroup, ImpactReport } from './impact-analyzer.js';
+export { ModelRouter } from './model-router.js';
+export type { TaskContext, TaskComplexity, ModelConfig } from './model-router.js';
+export { TelemetryCollector } from './telemetry.js';
+export type { GenerationMetric, TelemetryReport } from './telemetry.js';
+export { generateReports } from './report-generator.js';
+export type { ReportOptions } from './report-generator.js';
+export { SpecBridge, createAnthropicBridge, createOllamaBridge } from './spec-builder.js';
+export type { SpecBridgeConfig, ConversionResult } from './spec-builder.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agent/index.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AAGH,OAAO,EACH,aAAa,EACb,oBAAoB,EACpB,aAAa,EACb,eAAe,EACf,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,GACnB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EAAE,SAAS,EAAE,cAAc,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGjH,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGlF,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGxE,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAG3D,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC1F,YAAY,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/agent/index.js

@@ -0,0 +1,38 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOllamaBridge = exports.createAnthropicBridge = exports.SpecBridge = exports.generateReports = exports.TelemetryCollector = exports.ModelRouter = exports.identifyTestGaps = exports.findExistingTests = exports.matchFlowToChanges = exports.loadFlowCatalog = exports.getGitChanges = exports.detectComparisonBase = exports.analyzeImpact = void 0;
+/**
+ * Agent Module Exports
+ *
+ * Centralizes all agent-related functionality including:
+ * - Impact analysis (detecting affected flows from code changes)
+ * - Model routing (intelligent LLM model selection for cost optimization)
+ * - Telemetry (metrics collection and reporting)
+ * - Report generation (formatted output)
+ * - Spec building (test specification generation)
+ */
+// Impact Analysis
+var impact_analyzer_js_1 = require("./impact-analyzer.js");
+Object.defineProperty(exports, "analyzeImpact", { enumerable: true, get: function () { return impact_analyzer_js_1.analyzeImpact; } });
+Object.defineProperty(exports, "detectComparisonBase", { enumerable: true, get: function () { return impact_analyzer_js_1.detectComparisonBase; } });
+Object.defineProperty(exports, "getGitChanges", { enumerable: true, get: function () { return impact_analyzer_js_1.getGitChanges; } });
+Object.defineProperty(exports, "loadFlowCatalog", { enumerable: true, get: function () { return impact_analyzer_js_1.loadFlowCatalog; } });
+Object.defineProperty(exports, "matchFlowToChanges", { enumerable: true, get: function () { return impact_analyzer_js_1.matchFlowToChanges; } });
+Object.defineProperty(exports, "findExistingTests", { enumerable: true, get: function () { return impact_analyzer_js_1.findExistingTests; } });
+Object.defineProperty(exports, "identifyTestGaps", { enumerable: true, get: function () { return impact_analyzer_js_1.identifyTestGaps; } });
+// Model Routing (Cost Optimization - TinyDancer pattern)
+var model_router_js_1 = require("./model-router.js");
+Object.defineProperty(exports, "ModelRouter", { enumerable: true, get: function () { return model_router_js_1.ModelRouter; } });
+// Telemetry (Metrics Collection)
+var telemetry_js_1 = require("./telemetry.js");
+Object.defineProperty(exports, "TelemetryCollector", { enumerable: true, get: function () { return telemetry_js_1.TelemetryCollector; } });
+// Report Generation (Console, Markdown, JSON)
+var report_generator_js_1 = require("./report-generator.js");
+Object.defineProperty(exports, "generateReports", { enumerable: true, get: function () { return report_generator_js_1.generateReports; } });
+// Spec Bridge (PDF → Playwright specs)
+var spec_builder_js_1 = require("./spec-builder.js");
+Object.defineProperty(exports, "SpecBridge", { enumerable: true, get: function () { return spec_builder_js_1.SpecBridge; } });
+Object.defineProperty(exports, "createAnthropicBridge", { enumerable: true, get: function () { return spec_builder_js_1.createAnthropicBridge; } });
+Object.defineProperty(exports, "createOllamaBridge", { enumerable: true, get: function () { return spec_builder_js_1.createOllamaBridge; } });

package/dist/agent/model-router.d.ts

@@ -0,0 +1,57 @@
+/**
+ * TinyDancer-Style Model Router
+ *
+ * Intelligently routes test generation tasks to appropriate LLM models based on complexity:
+ * - Simple tasks (healing, validation): Claude Haiku ($0.25/1M tokens) - 40-60% cost reduction
+ * - Moderate tasks (test generation): Claude Sonnet ($3/1M tokens) - balanced quality/cost
+ * - Complex tasks (critical failures): Claude Opus ($15/1M tokens) - best quality
+ *
+ * This achieves 40-60% cost reduction by using cheaper models for simple operations.
+ */
+export interface TaskComplexity {
+    type: 'simple' | 'moderate' | 'complex' | 'critical';
+    confidence: number;
+    reasoning: string;
+}
+export interface TaskContext {
+    operation: 'explore' | 'generate' | 'heal' | 'validate' | 'score';
+    attemptNumber?: number;
+    codeSize?: number;
+    uiMapCoverage?: number;
+    errorType?: string;
+    previousFailures?: number;
+}
+export interface ModelConfig {
+    simpleModel: string;
+    moderateModel: string;
+    complexModel: string;
+    criticalModel: string;
+}
+export declare class ModelRouter {
+    private modelConfig;
+    constructor(config?: Partial<ModelConfig>);
+    /**
+     * Classify task complexity based on operation, attempt number, and context
+     */
+    classifyTask(context: TaskContext): TaskComplexity;
+    /**
+     * Select appropriate model based on task complexity
+     */
+    selectModel(complexity: TaskComplexity): string;
+    /**
+     * Get estimated cost for a task
+     */
+    estimateCost(complexity: TaskComplexity, estimatedTokens?: number): number;
+    /**
+     * Get cost savings vs always using Sonnet
+     */
+    estimateSavings(complexity: TaskComplexity, estimatedTokens?: number): {
+        savedCost: number;
+        savingsPercent: number;
+    };
+    /**
+     * Format complexity for logging
+     */
+    formatComplexity(complexity: TaskComplexity, tokensUsed?: number): string;
+}
+//# sourceMappingURL=model-router.d.ts.map

package/dist/agent/model-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-router.d.ts","sourceRoot":"","sources":["../../src/agent/model-router.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AAEH,MAAM,WAAW,cAAc;IAC3B,IAAI,EAAE,QAAQ,GAAG,UAAU,GAAG,SAAS,GAAG,UAAU,CAAC;IACrD,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,WAAW;IACxB,SAAS,EAAE,SAAS,GAAG,UAAU,GAAG,MAAM,GAAG,UAAU,GAAG,OAAO,CAAC;IAClE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,WAAW;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;CACzB;AAQD,qBAAa,WAAW;IACpB,OAAO,CAAC,WAAW,CAAc;gBAErB,MAAM,GAAE,OAAO,CAAC,WAAW,CAAM;IAS7C;;OAEG;IACH,YAAY,CAAC,OAAO,EAAE,WAAW,GAAG,cAAc;IA2FlD;;OAEG;IACH,WAAW,CAAC,UAAU,EAAE,cAAc,GAAG,MAAM;IAa/C;;OAEG;IACH,YAAY,CAAC,UAAU,EAAE,cAAc,EAAE,eAAe,GAAE,MAAa,GAAG,MAAM;IAMhF;;OAEG;IACH,eAAe,CACX,UAAU,EAAE,cAAc,EAC1B,eAAe,GAAE,MAAa,GAC/B;QACC,SAAS,EAAE,MAAM,CAAC;QAClB,cAAc,EAAE,MAAM,CAAC;KAC1B;IAaD;;OAEG;IACH,gBAAgB,CAAC,UAAU,EAAE,cAAc,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM;CAS5E"}