qa360 2.2.1 → 2.2.13

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

@@ -1,146 +0,0 @@
-/**
- * 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

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

@@ -1,240 +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 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();
-}