qa360 2.1.2 → 2.1.4

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

@@ -1,78 +0,0 @@
-/**
- * Ollama LLM Provider
- *
- * Local LLM provider using Ollama (https://ollama.com).
- * Runs locally with models like DeepSeek Coder, Llama, Mistral, etc.
- *
- * Environment variables:
- * - OLLAMA_BASE_URL: Optional base URL (default: http://localhost:11434)
- * - OLLAMA_MODEL: Model to use (default: deepseek-coder)
- */
-import type { LLMProvider, GenerationRequest, GenerationResponse } from './index.js';
-export interface OllamaConfig {
-    baseUrl?: string;
-    model?: string;
-    timeout?: number;
-}
-/**
- * Ollama-specific provider
- * Connects to local Ollama instance for AI capabilities
- */
-export declare class OllamaProvider implements LLMProvider {
-    name: string;
-    models: string[];
-    private readonly baseUrl;
-    private readonly defaultModel;
-    private readonly timeout;
-    constructor(config?: OllamaConfig);
-    isAvailable(): Promise<boolean>;
-    generate(request: GenerationRequest): Promise<GenerationResponse>;
-    stream(request: GenerationRequest): AsyncIterable<string>;
-    countTokens(text: string): number;
-    /**
-     * List available models from Ollama
-     */
-    listModels(): Promise<ModelInfo[]>;
-    /**
-     * Pull a model from Ollama registry
-     */
-    pullModel(model: string, onProgress?: (progress: PullProgress) => Promise<void>): Promise<void>;
-    private buildFullPrompt;
-}
-/**
- * Model information
- */
-export interface ModelInfo {
-    name: string;
-    size: number;
-    modifiedAt: string;
-}
-/**
- * Pull progress information
- */
-export interface PullProgress {
-    status: 'pulling' | 'verifying' | 'complete';
-    digest?: string;
-    total?: number;
-    completed?: number;
-}
-/**
- * Ollama-specific error
- */
-export declare class OllamaError extends Error {
-    code: string;
-    details?: Record<string, unknown>;
-    constructor(message: string, details?: Record<string, unknown>);
-}
-/**
- * Create Ollama provider with default settings
- */
-export declare function createOllamaProvider(config?: OllamaConfig): OllamaProvider;
-/**
- * Check if Ollama is available and has the required model
- */
-export declare function checkOllamaSetup(model?: string): Promise<{
-    available: boolean;
-    modelInstalled: boolean;
-    models: string[];
-}>;

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

@@ -1,192 +0,0 @@
-/**
- * Ollama LLM Provider
- *
- * Local LLM provider using Ollama (https://ollama.com).
- * Runs locally with models like DeepSeek Coder, Llama, Mistral, etc.
- *
- * Environment variables:
- * - OLLAMA_BASE_URL: Optional base URL (default: http://localhost:11434)
- * - OLLAMA_MODEL: Model to use (default: deepseek-coder)
- */
-/**
- * Ollama-specific provider
- * Connects to local Ollama instance for AI capabilities
- */
-export class OllamaProvider {
-    name = 'ollama';
-    // Recommended models for code generation
-    models = [
-        'deepseek-coder', // Best for code generation
-        'codellama', // Good for code
-        'llama3.2', // General purpose
-        'mistral', // Fast, good quality
-        'qwen2.5-coder', // Alternative code model
-    ];
-    baseUrl;
-    defaultModel;
-    timeout;
-    constructor(config = {}) {
-        this.baseUrl = config.baseUrl || process.env.OLLAMA_BASE_URL || 'http://localhost:11434';
-        this.defaultModel = config.model || process.env.OLLAMA_MODEL || 'deepseek-coder';
-        this.timeout = config.timeout || 120000; // 2 minutes default
-    }
-    async isAvailable() {
-        try {
-            const response = await fetch(`${this.baseUrl}/api/tags`, {
-                signal: AbortSignal.timeout(5000),
-            });
-            return response.ok;
-        }
-        catch {
-            return false;
-        }
-    }
-    async generate(request) {
-        const fullPrompt = this.buildFullPrompt(request);
-        const response = await fetch(`${this.baseUrl}/api/generate`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            signal: AbortSignal.timeout(this.timeout),
-            body: JSON.stringify({
-                model: this.defaultModel,
-                prompt: fullPrompt,
-                stream: false,
-                options: {
-                    temperature: request.temperature ?? 0.7,
-                    num_predict: request.maxTokens ?? 4096,
-                }
-            })
-        });
-        if (!response.ok) {
-            throw new OllamaError(`Ollama request failed: ${response.status} ${response.statusText}`, { response: await response.text().catch(() => 'Unknown error') });
-        }
-        const data = await response.json();
-        if (data.error) {
-            throw new OllamaError(data.error);
-        }
-        return {
-            content: data.response,
-            usage: {
-                promptTokens: data.prompt_eval_count || 0,
-                completionTokens: data.eval_count || 0,
-                totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0),
-            },
-            model: this.defaultModel,
-            finishReason: data.done_reason || 'stop',
-        };
-    }
-    async *stream(request) {
-        const fullPrompt = this.buildFullPrompt(request);
-        const response = await fetch(`${this.baseUrl}/api/generate`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                model: this.defaultModel,
-                prompt: fullPrompt,
-                stream: true,
-                options: {
-                    temperature: request.temperature ?? 0.7,
-                    num_predict: request.maxTokens ?? 4096,
-                }
-            })
-        });
-        if (!response.ok) {
-            throw new OllamaError(`Ollama stream failed: ${response.status}`);
-        }
-        const reader = response.body?.getReader();
-        if (!reader) {
-            throw new OllamaError('No response body');
-        }
-        const decoder = new TextDecoder();
-        let buffer = '';
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            buffer += decoder.decode(value, { stream: true });
-            const lines = buffer.split('\n');
-            buffer = lines.pop() || '';
-            for (const line of lines) {
-                if (line.trim()) {
-                    const data = JSON.parse(line);
-                    if (data.done) {
-                        if (data.response)
-                            yield data.response;
-                        return;
-                    }
-                    if (data.response) {
-                        yield data.response;
-                    }
-                }
-            }
-        }
-    }
-    countTokens(text) {
-        // Approximate token count (roughly 4 chars per token)
-        return Math.ceil(text.length / 4);
-    }
-    /**
-     * List available models from Ollama
-     */
-    async listModels() {
-        const response = await fetch(`${this.baseUrl}/api/tags`);
-        if (!response.ok) {
-            throw new OllamaError('Failed to list models');
-        }
-        const data = await response.json();
-        return data.models.map((m) => ({
-            name: m.name,
-            size: m.size,
-            modifiedAt: m.modified_at,
-        }));
-    }
-    /**
-     * Pull a model from Ollama registry
-     */
-    async pullModel(model, onProgress) {
-        // This is a long-running operation, typically done via CLI
-        // but we provide the method for completeness
-        throw new Error('Use "ollama pull <model>" via CLI for model downloads');
-    }
-    buildFullPrompt(request) {
-        if (request.systemPrompt) {
-            return `System: ${request.systemPrompt}\n\nUser: ${request.prompt}\n\nAssistant:`;
-        }
-        return request.prompt;
-    }
-}
-/**
- * Ollama-specific error
- */
-export class OllamaError extends Error {
-    code = 'OLLAMA_ERROR';
-    details;
-    constructor(message, details) {
-        super(message);
-        this.name = 'OllamaError';
-        this.details = details;
-    }
-}
-/**
- * Create Ollama provider with default settings
- */
-export function createOllamaProvider(config) {
-    return new OllamaProvider(config);
-}
-/**
- * Check if Ollama is available and has the required model
- */
-export async function checkOllamaSetup(model = 'deepseek-coder') {
-    const provider = new OllamaProvider();
-    const available = await provider.isAvailable();
-    if (!available) {
-        return { available: false, modelInstalled: false, models: [] };
-    }
-    const models = await provider.listModels();
-    const modelNames = models.map(m => m.name);
-    return {
-        available: true,
-        modelInstalled: modelNames.some(m => m.includes(model)),
-        models: modelNames,
-    };
-}

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

@@ -1,48 +0,0 @@
-/**
- * OpenAI LLM Provider
- *
- * Provider for OpenAI API (https://api.openai.com).
- * Supports GPT-4, GPT-4 Turbo, and GPT-3.5.
- *
- * Environment variables:
- * - OPENAI_API_KEY: Required API key
- * - OPENAI_BASE_URL: Optional base URL (default: https://api.openai.com/v1)
- * - OPENAI_MODEL: Model to use (default: gpt-4)
- */
-import type { LLMProvider, GenerationRequest, GenerationResponse } from './index.js';
-export interface OpenAIConfig {
-    apiKey?: string;
-    baseURL?: string;
-    model?: string;
-    timeout?: number;
-}
-export declare class OpenAIProvider implements LLMProvider {
-    name: string;
-    models: string[];
-    private readonly apiKey;
-    private readonly baseURL;
-    private readonly defaultModel;
-    private readonly timeout;
-    constructor(config?: OpenAIConfig);
-    isAvailable(): Promise<boolean>;
-    generate(request: GenerationRequest): Promise<GenerationResponse>;
-    stream(request: GenerationRequest): AsyncIterable<string>;
-    countTokens(text: string): number;
-    private buildMessages;
-}
-/**
- * OpenAI-specific error
- */
-export declare class OpenAIError extends Error {
-    code: string;
-    details?: Record<string, unknown>;
-    constructor(message: string, details?: Record<string, unknown>);
-}
-/**
- * Create OpenAI provider with default settings
- */
-export declare function createOpenAIProvider(config?: OpenAIConfig): OpenAIProvider;
-/**
- * Check if OpenAI is available and configured
- */
-export declare function checkOpenAISetup(): Promise<boolean>;

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

@@ -1,188 +0,0 @@
-/**
- * OpenAI LLM Provider
- *
- * Provider for OpenAI API (https://api.openai.com).
- * Supports GPT-4, GPT-4 Turbo, and GPT-3.5.
- *
- * Environment variables:
- * - OPENAI_API_KEY: Required API key
- * - OPENAI_BASE_URL: Optional base URL (default: https://api.openai.com/v1)
- * - OPENAI_MODEL: Model to use (default: gpt-4)
- */
-export class OpenAIProvider {
-    name = 'openai';
-    // Recommended models for code generation
-    models = [
-        'gpt-4', // Most capable
-        'gpt-4-turbo', // Faster, cheaper
-        'gpt-4o', // Latest GPT-4 Omni
-        'gpt-4o-mini', // Smaller, faster
-        'gpt-3.5-turbo', // Budget option
-    ];
-    apiKey;
-    baseURL;
-    defaultModel;
-    timeout;
-    constructor(config = {}) {
-        this.apiKey = config.apiKey || process.env.OPENAI_API_KEY || '';
-        this.baseURL = config.baseURL || process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1';
-        this.defaultModel = config.model || process.env.OPENAI_MODEL || 'gpt-4';
-        this.timeout = config.timeout || 60000; // 1 minute default
-    }
-    async isAvailable() {
-        // Check if API key is present
-        if (!this.apiKey) {
-            return false;
-        }
-        // Try a minimal API call
-        try {
-            const response = await fetch(`${this.baseURL}/models`, {
-                method: 'GET',
-                headers: {
-                    'Authorization': `Bearer ${this.apiKey}`,
-                },
-                signal: AbortSignal.timeout(5000),
-            });
-            return response.ok;
-        }
-        catch {
-            return false;
-        }
-    }
-    async generate(request) {
-        if (!this.apiKey) {
-            throw new OpenAIError('OPENAI_API_KEY is required', {
-                suggestion: 'Set OPENAI_API_KEY environment variable or pass apiKey in config'
-            });
-        }
-        const messages = this.buildMessages(request);
-        const response = await fetch(`${this.baseURL}/chat/completions`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${this.apiKey}`,
-                'Content-Type': 'application/json',
-            },
-            signal: AbortSignal.timeout(this.timeout),
-            body: JSON.stringify({
-                model: this.defaultModel,
-                messages,
-                temperature: request.temperature ?? 0.7,
-                max_tokens: request.maxTokens ?? 4096,
-            })
-        });
-        if (!response.ok) {
-            const error = await response.text().catch(() => 'Unknown error');
-            throw new OpenAIError(`OpenAI request failed: ${response.status} ${error}`, {
-                status: response.status,
-                response: error
-            });
-        }
-        const data = await response.json();
-        const choice = data.choices?.[0];
-        if (!choice) {
-            throw new OpenAIError('No choices returned from OpenAI');
-        }
-        return {
-            content: choice.message.content,
-            usage: {
-                promptTokens: data.usage?.prompt_tokens || 0,
-                completionTokens: data.usage?.completion_tokens || 0,
-                totalTokens: data.usage?.total_tokens || 0,
-            },
-            model: data.model,
-            finishReason: choice.finish_reason === 'stop' ? 'stop' : 'length'
-        };
-    }
-    async *stream(request) {
-        if (!this.apiKey) {
-            throw new OpenAIError('OPENAI_API_KEY is required');
-        }
-        const messages = this.buildMessages(request);
-        const response = await fetch(`${this.baseURL}/chat/completions`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${this.apiKey}`,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                model: this.defaultModel,
-                messages,
-                temperature: request.temperature ?? 0.7,
-                max_tokens: request.maxTokens ?? 4096,
-                stream: true,
-            })
-        });
-        if (!response.ok) {
-            throw new OpenAIError(`OpenAI stream failed: ${response.status}`);
-        }
-        const reader = response.body?.getReader();
-        if (!reader) {
-            throw new OpenAIError('No response body');
-        }
-        const decoder = new TextDecoder();
-        let buffer = '';
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            buffer += decoder.decode(value, { stream: true });
-            const lines = buffer.split('\n');
-            buffer = lines.pop() || '';
-            for (const line of lines) {
-                if (line.startsWith('data: ')) {
-                    const data = line.slice(6);
-                    if (data === '[DONE]') {
-                        return;
-                    }
-                    try {
-                        const parsed = JSON.parse(data);
-                        const content = parsed.choices?.[0]?.delta?.content;
-                        if (content) {
-                            yield content;
-                        }
-                    }
-                    catch {
-                        // Ignore invalid JSON
-                    }
-                }
-            }
-        }
-    }
-    countTokens(text) {
-        // Approximate token count (roughly 4 chars per token for English)
-        return Math.ceil(text.length / 4);
-    }
-    buildMessages(request) {
-        const messages = [];
-        if (request.systemPrompt) {
-            messages.push({ role: 'system', content: request.systemPrompt });
-        }
-        messages.push({ role: 'user', content: request.prompt });
-        return messages;
-    }
-}
-/**
- * OpenAI-specific error
- */
-export class OpenAIError extends Error {
-    code = 'OPENAI_ERROR';
-    details;
-    constructor(message, details) {
-        super(message);
-        this.name = 'OpenAIError';
-        this.details = details;
-    }
-}
-/**
- * Create OpenAI provider with default settings
- */
-export function createOpenAIProvider(config) {
-    return new OpenAIProvider(config);
-}
-/**
- * Check if OpenAI is available and configured
- */
-export async function checkOpenAISetup() {
-    const provider = new OpenAIProvider();
-    return provider.isAvailable();
-}

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

@@ -1,160 +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 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>;