qa360 2.1.7 → 2.2.0

package/dist/core/ai/provider-factory.js

@@ -1,269 +0,0 @@
-/**
- * LLM Provider Factory
- *
- * Factory pattern for creating LLM providers with automatic fallback.
- * Tries providers in order: Ollama → OpenAI → Anthropic → Mock.
- *
- * Usage:
- *   const provider = await createLLMProvider();
- *   // Returns first available provider
- */
-import { createOllamaProvider } from './index.js';
-import { createOpenAIProvider } from './openai-provider.js';
-import { createAnthropicProvider } from './anthropic-provider.js';
-import { createDeepSeekProvider } from './deepseek-provider.js';
-import { createStandardMockProvider } from './mock-provider.js';
-/**
- * Provider priority order for fallback
- * DeepSeek (best value) → Ollama (local, free) → OpenAI → Anthropic → Mock (always available)
- */
-export const PROVIDER_CHAIN = [
-    'deepseek',
-    'ollama',
-    'openai',
-    'anthropic',
-    'mock'
-];
-/**
- * Fallback provider that wraps the selected provider
- */
-export class FallbackProvider {
-    name = 'fallback';
-    models = [];
-    provider;
-    providerType;
-    constructor(provider, providerType) {
-        this.provider = provider;
-        this.providerType = providerType;
-        this.name = `fallback-${providerType}`;
-        this.models = provider.models;
-    }
-    async isAvailable() {
-        return this.provider.isAvailable();
-    }
-    async generate(request) {
-        return this.provider.generate(request);
-    }
-    async *stream(request) {
-        if (this.provider.stream) {
-            yield* this.provider.stream(request);
-        }
-        else {
-            // Fallback to generate if stream not supported
-            const response = await this.provider.generate(request);
-            yield response.content;
-        }
-    }
-    countTokens(text) {
-        return this.provider.countTokens(text);
-    }
-    /**
-     * Get the underlying provider type
-     */
-    getProviderType() {
-        return this.providerType;
-    }
-}
-/**
- * Check availability of a provider without creating it
- */
-async function checkProviderAvailability(type, config) {
-    try {
-        switch (type) {
-            case 'deepseek':
-                return await createDeepSeekProvider(config.deepseek).isAvailable();
-            case 'ollama':
-                return await createOllamaProvider(config.ollama).isAvailable();
-            case 'openai':
-                return await createOpenAIProvider(config.openai).isAvailable();
-            case 'anthropic':
-                return await createAnthropicProvider(config.anthropic).isAvailable();
-            case 'mock':
-                return true; // Mock is always available
-            default:
-                return false;
-        }
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Create provider instance by type
- */
-function createProviderByType(type, config) {
-    switch (type) {
-        case 'deepseek':
-            return createDeepSeekProvider(config.deepseek);
-        case 'ollama':
-            return createOllamaProvider(config.ollama);
-        case 'openai':
-            return createOpenAIProvider(config.openai);
-        case 'anthropic':
-            return createAnthropicProvider(config.anthropic);
-        case 'mock':
-            return createStandardMockProvider();
-        default:
-            throw new Error(`Unknown provider type: ${type}`);
-    }
-}
-/**
- * Create LLM provider with automatic fallback
- *
- * Tries providers in order until one is available.
- * Logs which provider was selected and why.
- */
-export async function createLLMProvider(config = {}) {
-    const chain = config.chain || PROVIDER_CHAIN;
-    const skip = config.skip || [];
-    // Build the actual chain to try (respect skip list and preferred order)
-    let tryChain = [];
-    if (config.preferred && !skip.includes(config.preferred)) {
-        // Try preferred first, then the rest
-        tryChain = [config.preferred];
-        tryChain.push(...chain.filter(p => p !== config.preferred && !skip.includes(p)));
-    }
-    else {
-        tryChain = chain.filter(p => !skip.includes(p));
-    }
-    // Ensure mock is always available as last resort
-    if (!tryChain.includes('mock')) {
-        tryChain.push('mock');
-    }
-    const skipped = [];
-    // Try each provider in order
-    for (const type of tryChain) {
-        if (skip.includes(type)) {
-            skipped.push(type);
-            continue;
-        }
-        const isAvailable = await checkProviderAvailability(type, config);
-        if (isAvailable) {
-            const provider = createProviderByType(type, config);
-            let reason = `Selected ${type}`;
-            if (type === 'mock' && tryChain.length > 1) {
-                reason = 'No other providers available, using mock';
-            }
-            else if (skipped.length > 0) {
-                reason = `${type} (skipped: ${skipped.join(', ')})`;
-            }
-            return new FallbackProvider(provider, type);
-        }
-        skipped.push(type);
-    }
-    // Should never reach here since mock is always available
-    throw new Error('No LLM provider available (even mock failed)');
-}
-/**
- * Get provider availability status for all providers
- */
-export async function getProviderStatus(config = {}) {
-    const status = {};
-    for (const type of PROVIDER_CHAIN) {
-        status[type] = await checkProviderAvailability(type, config);
-    }
-    return status;
-}
-/**
- * Auto-detect best available provider
- * Priority: DeepSeek (best value) → Ollama (free local) → OpenAI → Anthropic → Mock
- */
-export async function detectBestProvider(config = {}) {
-    const status = await getProviderStatus(config);
-    // Priority: DeepSeek > Ollama > OpenAI > Anthropic > Mock
-    if (status.deepseek)
-        return 'deepseek';
-    if (status.ollama)
-        return 'ollama';
-    if (status.openai)
-        return 'openai';
-    if (status.anthropic)
-        return 'anthropic';
-    return 'mock';
-}
-/**
- * Create the best available provider automatically
- * This is the recommended way to get a provider for most use cases.
- *
- * Selection criteria:
- * 1. DeepSeek - Best value, GPT-4 level at 95% lower cost
- * 2. Ollama - Free, local, privacy-preserving
- * 3. OpenAI - Reliable, widely-used
- * 4. Anthropic - High quality, Claude models
- * 5. Mock - Fallback for testing
- *
- * @example
- * const provider = await createBest();
- * const response = await provider.generate({
- *   prompt: 'Generate tests for login form'
- * });
- */
-export async function createBest(config = {}) {
-    const providerType = await detectBestProvider(config);
-    const provider = createProviderByType(providerType, config);
-    return new FallbackProvider(provider, providerType);
-}
-export async function getProviderInfo(config = {}) {
-    const status = await getProviderStatus(config);
-    return [
-        {
-            type: 'deepseek',
-            name: 'DeepSeek',
-            available: status.deepseek,
-            description: 'GPT-4 level performance at 95% lower cost',
-            costLevel: 'low',
-            capabilities: ['code-generation', 'test-generation', 'analysis', 'chat']
-        },
-        {
-            type: 'ollama',
-            name: 'Ollama',
-            available: status.ollama,
-            description: 'Local LLM inference, 100% free',
-            costLevel: 'free',
-            capabilities: ['code-generation', 'test-generation', 'offline', 'privacy']
-        },
-        {
-            type: 'openai',
-            name: 'OpenAI',
-            available: status.openai,
-            description: 'GPT-4, GPT-4 Turbo, reliable API',
-            costLevel: 'high',
-            capabilities: ['code-generation', 'test-generation', 'analysis', 'chat']
-        },
-        {
-            type: 'anthropic',
-            name: 'Anthropic',
-            available: status.anthropic,
-            description: 'Claude models, high quality outputs',
-            costLevel: 'high',
-            capabilities: ['code-generation', 'test-generation', 'analysis', 'chat']
-        },
-        {
-            type: 'mock',
-            name: 'Mock',
-            available: true,
-            description: 'Mock provider for testing',
-            costLevel: 'free',
-            capabilities: ['testing', 'mocking']
-        }
-    ];
-}
-/**
- * Create provider with automatic retry on failure
- *
- * If the selected provider fails, automatically falls back
- * to the next available provider in the chain.
- */
-export async function createResilientLLMProvider(config = {}) {
-    const provider = await createLLMProvider(config);
-    // Wrap with retry logic could be added here
-    // For now, return the standard fallback provider
-    return provider;
-}
-/**
- * Quick check if any LLM provider is available
- */
-export async function hasAnyProvider(config = {}) {
-    const status = await getProviderStatus(config);
-    return Object.values(status).some(v => v);
-}

package/dist/core/artifacts/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * QA360 Artifacts Module
- *
- * Manages screenshots, videos, traces, and other test artifacts
- */
-export { UIArtifactsManager, createUIArtifactsManager, type ScreenshotOptions, type ArtifactMetadata, type StoredArtifact, type VideoArtifact, type ScreenshotArtifact, type TraceArtifact, } from './ui-artifacts.js';

package/dist/core/artifacts/index.js

@@ -1,6 +0,0 @@
-/**
- * QA360 Artifacts Module
- *
- * Manages screenshots, videos, traces, and other test artifacts
- */
-export { UIArtifactsManager, createUIArtifactsManager, } from './ui-artifacts.js';

package/dist/core/artifacts/ui-artifacts.d.ts

@@ -1,133 +0,0 @@
-/**
- * QA360 UI Artifacts Manager
- *
- * Manages screenshots, videos, traces, and other test artifacts
- * with content-addressable storage (CAS) integration
- */
-export type ScreenshotFormat = 'png' | 'jpeg' | 'webp';
-export interface ScreenshotOptions {
-    fullPage?: boolean;
-    quality?: number;
-    type?: ScreenshotFormat;
-    animations?: 'disabled' | 'allow';
-}
-export interface ArtifactMetadata {
-    testId: string;
-    stepIndex?: number;
-    stepName?: string;
-    type: 'screenshot' | 'video' | 'trace' | 'network' | 'console' | 'coverage';
-    timestamp: string;
-    status?: 'passed' | 'failed' | 'flaky';
-    tags?: string[];
-}
-export interface StoredArtifact {
-    casPath: string;
-    localPath: string;
-    hash: string;
-    metadata: ArtifactMetadata;
-    size: number;
-    type: 'screenshot' | 'video' | 'trace' | 'network' | 'console' | 'coverage';
-}
-export interface VideoArtifact extends StoredArtifact {
-    type: 'video';
-    format: 'webm';
-    duration: number;
-}
-export interface ScreenshotArtifact extends StoredArtifact {
-    type: 'screenshot';
-    format: ScreenshotFormat;
-    width: number;
-    height: number;
-}
-export interface TraceArtifact extends StoredArtifact {
-    type: 'trace';
-    format: 'zip';
-}
-/**
- * UI Artifacts Manager
- *
- * Handles:
- * - Automatic screenshots (before/after steps, on error)
- * - Video recording
- * - Trace files
- * - Network captures
- * - Console logs
- * - Storage in CAS for deduplication
- */
-export declare class UIArtifactsManager {
-    private artifactDir;
-    private casDir;
-    private currentRunId;
-    private currentTestId?;
-    private artifacts;
-    private cas;
-    constructor(artifactDir?: string, casDir?: string);
-    private ensureDirectories;
-    /**
-     * Start a new test session
-     */
-    startTest(testId: string): void;
-    /**
-     * End current test session
-     */
-    endTest(): void;
-    /**
-     * Take a screenshot and store it
-     */
-    takeScreenshot(page: any, // Playwright Page
-    options?: ScreenshotOptions, metadata?: Partial<ArtifactMetadata>): Promise<ScreenshotArtifact>;
-    /**
-     * Take screenshot before a step
-     */
-    takeBeforeScreenshot(page: any, stepName: string, stepIndex: number): Promise<ScreenshotArtifact>;
-    /**
-     * Take screenshot after a step
-     */
-    takeAfterScreenshot(page: any, stepName: string, stepIndex: number, success: boolean): Promise<ScreenshotArtifact>;
-    /**
-     * Take screenshot on error
-     */
-    takeErrorScreenshot(page: any, error: Error, stepName?: string): Promise<ScreenshotArtifact>;
-    /**
-     * Save video artifact
-     */
-    saveVideo(videoPath: string, metadata?: Partial<ArtifactMetadata>): Promise<VideoArtifact>;
-    /**
-     * Save trace artifact
-     */
-    saveTrace(tracePath: string, metadata?: Partial<ArtifactMetadata>): Promise<TraceArtifact>;
-    /**
-     * Get artifact by ID
-     */
-    getArtifact(id: string): StoredArtifact | undefined;
-    /**
-     * Get all artifacts for current test
-     */
-    getTestArtifacts(): StoredArtifact[];
-    /**
-     * Get all artifacts by type
-     */
-    getArtifactsByType(type: StoredArtifact['type']): StoredArtifact[];
-    /**
-     * Clean up old artifacts
-     */
-    cleanup(maxAge?: number): void;
-    /**
-     * Generate CAS path from hash
-     */
-    private getCasPath;
-    /**
-     * Generate artifacts summary for reporting
-     */
-    generateSummary(): {
-        screenshots: number;
-        videos: number;
-        traces: number;
-        totalSize: number;
-        casDedupSavings: number;
-    };
-}
-/**
- * Create a UI artifacts manager
- */
-export declare function createUIArtifactsManager(artifactDir?: string, casDir?: string): UIArtifactsManager;