playwright-ai-reporter 0.0.4

package/dist/utils/genaiUtils.js

@@ -0,0 +1,178 @@
+"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.GenAIUtils = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const dotenv = __importStar(require("dotenv"));
+const ProviderRegistry_1 = require("../providers/ProviderRegistry");
+// Load environment variables from .env file
+dotenv.config({ path: path.resolve(process.cwd(), '.env') });
+/**
+ * Utility for generating AI-powered suggestions for test failures
+ */
+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 async callGenAISuggestion(prompt) {
+        try {
+            const provider = await ProviderRegistry_1.ProviderRegistry.getAIProvider();
+            console.log(`[GenAI] Using AI provider: ${provider.getName()}`);
+            const messages = [
+                {
+                    role: 'system',
+                    content: 'You are a test engineer helping debug flaky Playwright tests.',
+                },
+                {
+                    role: 'user',
+                    content: prompt,
+                },
+            ];
+            const response = await provider.generateCompletion(messages, {
+                maxTokens: 1000,
+                temperature: 0.7,
+            });
+            return response.content;
+        }
+        catch (error) {
+            console.error('[GenAI] Error calling AI provider:', error);
+            return `Error retrieving suggestion from AI provider: ${error instanceof Error ? error.message : 'Unknown error'}`;
+        }
+    }
+    /**
+     * 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 async generateFixSuggestion(failure, sourceCode) {
+        if (!failure.testFile) {
+            console.warn(`[GenAI] Cannot generate fix for test without file path: ${failure.testTitle}`);
+            return null;
+        }
+        try {
+            // Ensure the prompt and fixes directories exist
+            const promptDir = path.join(process.cwd(), 'test-results', 'prompts');
+            const fixesDir = path.join(process.cwd(), 'test-results', 'fixes');
+            fs.mkdirSync(promptDir, { recursive: true });
+            fs.mkdirSync(fixesDir, { recursive: true });
+            // Read the source file content if not already in cache
+            let source = sourceCode.get(failure.testFile);
+            if (!source) {
+                source = fs.readFileSync(failure.testFile, 'utf8');
+                sourceCode.set(failure.testFile, source);
+            }
+            // Create the prompt
+            const promptContent = [
+                `# Instructions`,
+                '',
+                `- The following Playwright test failed.`,
+                `- Explain why it failed and suggest a fix, respecting Playwright best practices.`,
+                `- Be concise and provide a code snippet with the fix.`,
+                '',
+                `# Test info`,
+                '',
+                `- Name: ${failure.testTitle}`,
+                `- File: ${failure.testFile}`,
+                `- Line: ${failure.location?.line || 'unknown'}`,
+                `- Column: ${failure.location?.column || 'unknown'}`,
+                '',
+                '# Error details',
+                '',
+                '```',
+                failure.errorMessage,
+                '```',
+                '',
+                '# Stack trace',
+                '',
+                '```',
+                this.truncateStackTrace(failure.errorStack),
+                '```',
+                '',
+                '# Test source',
+                '',
+                '```ts',
+                source,
+                '```',
+            ].join('\n');
+            // Generate a clean filename for the test
+            const safeFilename = this.sanitizeFilename(failure.testId ? `${failure.testId}` : `${path.basename(failure.testFile, '.ts')}-${failure.testTitle}`);
+            // Save the prompt
+            const promptPath = path.join(promptDir, `${safeFilename}.md`);
+            fs.writeFileSync(promptPath, promptContent, 'utf8');
+            // Call AI for the fix suggestion
+            const suggestion = await this.callGenAISuggestion(promptContent);
+            // Save the suggestion
+            const fixPath = path.join(fixesDir, `fix-${safeFilename}.md`);
+            fs.writeFileSync(fixPath, suggestion, 'utf8');
+            return { promptPath, fixPath };
+        }
+        catch (error) {
+            console.error('[GenAI] Error generating fix suggestion:', error);
+            return null;
+        }
+    }
+    /**
+     * Truncates a stack trace to a reasonable length
+     *
+     * @param stack - The full stack trace
+     * @returns Truncated stack trace
+     */
+    static truncateStackTrace(stack) {
+        if (!stack)
+            return '';
+        const lines = stack.split('\n');
+        // Return first 15 lines max to keep the context reasonable
+        return lines.slice(0, 15).join('\n') + (lines.length > 15 ? '\n... (truncated)' : '');
+    }
+    /**
+     * Sanitizes a filename to be used in a file path
+     *
+     * @param filename - The filename to sanitize
+     * @returns Sanitized filename
+     */
+    static sanitizeFilename(filename) {
+        return filename
+            .replace(/[\\/:*?"<>|]/g, '_')
+            .replace(/\s+/g, '-')
+            .substring(0, 100); // Limit length
+    }
+}
+exports.GenAIUtils = GenAIUtils;

package/dist/utils/historyUtils.d.ts

@@ -0,0 +1,49 @@
+import { TestFailure } from '../types';
+/**
+ * Interface for the last run information
+ */
+interface LastRunInfo {
+    status: string;
+    failedTests: string[];
+}
+/**
+ * Interface for test failure history item
+ */
+interface TestFailureHistory extends TestFailure {
+    timestamp?: string;
+}
+/**
+ * Utility functions for working with test history
+ */
+export declare class HistoryUtils {
+    /**
+     * Retrieves information about the last test run
+     * @param outputDir - Directory where test results are stored
+     * @returns Information about the last test run, or null if not available
+     */
+    static getLastRunInfo(outputDir?: string): LastRunInfo | null;
+    /**
+     * Checks if a particular test was failing in the previous run
+     * @param testId - ID of the test to check
+     * @param outputDir - Directory where test results are stored
+     * @returns True if the test was failing in the previous run, false otherwise
+     */
+    static wasTestFailingPreviously(testId: string, outputDir?: string): boolean;
+    /**
+     * Compares current test failures with previous run failures to identify new and fixed tests
+     * @param currentFailures - List of currently failed test IDs
+     * @param outputDir - Directory where test results are stored
+     * @returns Object with lists of newly failing and fixed tests
+     */
+    static compareWithPreviousRun(currentFailures: string[], outputDir?: string): {
+        newlyFailing: string[];
+        fixed: string[];
+    };
+    /**
+     * Gets the full test failure history
+     * @param outputDir - Directory where test results are stored
+     * @returns Array of test failures with timestamps
+     */
+    static getTestFailureHistory(outputDir?: string): TestFailureHistory[];
+}
+export {};

package/dist/utils/historyUtils.js

@@ -0,0 +1,118 @@
+"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.HistoryUtils = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Utility functions for working with test history
+ */
+class HistoryUtils {
+    /**
+     * Retrieves information about the last test run
+     * @param outputDir - Directory where test results are stored
+     * @returns Information about the last test run, or null if not available
+     */
+    static getLastRunInfo(outputDir = './test-results') {
+        try {
+            const lastRunFilePath = path.join(outputDir, '.last-run.json');
+            if (!fs.existsSync(lastRunFilePath)) {
+                return null;
+            }
+            const content = fs.readFileSync(lastRunFilePath, 'utf8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            console.error('Error reading last run information:', error);
+            return null;
+        }
+    }
+    /**
+     * Checks if a particular test was failing in the previous run
+     * @param testId - ID of the test to check
+     * @param outputDir - Directory where test results are stored
+     * @returns True if the test was failing in the previous run, false otherwise
+     */
+    static wasTestFailingPreviously(testId, outputDir = './test-results') {
+        const lastRunInfo = this.getLastRunInfo(outputDir);
+        if (!lastRunInfo) {
+            return false;
+        }
+        return lastRunInfo.failedTests.includes(testId);
+    }
+    /**
+     * Compares current test failures with previous run failures to identify new and fixed tests
+     * @param currentFailures - List of currently failed test IDs
+     * @param outputDir - Directory where test results are stored
+     * @returns Object with lists of newly failing and fixed tests
+     */
+    static compareWithPreviousRun(currentFailures, outputDir = './test-results') {
+        const lastRunInfo = this.getLastRunInfo(outputDir);
+        if (!lastRunInfo) {
+            // No previous run data available, all current failures are new
+            return {
+                newlyFailing: currentFailures,
+                fixed: [],
+            };
+        }
+        const previousFailures = lastRunInfo.failedTests || [];
+        return {
+            // Tests failing now but not in previous run
+            newlyFailing: currentFailures.filter((id) => !previousFailures.includes(id)),
+            // Tests that were failing before but now passing
+            fixed: previousFailures.filter((id) => !currentFailures.includes(id)),
+        };
+    }
+    /**
+     * Gets the full test failure history
+     * @param outputDir - Directory where test results are stored
+     * @returns Array of test failures with timestamps
+     */
+    static getTestFailureHistory(outputDir = './test-results') {
+        try {
+            const failuresFilePath = path.join(outputDir, 'testFailures.json');
+            if (!fs.existsSync(failuresFilePath)) {
+                return [];
+            }
+            const content = fs.readFileSync(failuresFilePath, 'utf8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            console.error('Error reading test failure history:', error);
+            return [];
+        }
+    }
+}
+exports.HistoryUtils = HistoryUtils;

package/dist/utils/utils.d.ts

@@ -0,0 +1,104 @@
+import { TestRecord, TestSummary, SlowTest, TestFailure, BuildInfo } from '../types';
+import { TestCase } from '@playwright/test/reporter';
+/**
+ * Utility class containing static methods for test result processing and calculations.
+ * Provides functionality for formatting time, calculating statistics, and processing test results.
+ */
+export declare class TestUtils {
+    /**
+     * Formats a time duration from seconds into a human-readable string.
+     * Converts to minutes if the duration is longer than 60 seconds.
+     *
+     * @param timeInSeconds - The time duration to format in seconds
+     * @returns A formatted string with appropriate units (e.g., "1.23s" or "2.50min")
+     */
+    static formatTime(timeInSeconds: number): string;
+    /**
+     * Calculates the average duration from an array of time measurements.
+     *
+     * @param durations - Array of durations in seconds
+     * @returns The average duration in seconds, or 0 if the array is empty
+     */
+    static calculateAverageTime(durations: number[]): number;
+    /**
+     * Finds the slowest tests from all test records.
+     * Only considers passed tests when calculating the slowest ones.
+     *
+     * @param testRecords - Map of all test records
+     * @param limit - Maximum number of slow tests to return
+     * @returns Array of the slowest tests, sorted by duration
+     */
+    static findSlowestTests(testRecords: Map<string, TestRecord>, limit: number): SlowTest[];
+    /**
+     * Categorizes the error message into predefined types
+     * @param message - Error message
+     * @returns Error category
+     */
+    static categorizeError(message: string): string;
+    /**
+     * Convert test outcome to status
+     * @param outcome - Test outcome
+     * @returns Standardized status
+     */
+    static outcomeToStatus(outcome: string): string;
+    /**
+     * Determines the team that owns a test based on test name and annotations
+     * @param test - Test case to analyze
+     * @returns Name of the team that owns the test
+     */
+    static getOwningTeam(test: TestCase): string;
+    /**
+     * Helper method to wrap a string for team name matching
+     * @param text - Text to wrap
+     * @returns Wrapped text
+     */
+    private static wrap;
+    /**
+     * Processes all test records to generate comprehensive test results.
+     * Calculates passed, failed, and skipped test counts, and collects timing information.
+     *
+     * @param testRecords - Map of all test records
+     * @returns Object containing test counts, failures, and timing information
+     */
+    static processTestResults(testRecords: Map<string, TestRecord>): {
+        passedCount: number;
+        testCount: number;
+        skippedCount: number;
+        failedCount: number;
+        failures: TestFailure[];
+        passedDurations: number[];
+    };
+}
+/**
+ * Logger class responsible for formatting and outputting test results.
+ * Provides methods for logging test summaries, metrics, and failures with appropriate formatting.
+ */
+export declare class Logger {
+    /**
+     * Logs the overall test run summary with appropriate coloring.
+     * Includes total tests, passed tests, skipped tests, and total time.
+     *
+     * @param summary - The test summary to log
+     */
+    static logSummary(summary: TestSummary): void;
+    /**
+     * Logs build information if available
+     *
+     * @param buildInfo - The build information to log
+     */
+    static logBuildInfo(buildInfo: BuildInfo): void;
+    /**
+     * Logs detailed metrics about the test run.
+     * Includes average test time and information about slow tests.
+     *
+     * @param summary - The test summary containing metrics to log
+     */
+    static logMetrics(summary: TestSummary): void;
+    /**
+     * Logs detailed information about test failures.
+     * Includes test title, stack trace, and timeout information.
+     *
+     * @param failures - Array of test failures to log
+     */
+    static logFailures(failures: TestFailure[]): void;
+}