playwright-ai-reporter 0.0.4

package/dist/utils/configValidator.js

@@ -0,0 +1,454 @@
+"use strict";
+/**
+ * Configuration validator and diagnostic tool
+ *
+ * This utility helps validate provider configurations and diagnose issues
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigValidator = void 0;
+const dotenv = __importStar(require("dotenv"));
+const path = __importStar(require("path"));
+const AIProviderFactory_1 = require("../providers/ai/AIProviderFactory");
+const BugTrackerFactory_1 = require("../providers/factories/BugTrackerFactory");
+const DatabaseFactory_1 = require("../providers/factories/DatabaseFactory");
+dotenv.config({ path: path.resolve(process.cwd(), '.env') });
+class ConfigValidator {
+    /**
+     * Validate all configured providers
+     */
+    static async validateAll() {
+        const results = [];
+        console.log('\n=== Provider Configuration Validation ===\n');
+        // Validate AI Provider
+        results.push(await this.validateAIProvider());
+        // Validate Bug Tracker (if configured)
+        if (process.env.BUG_TRACKER_PROVIDER) {
+            results.push(await this.validateBugTracker());
+        }
+        // Validate Database (if configured)
+        if (process.env.DATABASE_PROVIDER) {
+            results.push(await this.validateDatabase());
+        }
+        // Validate Notification Provider (if configured)
+        if (process.env.NOTIFICATION_PROVIDER) {
+            results.push(await this.validateNotificationProvider());
+        }
+        // Validate PR Provider (if configured)
+        if (process.env.PR_PROVIDER) {
+            results.push(await this.validatePRProvider());
+        }
+        this.printResults(results);
+        return results;
+    }
+    /**
+     * Validate AI provider configuration
+     */
+    static async validateAIProvider() {
+        const providerType = process.env.AI_PROVIDER || 'azure-openai';
+        try {
+            // Check if provider type is supported
+            if (!AIProviderFactory_1.AIProviderFactory.isProviderSupported(providerType)) {
+                return {
+                    provider: 'AI Provider',
+                    valid: false,
+                    configured: false,
+                    message: `Unsupported AI provider: ${providerType}`,
+                    details: { supportedProviders: AIProviderFactory_1.AIProviderFactory.getSupportedProviders() },
+                };
+            }
+            // Check provider-specific configuration
+            const configCheck = this.checkAIProviderConfig(providerType);
+            if (!configCheck.valid) {
+                return {
+                    provider: 'AI Provider',
+                    valid: false,
+                    configured: false,
+                    message: configCheck.message,
+                    details: configCheck.details,
+                };
+            }
+            // Try to initialize and test connection
+            const provider = await AIProviderFactory_1.AIProviderFactory.createProvider(providerType);
+            const connected = await provider.testConnection();
+            return {
+                provider: `AI Provider (${provider.getName()})`,
+                valid: true,
+                configured: true,
+                connected,
+                message: connected ? 'Successfully connected' : 'Configuration valid but connection failed',
+            };
+        }
+        catch (error) {
+            return {
+                provider: 'AI Provider',
+                valid: false,
+                configured: false,
+                message: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            };
+        }
+    }
+    /**
+     * Check AI provider specific configuration
+     */
+    static checkAIProviderConfig(providerType) {
+        const checks = {
+            'azure-openai': ['AZURE_OPENAI_ENDPOINT', 'AZURE_OPENAI_DEPLOYMENT_NAME'],
+            openai: ['OPENAI_API_KEY'],
+            anthropic: ['ANTHROPIC_API_KEY'],
+            'google-ai': ['GOOGLE_AI_API_KEY'],
+            mistral: ['MISTRAL_API_KEY'],
+        };
+        const requiredVars = checks[providerType] || [];
+        const missing = requiredVars.filter((v) => !process.env[v]);
+        if (missing.length > 0) {
+            return {
+                valid: false,
+                message: `Missing required environment variables: ${missing.join(', ')}`,
+                details: { required: requiredVars, missing },
+            };
+        }
+        return { valid: true, message: 'Configuration complete' };
+    }
+    /**
+     * Validate bug tracker configuration
+     */
+    static async validateBugTracker() {
+        const providerType = process.env.BUG_TRACKER_PROVIDER;
+        try {
+            if (!providerType) {
+                return {
+                    provider: 'Bug Tracker',
+                    valid: false,
+                    configured: false,
+                    message: 'BUG_TRACKER_PROVIDER not set',
+                };
+            }
+            const configCheck = this.checkBugTrackerConfig(providerType);
+            if (!configCheck.valid) {
+                return {
+                    provider: 'Bug Tracker',
+                    valid: false,
+                    configured: false,
+                    message: configCheck.message,
+                    details: configCheck.details,
+                };
+            }
+            // Try to initialize
+            const provider = await BugTrackerFactory_1.BugTrackerFactory.createProvider(providerType);
+            return {
+                provider: `Bug Tracker (${providerType})`,
+                valid: true,
+                configured: true,
+                message: 'Configuration valid',
+            };
+        }
+        catch (error) {
+            return {
+                provider: 'Bug Tracker',
+                valid: false,
+                configured: false,
+                message: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            };
+        }
+    }
+    /**
+     * Check bug tracker specific configuration
+     */
+    static checkBugTrackerConfig(providerType) {
+        const checks = {
+            'azure-devops': ['AZURE_DEVOPS_ORG_URL', 'AZURE_DEVOPS_PROJECT', 'AZURE_DEVOPS_PAT'],
+            github: ['GITHUB_TOKEN', 'GITHUB_OWNER', 'GITHUB_REPO'],
+            jira: ['JIRA_HOST', 'JIRA_EMAIL', 'JIRA_API_TOKEN', 'JIRA_PROJECT_KEY'],
+        };
+        const requiredVars = checks[providerType] || [];
+        const missing = requiredVars.filter((v) => !process.env[v]);
+        if (missing.length > 0) {
+            return {
+                valid: false,
+                message: `Missing required environment variables: ${missing.join(', ')}`,
+                details: { required: requiredVars, missing },
+            };
+        }
+        return { valid: true, message: 'Configuration complete' };
+    }
+    /**
+     * Validate database configuration
+     */
+    static async validateDatabase() {
+        const providerType = process.env.DATABASE_PROVIDER;
+        try {
+            if (!providerType) {
+                return {
+                    provider: 'Database',
+                    valid: false,
+                    configured: false,
+                    message: 'DATABASE_PROVIDER not set',
+                };
+            }
+            const configCheck = this.checkDatabaseConfig(providerType);
+            if (!configCheck.valid) {
+                return {
+                    provider: 'Database',
+                    valid: false,
+                    configured: false,
+                    message: configCheck.message,
+                    details: configCheck.details,
+                };
+            }
+            // Try to initialize
+            const provider = await DatabaseFactory_1.DatabaseFactory.createProvider(providerType);
+            await provider.close();
+            return {
+                provider: `Database (${providerType})`,
+                valid: true,
+                configured: true,
+                connected: true,
+                message: 'Successfully connected',
+            };
+        }
+        catch (error) {
+            return {
+                provider: 'Database',
+                valid: false,
+                configured: false,
+                message: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            };
+        }
+    }
+    /**
+     * Check database specific configuration
+     */
+    static checkDatabaseConfig(providerType) {
+        const checks = {
+            sqlite: [], // No required config for SQLite
+            mysql: ['MYSQL_HOST', 'MYSQL_USER', 'MYSQL_PASSWORD', 'MYSQL_DATABASE'],
+            postgresql: ['POSTGRES_HOST', 'POSTGRES_USER', 'POSTGRES_PASSWORD', 'POSTGRES_DATABASE'],
+        };
+        const requiredVars = checks[providerType] || [];
+        const missing = requiredVars.filter((v) => !process.env[v]);
+        if (missing.length > 0) {
+            return {
+                valid: false,
+                message: `Missing required environment variables: ${missing.join(', ')}`,
+                details: { required: requiredVars, missing },
+            };
+        }
+        return { valid: true, message: 'Configuration complete' };
+    }
+    /**
+     * Validate notification provider configuration
+     */
+    static async validateNotificationProvider() {
+        const providerType = process.env.NOTIFICATION_PROVIDER;
+        try {
+            if (!providerType) {
+                return {
+                    provider: 'Notification',
+                    valid: false,
+                    configured: false,
+                    message: 'NOTIFICATION_PROVIDER not set',
+                };
+            }
+            const configCheck = this.checkNotificationConfig(providerType);
+            if (!configCheck.valid) {
+                return {
+                    provider: 'Notification',
+                    valid: false,
+                    configured: false,
+                    message: configCheck.message,
+                    details: configCheck.details,
+                };
+            }
+            return {
+                provider: `Notification (${providerType})`,
+                valid: true,
+                configured: true,
+                message: 'Configuration valid',
+            };
+        }
+        catch (error) {
+            return {
+                provider: 'Notification',
+                valid: false,
+                configured: false,
+                message: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            };
+        }
+    }
+    /**
+     * Check notification provider specific configuration
+     */
+    static checkNotificationConfig(providerType) {
+        const checks = {
+            email: ['EMAIL_HOST', 'EMAIL_USER', 'EMAIL_PASSWORD', 'EMAIL_FROM'],
+            slack: ['SLACK_WEBHOOK_URL'],
+            teams: ['TEAMS_WEBHOOK_URL'],
+        };
+        const requiredVars = checks[providerType] || [];
+        const missing = requiredVars.filter((v) => !process.env[v]);
+        if (missing.length > 0) {
+            return {
+                valid: false,
+                message: `Missing required environment variables: ${missing.join(', ')}`,
+                details: { required: requiredVars, missing },
+            };
+        }
+        return { valid: true, message: 'Configuration complete' };
+    }
+    /**
+     * Validate PR provider configuration
+     */
+    static async validatePRProvider() {
+        const providerType = process.env.PR_PROVIDER;
+        try {
+            if (!providerType) {
+                return {
+                    provider: 'PR Provider',
+                    valid: false,
+                    configured: false,
+                    message: 'PR_PROVIDER not set',
+                };
+            }
+            const configCheck = this.checkPRProviderConfig(providerType);
+            if (!configCheck.valid) {
+                return {
+                    provider: 'PR Provider',
+                    valid: false,
+                    configured: false,
+                    message: configCheck.message,
+                    details: configCheck.details,
+                };
+            }
+            return {
+                provider: `PR Provider (${providerType})`,
+                valid: true,
+                configured: true,
+                message: 'Configuration valid',
+            };
+        }
+        catch (error) {
+            return {
+                provider: 'PR Provider',
+                valid: false,
+                configured: false,
+                message: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            };
+        }
+    }
+    /**
+     * Check PR provider specific configuration
+     */
+    static checkPRProviderConfig(providerType) {
+        const checks = {
+            github: ['GITHUB_TOKEN', 'GITHUB_OWNER', 'GITHUB_REPO'],
+            'azure-devops': ['AZURE_DEVOPS_ORG_URL', 'AZURE_DEVOPS_PROJECT', 'AZURE_DEVOPS_PAT'],
+        };
+        const requiredVars = checks[providerType] || [];
+        const missing = requiredVars.filter((v) => !process.env[v]);
+        if (missing.length > 0) {
+            return {
+                valid: false,
+                message: `Missing required environment variables: ${missing.join(', ')}`,
+                details: { required: requiredVars, missing },
+            };
+        }
+        return { valid: true, message: 'Configuration complete' };
+    }
+    /**
+     * Print validation results
+     */
+    static printResults(results) {
+        console.log('\n=== Validation Results ===\n');
+        let allValid = true;
+        results.forEach((result) => {
+            const status = result.valid ? '✓' : '✗';
+            const color = result.valid ? '\x1b[32m' : '\x1b[31m';
+            const reset = '\x1b[0m';
+            console.log(`${color}${status} ${result.provider}${reset}`);
+            console.log(`  ${result.message}`);
+            if (result.connected !== undefined) {
+                const connStatus = result.connected ? '✓ Connected' : '✗ Connection failed';
+                console.log(`  ${connStatus}`);
+            }
+            if (result.details) {
+                console.log(`  Details:`, result.details);
+            }
+            console.log('');
+            if (!result.valid) {
+                allValid = false;
+            }
+        });
+        if (allValid) {
+            console.log('\x1b[32m✓ All configured providers are valid!\x1b[0m\n');
+        }
+        else {
+            console.log('\x1b[31m✗ Some providers have configuration issues\x1b[0m\n');
+        }
+    }
+    /**
+     * Generate a configuration report
+     */
+    static async generateReport() {
+        const results = await this.validateAll();
+        let report = '# Provider Configuration Report\n\n';
+        report += `Generated: ${new Date().toISOString()}\n\n`;
+        report += '## Configured Providers\n\n';
+        results.forEach((result) => {
+            report += `### ${result.provider}\n\n`;
+            report += `- Status: ${result.valid ? 'Valid' : 'Invalid'}\n`;
+            report += `- Configured: ${result.configured ? 'Yes' : 'No'}\n`;
+            if (result.connected !== undefined) {
+                report += `- Connected: ${result.connected ? 'Yes' : 'No'}\n`;
+            }
+            report += `- Message: ${result.message}\n`;
+            if (result.details) {
+                report += `- Details: \`${JSON.stringify(result.details)}\`\n`;
+            }
+            report += '\n';
+        });
+        return report;
+    }
+}
+exports.ConfigValidator = ConfigValidator;
+// CLI usage
+if (require.main === module) {
+    ConfigValidator.validateAll()
+        .then(() => process.exit(0))
+        .catch((error) => {
+        console.error('Validation failed:', error);
+        process.exit(1);
+    });
+}

package/dist/utils/fileHandlerUtils.d.ts

@@ -0,0 +1,42 @@
+import { TestFailure, TestCaseDetails, TestSummary } from '../types';
+/**
+ * Handles writing test results to JSON files
+ */
+export declare class FileHandler {
+    private readonly failuresFilePath;
+    private readonly summaryFilePath;
+    private failuresBuffer;
+    private writeInterval;
+    private isBufferDirty;
+    /**
+     * Creates a new FileHandler instance
+     * @param outputDir - Directory where JSON files will be saved
+     */
+    constructor(outputDir?: string);
+    /**
+     * Adds a test failure to the failures file
+     * @param failure - The test failure to add
+     */
+    addFailure(failure: TestFailure): void;
+    /**
+     * Writes test summary and all test cases to files
+     * @param summary - Test run summary
+     * @param allTestCases - All test cases from the run
+     */
+    writeSummary(summary: TestSummary, allTestCases: TestCaseDetails[]): void;
+    /**
+     * Starts the periodic buffer flush
+     * @private
+     */
+    private startPeriodicFlush;
+    /**
+     * Stops the periodic buffer flush
+     * @private
+     */
+    private stopPeriodicFlush;
+    /**
+     * Flushes the failures buffer to disk
+     * @private
+     */
+    private flushFailuresBuffer;
+}

package/dist/utils/fileHandlerUtils.js

@@ -0,0 +1,136 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileHandler = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Handles writing test results to JSON files
+ */
+class FileHandler {
+    /**
+     * Creates a new FileHandler instance
+     * @param outputDir - Directory where JSON files will be saved
+     */
+    constructor(outputDir = './test-results') {
+        this.failuresBuffer = [];
+        this.writeInterval = null;
+        this.isBufferDirty = false;
+        // Ensure the output directory exists
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+        }
+        this.failuresFilePath = path.join(outputDir, 'testFailures.json');
+        this.summaryFilePath = path.join(outputDir, 'testSummary.json');
+        // Initialize failures file with empty array if it doesn't exist
+        if (!fs.existsSync(this.failuresFilePath)) {
+            fs.writeFileSync(this.failuresFilePath, JSON.stringify([], null, 2));
+        }
+        // Setup periodic flushing of the buffer (every 5 seconds)
+        this.startPeriodicFlush();
+    }
+    /**
+     * Adds a test failure to the failures file
+     * @param failure - The test failure to add
+     */
+    addFailure(failure) {
+        this.failuresBuffer.push(failure);
+        this.isBufferDirty = true;
+    }
+    /**
+     * Writes test summary and all test cases to files
+     * @param summary - Test run summary
+     * @param allTestCases - All test cases from the run
+     */
+    writeSummary(summary, allTestCases) {
+        const summaryWithTests = {
+            ...summary,
+            allTestCases,
+            timestamp: new Date().toISOString(),
+            runEnvironment: summary.buildInfo?.isPipeline ? 'Pipeline' : 'Local',
+        };
+        fs.writeFileSync(this.summaryFilePath, JSON.stringify(summaryWithTests, null, 2));
+        // Final flush of failures buffer
+        this.flushFailuresBuffer();
+        // Stop the periodic flush
+        this.stopPeriodicFlush();
+    }
+    /**
+     * Starts the periodic buffer flush
+     * @private
+     */
+    startPeriodicFlush() {
+        this.writeInterval = setInterval(() => {
+            this.flushFailuresBuffer();
+        }, 5000); // Flush every 5 seconds
+    }
+    /**
+     * Stops the periodic buffer flush
+     * @private
+     */
+    stopPeriodicFlush() {
+        if (this.writeInterval) {
+            clearInterval(this.writeInterval);
+            this.writeInterval = null;
+        }
+    }
+    /**
+     * Flushes the failures buffer to disk
+     * @private
+     */
+    flushFailuresBuffer() {
+        if (!this.isBufferDirty)
+            return;
+        try {
+            // Read existing failures
+            let existingFailures = [];
+            if (fs.existsSync(this.failuresFilePath)) {
+                const content = fs.readFileSync(this.failuresFilePath, 'utf8');
+                existingFailures = JSON.parse(content);
+            }
+            // Append new failures
+            const allFailures = [...existingFailures, ...this.failuresBuffer];
+            // Write back to file
+            fs.writeFileSync(this.failuresFilePath, JSON.stringify(allFailures, null, 2));
+            // Clear buffer
+            this.failuresBuffer = [];
+            this.isBufferDirty = false;
+        }
+        catch (error) {
+            console.error('Error writing failures to file:', error);
+        }
+    }
+}
+exports.FileHandler = FileHandler;

package/dist/utils/genaiUtils.d.ts

@@ -0,0 +1,38 @@
+import { TestFailure } from '../types';
+/**
+ * Utility for generating AI-powered suggestions for test failures
+ */
+export declare class GenAIUtils {
+    /**
+     * Calls the configured AI provider to get a suggestion for fixing a failed test
+     *
+     * @param prompt - The prompt to send to the AI
+     * @returns AI's suggested fix
+     */
+    static callGenAISuggestion(prompt: string): Promise<string>;
+    /**
+     * Generates a fix suggestion for a failed test
+     *
+     * @param failure - The test failure information
+     * @param sourceCode - Map of source code files for context
+     * @returns The path to the saved suggestion file
+     */
+    static generateFixSuggestion(failure: TestFailure, sourceCode: Map<string, string>): Promise<{
+        promptPath: string;
+        fixPath: string;
+    } | null>;
+    /**
+     * Truncates a stack trace to a reasonable length
+     *
+     * @param stack - The full stack trace
+     * @returns Truncated stack trace
+     */
+    private static truncateStackTrace;
+    /**
+     * Sanitizes a filename to be used in a file path
+     *
+     * @param filename - The filename to sanitize
+     * @returns Sanitized filename
+     */
+    private static sanitizeFilename;
+}