@entro314labs/ai-changelog-generator 3.0.5

package/src/infrastructure/providers/implementations/lmstudio.js

@@ -0,0 +1,189 @@
+import { OpenAI } from 'openai';
+import { BaseProvider } from '../core/base-provider.js';
+import { applyMixins } from '../utils/base-provider-helpers.js';
+import { buildClientOptions } from '../utils/provider-utils.js';
+
+class LMStudioProvider extends BaseProvider {
+  constructor(config) {
+    super(config);
+    this.client = null;
+    if (this.isAvailable()) {
+      this.initializeClient();
+    }
+  }
+
+  initializeClient() {
+    const clientOptions = buildClientOptions(this.getProviderConfig(), {
+      baseURL: 'http://localhost:1234/v1',
+      apiKey: 'lm-studio', // Not required by LM Studio
+      timeout: 120000,
+      maxRetries: 2
+    });
+    
+    // LM Studio uses OpenAI-compatible API
+    this.client = new OpenAI({
+      baseURL: clientOptions.baseURL,
+      apiKey: clientOptions.apiKey,
+      timeout: clientOptions.timeout,
+      maxRetries: clientOptions.maxRetries,
+    });
+  }
+
+  getName() {
+    return 'lmstudio';
+  }
+
+  isAvailable() {
+    return !!this.config.LMSTUDIO_API_BASE;
+  }
+
+  async generateCompletion(messages, options) {
+    if (!this.isAvailable()) {
+      return this.handleProviderError(
+        new Error('LM Studio provider is not configured'), 
+        'generate_completion'
+      );
+    }
+
+    // Prepare parameters for the API call
+    const params = {
+      model: options.model || this.config.AI_MODEL || this.config.LMSTUDIO_MODEL || this.config.LMSTUDIO_DEFAULT_MODEL || 'local-model',
+      messages: messages,
+      max_tokens: options.max_tokens || 2048,
+      temperature: options.temperature || 0.7,
+      top_p: options.top_p || 0.95,
+      frequency_penalty: options.frequency_penalty || 0,
+      presence_penalty: options.presence_penalty || 0,
+      user: options.user || this.config.LMSTUDIO_USER_ID
+    };
+
+    // Add function calling if provided and the model supports it
+    if (options.tools && this.getCapabilities(params.model).tool_use) {
+      params.tools = options.tools;
+      params.tool_choice = options.tool_choice || 'auto';
+    }
+
+    // Add JSON mode if requested and the model supports it
+    if (options.response_format?.type === 'json_object' && this.getCapabilities(params.model).json_mode) {
+      params.response_format = { type: 'json_object' };
+    }
+
+    // Handle streaming
+    if (options.stream) {
+      params.stream = true;
+      const stream = await this.client.chat.completions.create(params);
+      return { stream, model: params.model };
+    }
+
+    // Make the non-streaming API call
+    const response = await this.client.chat.completions.create(params);
+
+    // Extract tool calls if present
+    let toolCalls = null;
+    if (response.choices[0]?.message?.tool_calls?.length > 0) {
+      toolCalls = response.choices[0].message.tool_calls;
+    }
+
+    return {
+      content: response.choices[0].message.content,
+      model: response.model,
+      tokens: response.usage?.total_tokens || 0,
+      finish_reason: response.choices[0].finish_reason,
+      tool_calls: toolCalls
+    };
+  }
+
+
+  getCapabilities(modelName) {
+    const model = modelName || this.config.AI_MODEL || this.config.LMSTUDIO_MODEL || this.config.LMSTUDIO_DEFAULT_MODEL || 'local-model';
+    
+    // Base capabilities - all models are local
+    const capabilities = {
+      vision: false,
+      tool_use: false,
+      json_mode: false,
+      reasoning: false,
+      local: true
+    };
+    
+    // Capabilities depend on the specific model loaded in LM Studio
+    // These are general capabilities based on model family naming conventions
+    
+    // Llama models
+    if (model.toLowerCase().includes('llama')) {
+      capabilities.json_mode = true;
+      
+      // Llama 3 models likely support function calling
+      if (model.includes('3')) {
+        capabilities.tool_use = true;
+      }
+    }
+    
+    // Mistral models
+    else if (model.toLowerCase().includes('mistral')) {
+      capabilities.json_mode = true;
+      
+      // Mixtral models likely have better reasoning
+      if (model.toLowerCase().includes('mixtral')) {
+        capabilities.reasoning = true;
+      }
+    }
+    
+    // Vision models
+    if (model.toLowerCase().includes('vision') || 
+        model.toLowerCase().includes('llava') || 
+        model.toLowerCase().includes('bakllava')) {
+      capabilities.vision = true;
+    }
+    
+    return capabilities;
+  }
+
+  getAvailableModels() {
+    return [
+      {
+        id: 'local-model',
+        name: 'Local Model (LM Studio)',
+        contextWindow: 4096,
+        maxOutput: 2048,
+        inputCost: 0,  // Local models are free
+        outputCost: 0,
+        features: ['text', 'local'],
+        description: 'Local model running in LM Studio'
+      },
+      {
+        id: 'llama-3-8b-instruct',
+        name: 'Llama 3 8B Instruct',
+        contextWindow: 8192,
+        maxOutput: 4096,
+        inputCost: 0,
+        outputCost: 0,
+        features: ['text', 'tools', 'local'],
+        description: 'Local Llama 3 8B instruction-tuned model'
+      },
+      {
+        id: 'mistral-7b-instruct',
+        name: 'Mistral 7B Instruct',
+        contextWindow: 8192,
+        maxOutput: 4096,
+        inputCost: 0,
+        outputCost: 0,
+        features: ['text', 'reasoning', 'local'],
+        description: 'Local Mistral 7B instruction-tuned model'
+      },
+      {
+        id: 'llava-1.5-7b',
+        name: 'LLaVA 1.5 7B',
+        contextWindow: 4096,
+        maxOutput: 2048,
+        inputCost: 0,
+        outputCost: 0,
+        features: ['text', 'vision', 'local'],
+        description: 'Local vision-language model'
+      }
+    ];
+  }
+}
+
+// Apply mixins to add standard provider functionality
+export default applyMixins(LMStudioProvider, 'lmstudio');

package/src/infrastructure/providers/implementations/mock.js

@@ -0,0 +1,275 @@
+/**
+ * Mock Provider
+ * Used for testing without real API credentials
+ */
+
+import { BaseProvider } from '../core/base-provider.js';
+import { ProviderError } from '../../../shared/utils/utils.js';
+
+class MockProvider extends BaseProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'mock';
+    this.mockResponses = config.MOCK_RESPONSES || {};
+    this.shouldFail = config.MOCK_SHOULD_FAIL === 'true';
+    this.failureRate = parseFloat(config.MOCK_FAILURE_RATE || '0.1');
+    this.latency = parseInt(config.MOCK_LATENCY || '500', 10);
+    this.models = [
+      'mock-basic',
+      'mock-standard',
+      'mock-advanced'
+    ];
+  }
+
+  /**
+   * Get provider name
+   * @returns {string} Provider name
+   */
+  getName() {
+    return this.name;
+  }
+
+  /**
+   * Check if provider is available
+   * @returns {boolean} Always true for mock provider
+   */
+  isAvailable() {
+    return true;
+  }
+
+  /**
+   * Simulate network latency
+   * @param {number} ms - Milliseconds to wait
+   * @returns {Promise} - Promise that resolves after delay
+   */
+  async _simulateLatency() {
+    return new Promise(resolve => setTimeout(resolve, this.latency));
+  }
+
+  /**
+   * Determine if operation should fail based on failure rate
+   * @returns {boolean} - Whether operation should fail
+   */
+  _shouldFailOperation() {
+    if (this.shouldFail) {
+      return true;
+    }
+    return Math.random() < this.failureRate;
+  }
+
+  /**
+   * Generate completion with mock data
+   * @param {Array} messages - Messages for completion
+   * @param {Object} options - Generation options
+   * @returns {Promise} - Promise that resolves with mock completion
+   */
+  async generateCompletion(messages, options = {}) {
+    await this._simulateLatency();
+
+    if (this._shouldFailOperation()) {
+      throw new ProviderError(
+        'Mock provider simulated failure',
+        'mock_error',
+        this.getName(),
+        options.model || 'mock-standard'
+      );
+    }
+
+    const model = options.model || 'mock-standard';
+    const lastMessage = messages[messages.length - 1];
+    const prompt = typeof lastMessage === 'string'
+      ? lastMessage
+      : (lastMessage.content || '');
+
+    // Check for predefined responses
+    if (this.mockResponses[prompt]) {
+      return {
+        content: this.mockResponses[prompt],
+        tokens: this.mockResponses[prompt].length / 4, // Rough estimate
+        model: model
+      };
+    }
+
+    // Generate mock response based on commit convention if it looks like a commit message
+    if (prompt.match(/^(feat|fix|docs|style|refactor|perf|test|build|ci|chore)(\(.+\))?:/)) {
+      return {
+        content: this._generateMockChangelog(prompt),
+        tokens: 150,
+        model: model
+      };
+    }
+
+    // Default mock response
+    return {
+      content: `This is a mock response from the ${model} model.`,
+      tokens: 10,
+      model: model
+    };
+  }
+
+  /**
+   * Generate mock changelog based on commit message
+   * @param {string} commitMessage - Commit message
+   * @returns {string} - Mock changelog entry
+   */
+  _generateMockChangelog(commitMessage) {
+    const typeMatch = commitMessage.match(/^(feat|fix|docs|style|refactor|perf|test|build|ci|chore)(\(.+\))?:/);
+
+    if (!typeMatch) {
+      return 'Mock changelog entry for conventional commit';
+    }
+
+    const type = typeMatch[1];
+    const scope = typeMatch[2] ? typeMatch[2].replace(/[()]/g, '') : '';
+    const description = commitMessage.split(':')[1]?.trim() || '';
+
+    const typeMap = {
+      feat: 'Feature',
+      fix: 'Bug Fix',
+      docs: 'Documentation',
+      style: 'Style',
+      refactor: 'Code Refactoring',
+      perf: 'Performance',
+      test: 'Tests',
+      build: 'Build',
+      ci: 'CI',
+      chore: 'Chore'
+    };
+
+    const title = `${typeMap[type]}${scope ? ` (${scope})` : ''}`;
+    return `### ${title}\n\n- ${description}\n`;
+  }
+
+  /**
+   * Get model recommendation based on mock rules
+   * @param {Object} commitInfo - Commit information
+   * @returns {Object} Model recommendation
+   */
+  getModelRecommendation(commitInfo = {}) {
+    if (!commitInfo.message) {
+      return {
+        model: 'mock-standard',
+        reason: 'Default model selected due to insufficient commit information'
+      };
+    }
+
+    // Simple logic based on commit complexity
+    const filesChanged = commitInfo.files?.length || 0;
+    const linesChanged = (commitInfo.additions || 0) + (commitInfo.deletions || 0);
+
+    if (filesChanged > 10 || linesChanged > 500 || commitInfo.breaking) {
+      return {
+        model: 'mock-advanced',
+        reason: 'Complex commit detected, using advanced model'
+      };
+    } else if (filesChanged > 3 || linesChanged > 100) {
+      return {
+        model: 'mock-standard',
+        reason: 'Moderate commit detected, using standard model'
+      };
+    } else {
+      return {
+        model: 'mock-basic',
+        reason: 'Simple commit detected, using basic model'
+      };
+    }
+  }
+
+  /**
+   * Validate model availability
+   * @param {string} model - Model name
+   * @returns {Promise} - Promise that resolves with validation result
+   */
+  async validateModelAvailability(model) {
+    await this._simulateLatency();
+
+    if (this._shouldFailOperation()) {
+      return {
+        available: false,
+        error: 'Mock validation failure',
+        alternatives: this.models
+      };
+    }
+
+    const isAvailable = this.models.includes(model);
+
+    return {
+      available: isAvailable,
+      model: isAvailable ? model : null,
+      alternatives: isAvailable ? [] : this.models
+    };
+  }
+
+  /**
+   * Test connection to mock provider
+   * @returns {Promise} - Promise that resolves with connection test result
+   */
+  async testConnection() {
+    await this._simulateLatency();
+
+    if (this._shouldFailOperation()) {
+      return {
+        success: false,
+        error: 'Mock connection failure',
+        provider: this.getName()
+      };
+    }
+
+    return {
+      success: true,
+      provider: this.getName(),
+      model: 'mock-standard',
+      response: 'Mock connection successful'
+    };
+  }
+
+  /**
+   * Get provider capabilities
+   * @returns {Object} - Capabilities object
+   */
+  getCapabilities() {
+    return {
+      streaming: false,
+      tool_use: true,
+      vision: false,
+      json_mode: true
+    };
+  }
+
+  getAvailableModels() {
+    return [
+      {
+        id: 'mock-basic',
+        name: 'Mock Basic Model',
+        contextWindow: 2048,
+        maxOutput: 1000,
+        inputCost: 0,
+        outputCost: 0,
+        features: ['text', 'testing'],
+        description: 'Basic mock model for simple testing'
+      },
+      {
+        id: 'mock-standard',
+        name: 'Mock Standard Model',
+        contextWindow: 4096,
+        maxOutput: 2000,
+        inputCost: 0,
+        outputCost: 0,
+        features: ['text', 'tools', 'testing'],
+        description: 'Standard mock model for moderate testing'
+      },
+      {
+        id: 'mock-advanced',
+        name: 'Mock Advanced Model',
+        contextWindow: 8192,
+        maxOutput: 4000,
+        inputCost: 0,
+        outputCost: 0,
+        features: ['text', 'tools', 'json', 'testing'],
+        description: 'Advanced mock model for complex testing scenarios'
+      }
+    ];
+  }
+}
+
+export default MockProvider;

package/src/infrastructure/providers/implementations/ollama.js

@@ -0,0 +1,151 @@
+import { Ollama } from 'ollama';
+import { BaseProvider } from '../core/base-provider.js';
+import { ProviderError } from '../../../shared/utils/utils.js';
+import { applyMixins } from '../utils/base-provider-helpers.js';
+import { buildClientOptions } from '../utils/provider-utils.js';
+
+class OllamaProvider extends BaseProvider {
+  constructor(config) {
+    super(config);
+    this.client = null;
+    if (this.isAvailable()) {
+      this.initializeClient();
+    }
+  }
+
+  initializeClient() {
+    const clientOptions = buildClientOptions(this.getProviderConfig(), {
+      host: 'http://localhost:11434'
+    });
+
+    this.client = new Ollama({
+      host: clientOptions.host
+    });
+  }
+
+  getName() {
+    return 'ollama';
+  }
+
+  isAvailable() {
+    return !!this.config.OLLAMA_HOST;
+  }
+
+  async generateCompletion(messages, options = {}) {
+    if (!this.isAvailable()) {
+      return this.handleProviderError(
+        new Error('Ollama provider is not configured'),
+        'generate_completion'
+      );
+    }
+
+    try {
+      // Test connection first time if not already done
+      if (!this._connectionTested) {
+        try {
+          await this.client.list();
+          this._connectionTested = true;
+        } catch (connectionError) {
+          return this.handleProviderError(
+            new Error(`Ollama server unreachable: ${connectionError.message}. Please run 'ollama serve' first.`),
+            'generate_completion'
+          );
+        }
+      }
+
+      const modelConfig = this.getProviderModelConfig();
+      const modelName = options.model || modelConfig.standardModel;
+
+    const params = {
+      model: modelName,
+      messages: messages,
+      stream: !!options.stream,
+      options: {
+        temperature: options.temperature || 0.7,
+        top_p: options.top_p || 0.9,
+        num_predict: options.max_tokens || 1024,
+        stop: options.stop || [],
+      },
+    };
+
+    if (options.tools && this.getCapabilities(modelName).tool_use) {
+      params.tools = options.tools;
+    }
+
+    if (options.response_format?.type === 'json_object' && this.getCapabilities(modelName).json_mode) {
+      params.format = 'json';
+    }
+
+    if (params.stream) {
+      const stream = await this.client.chat(params);
+      return { stream, model: modelName };
+    }
+
+      const response = await this.client.chat(params);
+      return {
+        content: response.message.content,
+        model: response.model,
+        tokens: response.eval_count,
+        finish_reason: response.done ? 'stop' : 'incomplete',
+        tool_calls: response.message.tool_calls,
+      };
+    } catch (error) {
+      return this.handleProviderError(error, 'generate_completion', { model: options.model });
+    }
+  }
+
+  async generateEmbedding(text, options = {}) {
+    if (!this.isAvailable()) {
+      throw new ProviderError('Ollama provider is not configured', 'ollama', 'isAvailable');
+    }
+
+    const modelName = options.model || this.config.OLLAMA_EMBEDDING_MODEL || this.config.AI_MODEL_EMBEDDING || 'nomic-embed-text';
+
+    const response = await this.client.embeddings({
+      model: modelName,
+      prompt: text,
+      options: {
+        temperature: options.temperature || 0.0
+      }
+    });
+
+    return {
+      embedding: response.embedding,
+      model: modelName,
+      tokens: response.token_count || 0
+    };
+  }
+
+  // Ollama-specific helper methods
+  async getAvailableModels() {
+    if (!this.isAvailable()) return [];
+    try {
+      const response = await this.client.list();
+      return response.models.map(m => m.name);
+    } catch (error) {
+      // Only log connection errors in development mode or when explicitly used
+      if (!this._connectionErrorLogged && (process.env.NODE_ENV === 'development' || process.env.DEBUG)) {
+        console.warn(`⚠️  Ollama connection failed: ${error.message}`);
+        console.warn(`💡 Make sure Ollama is running: ollama serve`);
+        this._connectionErrorLogged = true;
+      }
+      return [];
+    }
+  }
+
+  async pullModel(modelName) {
+    if (!this.isAvailable()) {
+      throw new ProviderError('Ollama provider is not configured', 'ollama', 'isAvailable');
+    }
+
+    try {
+      const pullStream = await this.client.pull({ model: modelName, stream: true });
+      return { stream: pullStream, model: modelName };
+    } catch (error) {
+      throw new ProviderError(`Failed to pull model ${modelName}: ${error.message}`, 'ollama', 'pullModel', error, { modelName });
+    }
+  }
+}
+
+// Apply mixins to add standard provider functionality
+export default applyMixins(OllamaProvider, 'ollama');