qa360 2.2.1 → 2.2.13

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

@@ -0,0 +1,78 @@
+/**
+ * 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/cli/dist/core/ai/ollama-provider.js

@@ -0,0 +1,216 @@
+/**
+ * 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 {
+            // Use a longer timeout (15 seconds) to accommodate slower systems
+            // Ollama can take time to respond, especially on first run or with many models
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 15000);
+            const response = await fetch(`${this.baseUrl}/api/tags`, {
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            return response.ok;
+        }
+        catch (error) {
+            // Log the error for debugging (will be visible in verbose mode)
+            if (error instanceof Error) {
+                if (error.name === 'AbortError') {
+                    // Timeout - Ollama is slow to respond
+                    console.debug(`[Ollama] Connection to ${this.baseUrl} timed out after 15s`);
+                }
+                else {
+                    // Other error (ECONNREFUSED, ENOTFOUND, etc.)
+                    console.debug(`[Ollama] Connection error: ${error.message}`);
+                }
+            }
+            return false;
+        }
+    }
+    async generate(request) {
+        const fullPrompt = this.buildFullPrompt(request);
+        // Use timeout with AbortController for compatibility
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(`${this.baseUrl}/api/generate`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                signal: controller.signal,
+                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',
+            };
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    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/cli/dist/core/ai/openai-provider.d.ts

@@ -0,0 +1,48 @@
+/**
+ * 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/cli/dist/core/ai/openai-provider.js

@@ -0,0 +1,200 @@
+/**
+ * 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 {
+            // Use timeout with AbortController for compatibility
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), 5000);
+            const response = await fetch(`${this.baseURL}/models`, {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                },
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            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);
+        // Use timeout with AbortController for compatibility
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const response = await fetch(`${this.baseURL}/chat/completions`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                signal: controller.signal,
+                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'
+            };
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    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/cli/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>;