@entro314labs/ai-changelog-generator 3.0.5 → 3.2.0

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

@@ -3,22 +3,18 @@
  * Used for testing without real API credentials
  */
 
-import { BaseProvider } from '../core/base-provider.js';
-import { ProviderError } from '../../../shared/utils/utils.js';
+import { ProviderError } from '../../../shared/utils/utils.js'
+import { BaseProvider } from '../core/base-provider.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'
-    ];
+    super(config)
+    this.name = 'mock'
+    this.mockResponses = config.MOCK_RESPONSES || {}
+    this.shouldFail = config.MOCK_SHOULD_FAIL === 'true'
+    this.failureRate = Number.parseFloat(config.MOCK_FAILURE_RATE || '0.1')
+    this.latency = Number.parseInt(config.MOCK_LATENCY || '500', 10)
+    this.models = ['mock-basic', 'mock-standard', 'mock-advanced']
   }
 
   /**
@@ -26,7 +22,7 @@ class MockProvider extends BaseProvider {
    * @returns {string} Provider name
    */
   getName() {
-    return this.name;
+    return this.name
   }
 
   /**
@@ -34,7 +30,7 @@ class MockProvider extends BaseProvider {
    * @returns {boolean} Always true for mock provider
    */
   isAvailable() {
-    return true;
+    return true
   }
 
   /**
@@ -43,7 +39,7 @@ class MockProvider extends BaseProvider {
    * @returns {Promise} - Promise that resolves after delay
    */
   async _simulateLatency() {
-    return new Promise(resolve => setTimeout(resolve, this.latency));
+    return new Promise((resolve) => setTimeout(resolve, this.latency))
   }
 
   /**
@@ -52,9 +48,9 @@ class MockProvider extends BaseProvider {
    */
   _shouldFailOperation() {
     if (this.shouldFail) {
-      return true;
+      return true
     }
-    return Math.random() < this.failureRate;
+    return Math.random() < this.failureRate
   }
 
   /**
@@ -64,7 +60,7 @@ class MockProvider extends BaseProvider {
    * @returns {Promise} - Promise that resolves with mock completion
    */
   async generateCompletion(messages, options = {}) {
-    await this._simulateLatency();
+    await this._simulateLatency()
 
     if (this._shouldFailOperation()) {
       throw new ProviderError(
@@ -72,22 +68,20 @@ class MockProvider extends BaseProvider {
         '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 || '');
+    const model = options.model || 'mock-standard'
+    const lastMessage = messages.at(-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
-      };
+        model,
+      }
     }
 
     // Generate mock response based on commit convention if it looks like a commit message
@@ -95,16 +89,16 @@ class MockProvider extends BaseProvider {
       return {
         content: this._generateMockChangelog(prompt),
         tokens: 150,
-        model: model
-      };
+        model,
+      }
     }
 
     // Default mock response
     return {
       content: `This is a mock response from the ${model} model.`,
       tokens: 10,
-      model: model
-    };
+      model,
+    }
   }
 
   /**
@@ -113,15 +107,17 @@ class MockProvider extends BaseProvider {
    * @returns {string} - Mock changelog entry
    */
   _generateMockChangelog(commitMessage) {
-    const typeMatch = commitMessage.match(/^(feat|fix|docs|style|refactor|perf|test|build|ci|chore)(\(.+\))?:/);
+    const typeMatch = commitMessage.match(
+      /^(feat|fix|docs|style|refactor|perf|test|build|ci|chore)(\(.+\))?:/
+    )
 
     if (!typeMatch) {
-      return 'Mock changelog entry for conventional commit';
+      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 type = typeMatch[1]
+    const scope = typeMatch[2] ? typeMatch[2].replace(/[()]/g, '') : ''
+    const description = commitMessage.split(':')[1]?.trim() || ''
 
     const typeMap = {
       feat: 'Feature',
@@ -133,11 +129,11 @@ class MockProvider extends BaseProvider {
       test: 'Tests',
       build: 'Build',
       ci: 'CI',
-      chore: 'Chore'
-    };
+      chore: 'Chore',
+    }
 
-    const title = `${typeMap[type]}${scope ? ` (${scope})` : ''}`;
-    return `### ${title}\n\n- ${description}\n`;
+    const title = `${typeMap[type]}${scope ? ` (${scope})` : ''}`
+    return `### ${title}\n\n- ${description}\n`
   }
 
   /**
@@ -149,29 +145,29 @@ class MockProvider extends BaseProvider {
     if (!commitInfo.message) {
       return {
         model: 'mock-standard',
-        reason: 'Default model selected due to insufficient commit information'
-      };
+        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);
+    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) {
+        reason: 'Complex commit detected, using advanced model',
+      }
+    }
+    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'
-      };
+        reason: 'Moderate commit detected, using standard model',
+      }
+    }
+    return {
+      model: 'mock-basic',
+      reason: 'Simple commit detected, using basic model',
     }
   }
 
@@ -181,23 +177,23 @@ class MockProvider extends BaseProvider {
    * @returns {Promise} - Promise that resolves with validation result
    */
   async validateModelAvailability(model) {
-    await this._simulateLatency();
+    await this._simulateLatency()
 
     if (this._shouldFailOperation()) {
       return {
         available: false,
         error: 'Mock validation failure',
-        alternatives: this.models
-      };
+        alternatives: this.models,
+      }
     }
 
-    const isAvailable = this.models.includes(model);
+    const isAvailable = this.models.includes(model)
 
     return {
       available: isAvailable,
       model: isAvailable ? model : null,
-      alternatives: isAvailable ? [] : this.models
-    };
+      alternatives: isAvailable ? [] : this.models,
+    }
   }
 
   /**
@@ -205,22 +201,22 @@ class MockProvider extends BaseProvider {
    * @returns {Promise} - Promise that resolves with connection test result
    */
   async testConnection() {
-    await this._simulateLatency();
+    await this._simulateLatency()
 
     if (this._shouldFailOperation()) {
       return {
         success: false,
         error: 'Mock connection failure',
-        provider: this.getName()
-      };
+        provider: this.getName(),
+      }
     }
 
     return {
       success: true,
       provider: this.getName(),
       model: 'mock-standard',
-      response: 'Mock connection successful'
-    };
+      response: 'Mock connection successful',
+    }
   }
 
   /**
@@ -232,8 +228,8 @@ class MockProvider extends BaseProvider {
       streaming: false,
       tool_use: true,
       vision: false,
-      json_mode: true
-    };
+      json_mode: true,
+    }
   }
 
   getAvailableModels() {
@@ -246,7 +242,7 @@ class MockProvider extends BaseProvider {
         inputCost: 0,
         outputCost: 0,
         features: ['text', 'testing'],
-        description: 'Basic mock model for simple testing'
+        description: 'Basic mock model for simple testing',
       },
       {
         id: 'mock-standard',
@@ -256,7 +252,7 @@ class MockProvider extends BaseProvider {
         inputCost: 0,
         outputCost: 0,
         features: ['text', 'tools', 'testing'],
-        description: 'Standard mock model for moderate testing'
+        description: 'Standard mock model for moderate testing',
       },
       {
         id: 'mock-advanced',
@@ -266,10 +262,10 @@ class MockProvider extends BaseProvider {
         inputCost: 0,
         outputCost: 0,
         features: ['text', 'tools', 'json', 'testing'],
-        description: 'Advanced mock model for complex testing scenarios'
-      }
-    ];
+        description: 'Advanced mock model for complex testing scenarios',
+      },
+    ]
   }
 }
 
-export default MockProvider;
+export default MockProvider

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

@@ -1,34 +1,37 @@
-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';
+import process from 'node:process'
+
+import { Ollama } from 'ollama'
+
+import { ProviderError } from '../../../shared/utils/utils.js'
+import { BaseProvider } from '../core/base-provider.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;
+    super(config)
+    this.client = null
     if (this.isAvailable()) {
-      this.initializeClient();
+      this.initializeClient()
     }
   }
 
   initializeClient() {
     const clientOptions = buildClientOptions(this.getProviderConfig(), {
-      host: 'http://localhost:11434'
-    });
+      host: 'http://localhost:11434',
+    })
 
     this.client = new Ollama({
-      host: clientOptions.host
-    });
+      host: clientOptions.host,
+    })
   }
 
   getName() {
-    return 'ollama';
+    return 'ollama'
   }
 
   isAvailable() {
-    return !!this.config.OLLAMA_HOST;
+    return !!this.config.OLLAMA_HOST
   }
 
   async generateCompletion(messages, options = {}) {
@@ -36,116 +39,136 @@ class OllamaProvider extends BaseProvider {
       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;
+          await this.client.list()
+          this._connectionTested = true
         } catch (connectionError) {
           return this.handleProviderError(
-            new Error(`Ollama server unreachable: ${connectionError.message}. Please run 'ollama serve' first.`),
+            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 || [],
-      },
-    };
+      const modelConfig = this.getProviderModelConfig()
+      const modelName = options.model || modelConfig.standardModel
+
+      const params = {
+        model: modelName,
+        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.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 (
+        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 };
-    }
+      if (params.stream) {
+        const stream = await this.client.chat(params)
+        return { stream, model: modelName }
+      }
 
-      const response = await this.client.chat(params);
+      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 });
+      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');
+      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 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
-      }
-    });
+        temperature: options.temperature || 0.0,
+      },
+    })
 
     return {
       embedding: response.embedding,
       model: modelName,
-      tokens: response.token_count || 0
-    };
+      tokens: response.token_count || 0,
+    }
   }
 
   // Ollama-specific helper methods
   async getAvailableModels() {
-    if (!this.isAvailable()) return [];
+    if (!this.isAvailable()) {
+      return []
+    }
     try {
-      const response = await this.client.list();
-      return response.models.map(m => m.name);
+      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;
+      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 [];
+      return []
     }
   }
 
   async pullModel(modelName) {
     if (!this.isAvailable()) {
-      throw new ProviderError('Ollama provider is not configured', 'ollama', '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 };
+      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 });
+      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');
+export default applyMixins(OllamaProvider, 'ollama')