qa360 2.1.7 → 2.2.0

package/core/src/ai/mock-provider.ts

@@ -0,0 +1,146 @@
+/**
+ * Mock LLM Provider
+ *
+ * Deterministic LLM provider for testing and fallback.
+ * Returns predefined responses without making network calls.
+ */
+
+import type { LLMProvider, GenerationRequest, GenerationResponse } from './index.js';
+
+export interface MockProviderConfig {
+  responses?: Record<string, string>;
+  defaultResponse?: string;
+  delay?: number; // Simulate network latency in ms
+}
+
+export class MockProvider implements LLMProvider {
+  name = 'mock';
+  models = ['mock-model', 'mock-coder', 'mock-analyst'];
+
+  private readonly responses: Record<string, string>;
+  private readonly defaultResponse: string;
+  private readonly delay: number;
+
+  constructor(config: MockProviderConfig = {}) {
+    this.responses = config.responses || {};
+    this.defaultResponse = config.defaultResponse || 'Mock LLM response';
+    this.delay = config.delay || 0;
+  }
+
+  async isAvailable(): Promise<boolean> {
+    // Mock is always available
+    return true;
+  }
+
+  async generate(request: GenerationRequest): Promise<GenerationResponse> {
+    if (this.delay > 0) {
+      await new Promise(resolve => setTimeout(resolve, this.delay));
+    }
+
+    // Check for predefined response
+    const key = this.getRequestKey(request);
+    const content = this.responses[key] || this.defaultResponse;
+
+    return {
+      content,
+      usage: {
+        promptTokens: this.countTokens(request.prompt),
+        completionTokens: this.countTokens(content),
+        totalTokens: this.countTokens(request.prompt) + this.countTokens(content)
+      },
+      model: 'mock-model',
+      finishReason: 'stop'
+    };
+  }
+
+  async *stream(request: GenerationRequest): AsyncIterable<string> {
+    const response = await this.generate(request);
+    const words = response.content.split(' ');
+    for (const word of words) {
+      await new Promise(resolve => setTimeout(resolve, 10)); // Small delay between chunks
+      yield word + ' ';
+    }
+  }
+
+  countTokens(text: string): number {
+    return Math.ceil(text.length / 4);
+  }
+
+  private getRequestKey(request: GenerationRequest): string {
+    // Create a simple key from the prompt
+    const prompt = request.prompt.substring(0, 100);
+    return prompt.replace(/\s+/g, ' ').trim();
+  }
+
+  /**
+   * Set a predefined response for a specific prompt
+   */
+  setResponse(promptPattern: string, response: string): void {
+    const key = promptPattern.replace(/\s+/g, ' ').trim();
+    this.responses[key] = response;
+  }
+
+  /**
+   * Clear all predefined responses
+   */
+  clearResponses(): void {
+    Object.keys(this.responses).forEach(key => {
+      delete this.responses[key];
+    });
+  }
+}
+
+/**
+ * Create a mock provider with predefined responses
+ */
+export function createMockProvider(config?: MockProviderConfig): MockProvider {
+  return new MockProvider(config);
+}
+
+/**
+ * Default mock responses for common QA360 prompts
+ */
+export const MOCK_RESPONSES = {
+  testGeneration: `{
+  "tests": [
+    {
+      "name": "API Health Check",
+      "type": "api_smoke",
+      "target": "https://api.example.com/health",
+      "method": "GET",
+      "expectedStatus": 200
+    }
+  ]
+}`,
+
+  codeAnalysis: `{
+  "issues": [
+    {
+      "severity": "medium",
+      "rule": "no-unused-vars",
+      "message": "Unused variable 'foo'",
+      "location": { "file": "src/app.ts", "line": 42 }
+    }
+  ]
+}`,
+
+  testSuggestions: `{
+  "suggestions": [
+    {
+      "type": "add_test",
+      "description": "Add test for login function",
+      "priority": "high"
+    }
+  ]
+}`
+};
+
+/**
+ * Create a mock provider with standard QA360 mock responses
+ */
+export function createStandardMockProvider(): MockProvider {
+  return new MockProvider({
+    responses: MOCK_RESPONSES,
+    delay: 50 // Simulate 50ms latency
+  });
+}

package/core/src/ai/ollama-provider.ts

@@ -0,0 +1,269 @@
+/**
+ * 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 class OllamaProvider implements LLMProvider {
+  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
+  ];
+
+  private readonly baseUrl: string;
+  private readonly defaultModel: string;
+  private readonly timeout: number;
+
+  constructor(config: OllamaConfig = {}) {
+    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(): Promise<boolean> {
+    try {
+      // Use timeout with AbortSignal - wrap for compatibility
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 5000);
+
+      const response = await fetch(`${this.baseUrl}/api/tags`, {
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  async generate(request: GenerationRequest): Promise<GenerationResponse> {
+    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: GenerationRequest): AsyncIterable<string> {
+    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: string): number {
+    // Approximate token count (roughly 4 chars per token)
+    return Math.ceil(text.length / 4);
+  }
+
+  /**
+   * List available models from Ollama
+   */
+  async listModels(): Promise<ModelInfo[]> {
+    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: any) => ({
+      name: m.name,
+      size: m.size,
+      modifiedAt: m.modified_at,
+    }));
+  }
+
+  /**
+   * Pull a model from Ollama registry
+   */
+  async pullModel(model: string, onProgress?: (progress: PullProgress) => Promise<void>): Promise<void> {
+    // 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');
+  }
+
+  private buildFullPrompt(request: GenerationRequest): string {
+    if (request.systemPrompt) {
+      return `System: ${request.systemPrompt}\n\nUser: ${request.prompt}\n\nAssistant:`;
+    }
+    return request.prompt;
+  }
+}
+
+/**
+ * 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 class OllamaError extends Error {
+  code = 'OLLAMA_ERROR';
+  details?: Record<string, unknown>;
+
+  constructor(message: string, details?: Record<string, unknown>) {
+    super(message);
+    this.name = 'OllamaError';
+    this.details = details;
+  }
+}
+
+/**
+ * Create Ollama provider with default settings
+ */
+export function createOllamaProvider(config?: OllamaConfig): OllamaProvider {
+  return new OllamaProvider(config);
+}
+
+/**
+ * Check if Ollama is available and has the required model
+ */
+export async function checkOllamaSetup(model: string = 'deepseek-coder'): Promise<{
+  available: boolean;
+  modelInstalled: boolean;
+  models: string[];
+}> {
+  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/core/src/ai/openai-provider.ts

@@ -0,0 +1,240 @@
+/**
+ * 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 class OpenAIProvider implements LLMProvider {
+  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
+  ];
+
+  private readonly apiKey: string;
+  private readonly baseURL: string;
+  private readonly defaultModel: string;
+  private readonly timeout: number;
+
+  constructor(config: OpenAIConfig = {}) {
+    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(): Promise<boolean> {
+    // 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: GenerationRequest): Promise<GenerationResponse> {
+    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: GenerationRequest): AsyncIterable<string> {
+    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: string): number {
+    // Approximate token count (roughly 4 chars per token for English)
+    return Math.ceil(text.length / 4);
+  }
+
+  private buildMessages(request: GenerationRequest): Array<{ role: string; content: string }> {
+    const messages: Array<{ role: string; content: string }> = [];
+
+    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?: Record<string, unknown>;
+
+  constructor(message: string, details?: Record<string, unknown>) {
+    super(message);
+    this.name = 'OpenAIError';
+    this.details = details;
+  }
+}
+
+/**
+ * Create OpenAI provider with default settings
+ */
+export function createOpenAIProvider(config?: OpenAIConfig): OpenAIProvider {
+  return new OpenAIProvider(config);
+}
+
+/**
+ * Check if OpenAI is available and configured
+ */
+export async function checkOpenAISetup(): Promise<boolean> {
+  const provider = new OpenAIProvider();
+  return provider.isAvailable();
+}