playwright-ai-reporter 0.0.4

package/dist/providers/ai/GoogleAIProvider.js

@@ -0,0 +1,154 @@
+"use strict";
+/**
+ * Google AI (Gemini) provider implementation
+ */
+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.GoogleAIProvider = void 0;
+const dotenv = __importStar(require("dotenv"));
+const path = __importStar(require("path"));
+dotenv.config({ path: path.resolve(process.cwd(), '.env') });
+class GoogleAIProvider {
+    constructor() {
+        this.apiKey = process.env.GOOGLE_AI_API_KEY || '';
+        this.baseUrl = process.env.GOOGLE_AI_BASE_URL || 'https://generativelanguage.googleapis.com/v1beta';
+        this.defaultModel = process.env.GOOGLE_AI_MODEL || 'gemini-pro';
+    }
+    getName() {
+        return 'Google AI';
+    }
+    async initialize() {
+        if (!this.apiKey) {
+            throw new Error('GOOGLE_AI_API_KEY is required for Google AI provider');
+        }
+    }
+    convertMessagesToGeminiFormat(messages) {
+        // Gemini has different format for messages
+        const systemMessage = messages.find((m) => m.role === 'system');
+        const conversationMessages = messages.filter((m) => m.role !== 'system');
+        const contents = conversationMessages.map((msg) => ({
+            role: msg.role === 'assistant' ? 'model' : 'user',
+            parts: [{ text: msg.content }],
+        }));
+        return {
+            systemInstruction: systemMessage ? { parts: [{ text: systemMessage.content }] } : undefined,
+            contents,
+        };
+    }
+    async generateCompletion(messages, config) {
+        const model = config?.model || this.defaultModel;
+        const url = `${this.baseUrl}/models/${model}:generateContent?key=${this.apiKey}`;
+        const geminiMessages = this.convertMessagesToGeminiFormat(messages);
+        const requestBody = {
+            ...geminiMessages,
+            generationConfig: {},
+        };
+        if (config) {
+            if (config.temperature !== undefined)
+                requestBody.generationConfig.temperature = config.temperature;
+            if (config.topP !== undefined)
+                requestBody.generationConfig.topP = config.topP;
+            if (config.maxTokens)
+                requestBody.generationConfig.maxOutputTokens = config.maxTokens;
+            if (config.responseFormat === 'json')
+                requestBody.generationConfig.responseMimeType = 'application/json';
+        }
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(requestBody),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Google AI API error (${response.status}): ${errorText}`);
+        }
+        const data = await response.json();
+        if (!data.candidates || data.candidates.length === 0) {
+            throw new Error('No candidates in Google AI response');
+        }
+        const candidate = data.candidates[0];
+        const text = candidate.content.parts[0].text;
+        return {
+            content: text,
+            usage: data.usageMetadata
+                ? {
+                    promptTokens: data.usageMetadata.promptTokenCount,
+                    completionTokens: data.usageMetadata.candidatesTokenCount,
+                    totalTokens: data.usageMetadata.totalTokenCount,
+                }
+                : undefined,
+            model: model,
+            finishReason: candidate.finishReason,
+        };
+    }
+    async generateText(prompt, config) {
+        const messages = [
+            {
+                role: 'system',
+                content: 'You are a helpful assistant.',
+            },
+            {
+                role: 'user',
+                content: prompt,
+            },
+        ];
+        const response = await this.generateCompletion(messages, config);
+        return response.content;
+    }
+    async testConnection() {
+        try {
+            const response = await this.generateText('Hello', { maxTokens: 10 });
+            return !!response;
+        }
+        catch (error) {
+            console.error('[GoogleAI] Connection test failed:', error);
+            return false;
+        }
+    }
+    async getAvailableModels() {
+        const url = `${this.baseUrl}/models?key=${this.apiKey}`;
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch models: ${response.status}`);
+        }
+        const data = await response.json();
+        return data.models
+            .filter((model) => model.supportedGenerationMethods.includes('generateContent'))
+            .map((model) => model.name.replace('models/', ''));
+    }
+}
+exports.GoogleAIProvider = GoogleAIProvider;

package/dist/providers/ai/MistralProvider.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Mistral AI provider implementation
+ */
+import { IAIProvider, AIMessage, AIModelConfig, AIResponse } from '../interfaces/IAIProvider';
+export declare class MistralProvider implements IAIProvider {
+    private apiKey;
+    private baseUrl;
+    private defaultModel;
+    constructor();
+    getName(): string;
+    initialize(): Promise<void>;
+    generateCompletion(messages: AIMessage[], config?: AIModelConfig): Promise<AIResponse>;
+    generateText(prompt: string, config?: AIModelConfig): Promise<string>;
+    testConnection(): Promise<boolean>;
+    getAvailableModels(): Promise<string[]>;
+}

package/dist/providers/ai/MistralProvider.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * Mistral AI provider implementation
+ */
+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.MistralProvider = void 0;
+const dotenv = __importStar(require("dotenv"));
+const path = __importStar(require("path"));
+dotenv.config({ path: path.resolve(process.cwd(), '.env') });
+class MistralProvider {
+    constructor() {
+        this.apiKey = process.env.MISTRAL_API_KEY || '';
+        this.baseUrl = process.env.MISTRAL_BASE_URL || 'https://api.mistral.ai/v1';
+        this.defaultModel = process.env.MISTRAL_MODEL || 'mistral-large-latest';
+    }
+    getName() {
+        return 'Mistral AI';
+    }
+    async initialize() {
+        if (!this.apiKey) {
+            throw new Error('MISTRAL_API_KEY is required for Mistral provider');
+        }
+    }
+    async generateCompletion(messages, config) {
+        const url = `${this.baseUrl}/chat/completions`;
+        const requestBody = {
+            model: config?.model || this.defaultModel,
+            messages: messages,
+        };
+        if (config) {
+            if (config.maxTokens)
+                requestBody.max_tokens = config.maxTokens;
+            if (config.temperature !== undefined)
+                requestBody.temperature = config.temperature;
+            if (config.topP !== undefined)
+                requestBody.top_p = config.topP;
+            if (config.responseFormat === 'json')
+                requestBody.response_format = { type: 'json_object' };
+        }
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(requestBody),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Mistral API error (${response.status}): ${errorText}`);
+        }
+        const data = await response.json();
+        return {
+            content: data.choices[0].message.content,
+            usage: data.usage
+                ? {
+                    promptTokens: data.usage.prompt_tokens,
+                    completionTokens: data.usage.completion_tokens,
+                    totalTokens: data.usage.total_tokens,
+                }
+                : undefined,
+            model: data.model,
+            finishReason: data.choices[0].finish_reason,
+        };
+    }
+    async generateText(prompt, config) {
+        const messages = [
+            {
+                role: 'system',
+                content: 'You are a helpful assistant.',
+            },
+            {
+                role: 'user',
+                content: prompt,
+            },
+        ];
+        const response = await this.generateCompletion(messages, config);
+        return response.content;
+    }
+    async testConnection() {
+        try {
+            const response = await this.generateText('Hello', { maxTokens: 10 });
+            return !!response;
+        }
+        catch (error) {
+            console.error('[Mistral] Connection test failed:', error);
+            return false;
+        }
+    }
+    async getAvailableModels() {
+        const url = `${this.baseUrl}/models`;
+        const response = await fetch(url, {
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch models: ${response.status}`);
+        }
+        const data = await response.json();
+        return data.data.map((model) => model.id);
+    }
+}
+exports.MistralProvider = MistralProvider;

package/dist/providers/ai/OpenAIProvider.d.ts

@@ -0,0 +1,16 @@
+/**
+ * OpenAI provider implementation using AI SDK
+ */
+import { IAIProvider, AIMessage, AIModelConfig, AIResponse } from '../interfaces/IAIProvider';
+export declare class OpenAIProvider implements IAIProvider {
+    private apiKey;
+    private baseUrl;
+    private defaultModel;
+    constructor();
+    getName(): string;
+    initialize(): Promise<void>;
+    generateCompletion(messages: AIMessage[], config?: AIModelConfig): Promise<AIResponse>;
+    generateText(prompt: string, config?: AIModelConfig): Promise<string>;
+    testConnection(): Promise<boolean>;
+    getAvailableModels(): Promise<string[]>;
+}

package/dist/providers/ai/OpenAIProvider.js

@@ -0,0 +1,141 @@
+"use strict";
+/**
+ * OpenAI provider implementation using AI SDK
+ */
+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.OpenAIProvider = void 0;
+const dotenv = __importStar(require("dotenv"));
+const path = __importStar(require("path"));
+dotenv.config({ path: path.resolve(process.cwd(), '.env') });
+class OpenAIProvider {
+    constructor() {
+        this.apiKey = process.env.OPENAI_API_KEY || '';
+        this.baseUrl = process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1';
+        this.defaultModel = process.env.OPENAI_MODEL || 'gpt-4o';
+    }
+    getName() {
+        return 'OpenAI';
+    }
+    async initialize() {
+        if (!this.apiKey) {
+            throw new Error('OPENAI_API_KEY is required for OpenAI provider');
+        }
+    }
+    async generateCompletion(messages, config) {
+        const url = `${this.baseUrl}/chat/completions`;
+        const requestBody = {
+            model: config?.model || this.defaultModel,
+            messages: messages,
+        };
+        if (config) {
+            if (config.maxTokens)
+                requestBody.max_tokens = config.maxTokens;
+            if (config.temperature !== undefined)
+                requestBody.temperature = config.temperature;
+            if (config.topP !== undefined)
+                requestBody.top_p = config.topP;
+            if (config.frequencyPenalty !== undefined)
+                requestBody.frequency_penalty = config.frequencyPenalty;
+            if (config.presencePenalty !== undefined)
+                requestBody.presence_penalty = config.presencePenalty;
+            if (config.responseFormat === 'json')
+                requestBody.response_format = { type: 'json_object' };
+        }
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(requestBody),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`OpenAI API error (${response.status}): ${errorText}`);
+        }
+        const data = await response.json();
+        return {
+            content: data.choices[0].message.content,
+            usage: data.usage
+                ? {
+                    promptTokens: data.usage.prompt_tokens,
+                    completionTokens: data.usage.completion_tokens,
+                    totalTokens: data.usage.total_tokens,
+                }
+                : undefined,
+            model: data.model,
+            finishReason: data.choices[0].finish_reason,
+        };
+    }
+    async generateText(prompt, config) {
+        const messages = [
+            {
+                role: 'system',
+                content: 'You are a helpful assistant.',
+            },
+            {
+                role: 'user',
+                content: prompt,
+            },
+        ];
+        const response = await this.generateCompletion(messages, config);
+        return response.content;
+    }
+    async testConnection() {
+        try {
+            const response = await this.generateText('Hello', { maxTokens: 10 });
+            return !!response;
+        }
+        catch (error) {
+            console.error('[OpenAI] Connection test failed:', error);
+            return false;
+        }
+    }
+    async getAvailableModels() {
+        const url = `${this.baseUrl}/models`;
+        const response = await fetch(url, {
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch models: ${response.status}`);
+        }
+        const data = await response.json();
+        return data.data.map((model) => model.id);
+    }
+}
+exports.OpenAIProvider = OpenAIProvider;

package/dist/providers/bugTrackers/AzureDevOpsBugTracker.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Azure DevOps Bug Tracker Provider
+ */
+import { IBugTrackerProvider, BugDetails, BugInfo, BugStatus } from '../interfaces/IBugTrackerProvider';
+export interface AzureDevOpsConfig {
+    organizationUrl: string;
+    project: string;
+    personalAccessToken: string;
+    areaPath?: string;
+    iterationPath?: string;
+    tags?: string[];
+}
+export declare class AzureDevOpsBugTracker implements IBugTrackerProvider {
+    private webApi;
+    private config;
+    constructor(config: AzureDevOpsConfig);
+    private getWebApi;
+    createBug(bugDetails: BugDetails): Promise<BugInfo | null>;
+    updateBug(bugId: string, updates: Partial<BugDetails>): Promise<BugInfo | null>;
+    closeBug(bugId: string, comment?: string): Promise<BugInfo | null>;
+    findBugs(query: {
+        title?: string;
+        labels?: string[];
+        status?: BugStatus;
+    }): Promise<BugInfo[]>;
+    addComment(bugId: string, comment: string): Promise<boolean>;
+    private formatReproSteps;
+    private escapeHtml;
+    private mapPriorityToAdo;
+    private mapAdoStateToStatus;
+    private mapStatusToAdoState;
+}