qa360 1.4.5 → 2.0.1

package/dist/core/ai/provider-factory.d.ts

@@ -0,0 +1,160 @@
+/**
+ * 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 type { LLMProvider, GenerationRequest, GenerationResponse } from './index.js';
+/**
+ * Provider priority order for fallback
+ * DeepSeek (best value) → Ollama (local, free) → OpenAI → Anthropic → Mock (always available)
+ */
+export declare const PROVIDER_CHAIN: readonly ["deepseek", "ollama", "openai", "anthropic", "mock"];
+export type ProviderType = typeof PROVIDER_CHAIN[number];
+/**
+ * Provider factory configuration
+ */
+export interface ProviderFactoryConfig {
+    /**
+     * Preferred provider (will be tried first)
+     */
+    preferred?: ProviderType;
+    /**
+     * Ordered list of providers to try (overrides default chain)
+     */
+    chain?: ProviderType[];
+    /**
+     * Skip specific providers
+     */
+    skip?: ProviderType[];
+    /**
+     * Ollama configuration
+     */
+    ollama?: {
+        baseUrl?: string;
+        model?: string;
+        timeout?: number;
+    };
+    /**
+     * OpenAI configuration
+     */
+    openai?: {
+        apiKey?: string;
+        baseURL?: string;
+        model?: string;
+        timeout?: number;
+    };
+    /**
+     * Anthropic configuration
+     */
+    anthropic?: {
+        apiKey?: string;
+        baseURL?: string;
+        model?: string;
+        timeout?: number;
+    };
+    /**
+     * DeepSeek configuration
+     */
+    deepseek?: {
+        apiKey?: string;
+        baseURL?: string;
+        model?: string;
+        timeout?: number;
+    };
+    /**
+     * Mock configuration
+     */
+    mock?: {
+        delay?: number;
+        responses?: Record<string, string>;
+    };
+}
+/**
+ * Provider selection result
+ */
+export interface ProviderSelection {
+    provider: LLMProvider;
+    type: ProviderType;
+    reason: string;
+    skipped: ProviderType[];
+}
+/**
+ * Fallback provider that wraps the selected provider
+ */
+export declare class FallbackProvider implements LLMProvider {
+    name: string;
+    models: string[];
+    private readonly provider;
+    private readonly providerType;
+    constructor(provider: LLMProvider, providerType: ProviderType);
+    isAvailable(): Promise<boolean>;
+    generate(request: GenerationRequest): Promise<GenerationResponse>;
+    stream(request: GenerationRequest): AsyncIterable<string>;
+    countTokens(text: string): number;
+    /**
+     * Get the underlying provider type
+     */
+    getProviderType(): ProviderType;
+}
+/**
+ * Create LLM provider with automatic fallback
+ *
+ * Tries providers in order until one is available.
+ * Logs which provider was selected and why.
+ */
+export declare function createLLMProvider(config?: ProviderFactoryConfig): Promise<FallbackProvider>;
+/**
+ * Get provider availability status for all providers
+ */
+export declare function getProviderStatus(config?: ProviderFactoryConfig): Promise<Record<ProviderType, boolean>>;
+/**
+ * Auto-detect best available provider
+ * Priority: DeepSeek (best value) → Ollama (free local) → OpenAI → Anthropic → Mock
+ */
+export declare function detectBestProvider(config?: ProviderFactoryConfig): Promise<ProviderType>;
+/**
+ * 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 declare function createBest(config?: ProviderFactoryConfig): Promise<FallbackProvider>;
+/**
+ * Get provider information for display
+ */
+export interface ProviderInfo {
+    type: ProviderType;
+    name: string;
+    available: boolean;
+    description: string;
+    costLevel: 'free' | 'low' | 'medium' | 'high';
+    capabilities: string[];
+}
+export declare function getProviderInfo(config?: ProviderFactoryConfig): Promise<ProviderInfo[]>;
+/**
+ * Create provider with automatic retry on failure
+ *
+ * If the selected provider fails, automatically falls back
+ * to the next available provider in the chain.
+ */
+export declare function createResilientLLMProvider(config?: ProviderFactoryConfig): Promise<FallbackProvider>;
+/**
+ * Quick check if any LLM provider is available
+ */
+export declare function hasAnyProvider(config?: ProviderFactoryConfig): Promise<boolean>;

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

@@ -0,0 +1,269 @@
+/**
+ * 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/auth/api-key-provider.d.ts

@@ -0,0 +1,16 @@
+/**
+ * API Key Authentication Provider
+ *
+ * Handles API key authentication with support for:
+ * - Custom header names (default: X-API-Key)
+ * - Custom prefix (e.g., "Bearer ")
+ * - Header or query param location
+ */
+import { AuthProvider, AuthResult, APIKeyAuthConfig } from './index.js';
+export declare class APIKeyProvider implements AuthProvider<APIKeyAuthConfig> {
+    readonly type: "api_key";
+    authenticate(config: APIKeyAuthConfig): Promise<AuthResult>;
+    clear(config: APIKeyAuthConfig): Promise<void>;
+    validate(config: APIKeyAuthConfig): Promise<boolean>;
+    private getCacheKey;
+}

package/dist/core/auth/api-key-provider.js

@@ -0,0 +1,63 @@
+/**
+ * API Key Authentication Provider
+ *
+ * Handles API key authentication with support for:
+ * - Custom header names (default: X-API-Key)
+ * - Custom prefix (e.g., "Bearer ")
+ * - Header or query param location
+ */
+import { authCache, createCacheKey } from './index.js';
+export class APIKeyProvider {
+    type = 'api_key';
+    async authenticate(config) {
+        const { key, header_name = 'X-API-Key', prefix = '', location = 'header', cache } = config;
+        const cacheKey = this.getCacheKey(config);
+        // Check cache first
+        if (cache?.enabled !== false) {
+            const cached = authCache.get(cacheKey);
+            if (cached) {
+                return { success: true, credentials: cached };
+            }
+        }
+        const credentials = {
+            type: 'api_key'
+        };
+        // Prefix is used as-is, no automatic space added
+        const fullKey = prefix + key;
+        if (location === 'header') {
+            credentials.headers = {
+                [header_name]: fullKey
+            };
+        }
+        else {
+            credentials.queryParams = {
+                api_key: fullKey
+            };
+        }
+        // Cache if enabled
+        if (cache?.enabled !== false) {
+            const ttl = cache?.ttl || 3600;
+            authCache.set(cacheKey, credentials, ttl);
+        }
+        return {
+            success: true,
+            credentials
+        };
+    }
+    async clear(config) {
+        const key = this.getCacheKey(config);
+        authCache.clear(key);
+    }
+    async validate(config) {
+        const cacheKey = this.getCacheKey(config);
+        // Check cache first, then validate key
+        if (authCache.has(cacheKey)) {
+            return true;
+        }
+        return !!config.key && config.key.length > 0;
+    }
+    getCacheKey(config) {
+        // Use header name as identifier
+        return createCacheKey('api_key', config.header_name || 'default');
+    }
+}

package/dist/core/auth/aws-iam-provider.d.ts

@@ -0,0 +1,35 @@
+/**
+ * AWS IAM Authentication Provider
+ *
+ * Handles AWS authentication using IAM credentials.
+ * Supports credential chains, environment variables, and profiles.
+ */
+import { AuthProvider, AuthResult, AWSIamConfig } from './index.js';
+export declare class AWSIamProvider implements AuthProvider<AWSIamConfig> {
+    readonly type: "aws_iam";
+    authenticate(config: AWSIamConfig): Promise<AuthResult>;
+    refresh(config: AWSIamConfig): Promise<AuthResult>;
+    clear(config: AWSIamConfig): Promise<void>;
+    validate(config: AWSIamConfig): Promise<boolean>;
+    /**
+     * Get AWS credentials from various sources
+     */
+    private getCredentials;
+    /**
+     * Get credentials from environment variables
+     */
+    private getFromEnv;
+    /**
+     * Get credentials from AWS profile file
+     */
+    private getFromProfile;
+    /**
+     * Get credentials from AWS SDK v3
+     */
+    private getFromSDK;
+    /**
+     * Get AMZ date format for AWS signing
+     */
+    private getAmzDate;
+    private getCacheKey;
+}