@entro314labs/ai-changelog-generator 3.2.1 → 3.6.0

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

@@ -3,6 +3,7 @@ import { AzureOpenAI } from 'openai'
 
 import { BaseProvider } from '../core/base-provider.js'
 import { applyMixins, ProviderResponseHandler } from '../utils/base-provider-helpers.js'
+import { getProviderModelConfig } from '../utils/model-config.js'
 
 class AzureOpenAIProvider extends BaseProvider {
   constructor(config) {
@@ -168,59 +169,11 @@ class AzureOpenAIProvider extends BaseProvider {
 
   // Azure-specific helper methods
   getDeploymentName() {
-    return this.config.AZURE_OPENAI_DEPLOYMENT_NAME || this.getProviderModelConfig().standardModel
+    const modelConfig = this.getProviderModelConfig()
+    return this.config.AZURE_OPENAI_DEPLOYMENT_NAME || modelConfig.standardModel
   }
 
-  getModelContextWindow(modelName) {
-    const contextWindows = {
-      // Latest 2025 models (Azure exclusive)
-      o4: 500000,
-      'o4-mini': 200000,
-      o3: 300000,
-      'o3-mini': 150000,
-      // Standard 2025 models
-      'gpt-4o': 128000,
-      'gpt-4o-mini': 128000,
-      o1: 200000,
-      'o1-mini': 128000,
-      'gpt-4.1': 200000,
-      'gpt-4.1-mini': 200000,
-      'gpt-4.1-nano': 200000,
-      // Legacy models
-      'gpt-4': 8192,
-      'gpt-4-32k': 32768,
-      'gpt-4-turbo': 128000,
-      'gpt-35-turbo': 4096,
-      'gpt-35-turbo-16k': 16384,
-    }
-    return contextWindows[modelName] || 128000
-  }
-
-  getModelCapabilities(modelName) {
-    return {
-      reasoning:
-        modelName.includes('o1') ||
-        modelName.includes('o3') ||
-        modelName.includes('o4') ||
-        modelName.includes('gpt-4'),
-      function_calling: !(
-        modelName.includes('o1') ||
-        modelName.includes('o3') ||
-        modelName.includes('o4')
-      ), // o-series models don't support function calling
-      json_mode: true,
-      multimodal: modelName.includes('gpt-4o') || modelName.includes('gpt-4.1'),
-      largeContext:
-        modelName.includes('4.1') ||
-        modelName.includes('o1') ||
-        modelName.includes('o3') ||
-        modelName.includes('o4') ||
-        modelName.includes('4o'),
-      promptCaching: modelName.includes('4.1'),
-      advancedReasoning: modelName.includes('o3') || modelName.includes('o4'),
-      azureExclusive: modelName.includes('o3') || modelName.includes('o4'),
-    }
-  }
+  // Model capabilities now handled by centralized CapabilitiesMixin
 
   // Azure-specific method for testing deployment availability
   async testDeployment(deploymentName) {
@@ -257,19 +210,19 @@ class AzureOpenAIProvider extends BaseProvider {
       return this._cachedDeployments
     }
 
-    // Get base config directly to avoid recursion
-    const baseConfig = {
-      commonDeployments: ['o4', 'o3', 'gpt-4.1', 'gpt-4o', 'gpt-35-turbo', 'o1'],
-      fallbacks: ['gpt-4.1', 'gpt-4o', 'o1', 'gpt-35-turbo'],
-    }
+    // Get model config from centralized system (avoiding circular dependency)
+    const modelConfig = getProviderModelConfig('azure', this.config)
 
     const potentialDeployments = [
       // User configured deployment
       this.config.AZURE_OPENAI_DEPLOYMENT_NAME,
-      // Common deployment names
-      ...baseConfig.commonDeployments,
+      // Models from config
+      modelConfig.complexModel,
+      modelConfig.standardModel,
+      modelConfig.mediumModel,
+      modelConfig.smallModel,
       // Fallback models
-      ...baseConfig.fallbacks,
+      ...modelConfig.fallbacks,
     ]
       .filter(Boolean)
       .filter((v, i, a) => a.indexOf(v) === i) // Remove duplicates
@@ -294,16 +247,16 @@ class AzureOpenAIProvider extends BaseProvider {
 
       if (availableDeployments.length === 0) {
         console.warn('⚠️  No Azure deployments found. Using configured deployment name as fallback.')
-        // Fallback to configured deployment even if untested, preferring latest models
-        const fallback = this.config.AZURE_OPENAI_DEPLOYMENT_NAME || 'o4' || 'gpt-4.1'
+        // Fallback to configured deployment even if untested
+        const fallback = this.config.AZURE_OPENAI_DEPLOYMENT_NAME || modelConfig.standardModel
         return [fallback]
       }
 
       return availableDeployments
     } catch (error) {
       console.warn('⚠️  Failed to detect Azure deployments:', error.message)
-      // Return common deployments as fallback
-      return baseConfig.commonDeployments
+      // Return fallback models from config
+      return modelConfig.fallbacks
     }
   }
 

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

@@ -3,8 +3,9 @@
  * Fallback provider when no other providers are available
  */
 
-import { ProviderError } from '../../../shared/utils/utils.js'
+import { ProviderError } from '../../../shared/utils/error-classes.js'
 import { BaseProvider } from '../core/base-provider.js'
+import { applyMixins } from '../utils/base-provider-helpers.js'
 
 class DummyProvider extends BaseProvider {
   constructor(config = {}) {
@@ -12,22 +13,22 @@ class DummyProvider extends BaseProvider {
     this.name = 'dummy'
   }
 
-  /**
-   * Get provider name
-   * @returns {string} Provider name
-   */
   getName() {
     return this.name
   }
 
-  /**
-   * Check if provider is available
-   * @returns {boolean} Always true for dummy provider
-   */
   isAvailable() {
     return true
   }
 
+  getRequiredEnvVars() {
+    return []
+  }
+
+  getDefaultModel() {
+    return 'rule-based'
+  }
+
   /**
    * Generate completion (always fails with informative error)
    * @param {Array} messages - Messages for completion
@@ -93,20 +94,16 @@ class DummyProvider extends BaseProvider {
     }
   }
 
-  getAvailableModels() {
+  async getAvailableModels() {
     return [
       {
         id: 'rule-based',
         name: 'Rule-based Fallback',
-        contextWindow: 0,
-        maxOutput: 0,
-        inputCost: 0,
-        outputCost: 0,
-        features: [],
         description: 'No AI model available - configure a provider',
       },
     ]
   }
 }
 
-export default DummyProvider
+// Apply minimal mixins (error handling only - dummy provider doesn't need full functionality)
+export default applyMixins ? applyMixins(DummyProvider, 'dummy', []) : DummyProvider

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

@@ -3,8 +3,9 @@
  * Used for testing without real API credentials
  */
 
-import { ProviderError } from '../../../shared/utils/utils.js'
+import { ProviderError } from '../../../shared/utils/error-classes.js'
 import { BaseProvider } from '../core/base-provider.js'
+import { applyMixins } from '../utils/base-provider-helpers.js'
 
 class MockProvider extends BaseProvider {
   constructor(config = {}) {
@@ -17,22 +18,22 @@ class MockProvider extends BaseProvider {
     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
   }
 
+  getRequiredEnvVars() {
+    return []
+  }
+
+  getDefaultModel() {
+    return 'mock-standard'
+  }
+
   /**
    * Simulate network latency
    * @param {number} ms - Milliseconds to wait
@@ -232,40 +233,26 @@ class MockProvider extends BaseProvider {
     }
   }
 
-  getAvailableModels() {
+  async 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
+// Apply mixins for enhanced functionality
+export default applyMixins ? applyMixins(MockProvider, 'mock') : MockProvider

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

@@ -2,10 +2,9 @@ import process from 'node:process'
 
 import { Ollama } from 'ollama'
 
-import { ProviderError } from '../../../shared/utils/utils.js'
+import { ProviderError } from '../../../shared/utils/error-classes.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) {
@@ -17,12 +16,12 @@ class OllamaProvider extends BaseProvider {
   }
 
   initializeClient() {
-    const clientOptions = buildClientOptions(this.getProviderConfig(), {
+    const clientOptions = this.buildClientOptions({
       host: 'http://localhost:11434',
     })
 
     this.client = new Ollama({
-      host: clientOptions.host,
+      host: clientOptions.OLLAMA_HOST || clientOptions.host,
     })
   }
 
@@ -34,6 +33,15 @@ class OllamaProvider extends BaseProvider {
     return !!this.config.OLLAMA_HOST
   }
 
+  getRequiredEnvVars() {
+    return ['OLLAMA_HOST']
+  }
+
+  getDefaultModel() {
+    const modelConfig = this.getProviderModelConfig()
+    return modelConfig.standardModel
+  }
+
   async generateCompletion(messages, options = {}) {
     if (!this.isAvailable()) {
       return this.handleProviderError(

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

@@ -2,7 +2,6 @@ import { OpenAI } from 'openai'
 
 import { BaseProvider } from '../core/base-provider.js'
 import { applyMixins, ProviderResponseHandler } from '../utils/base-provider-helpers.js'
-import { buildClientOptions } from '../utils/provider-utils.js'
 
 export class OpenAIProvider extends BaseProvider {
   constructor(config) {
@@ -14,15 +13,15 @@ export class OpenAIProvider extends BaseProvider {
   }
 
   initializeClient() {
-    const clientOptions = buildClientOptions(this.getProviderConfig(), {
+    const clientOptions = this.buildClientOptions({
       timeout: 60000,
       maxRetries: 2,
     })
 
     this.openai = new OpenAI({
-      apiKey: clientOptions.apiKey,
-      organization: clientOptions.organization,
-      project: clientOptions.project,
+      apiKey: clientOptions.OPENAI_API_KEY,
+      organization: clientOptions.OPENAI_ORGANIZATION,
+      project: clientOptions.OPENAI_PROJECT,
       timeout: clientOptions.timeout,
       maxRetries: clientOptions.maxRetries,
     })
@@ -42,7 +41,8 @@ export class OpenAIProvider extends BaseProvider {
   }
 
   getDefaultModel() {
-    return 'gpt-4o'
+    const modelConfig = this.getProviderModelConfig()
+    return modelConfig.standardModel
   }
 
   async generateCompletion(messages, options = {}) {
@@ -101,171 +101,19 @@ export class OpenAIProvider extends BaseProvider {
           name: m.id,
           id: m.id,
           description: `OpenAI ${m.id}`,
-          contextWindow: this.getModelContextWindow(m.id),
-          capabilities: this.getModelCapabilities(m.id),
         }))
     } catch (_error) {
       return []
     }
   }
 
-  getModelContextWindow(modelName) {
-    const contextWindows = {
-      // Latest 2025 models
-      'gpt-4o': 128000,
-      'gpt-4o-mini': 128000,
-      o1: 200000,
-      'o1-mini': 128000,
-      'gpt-4.1-nano': 200000,
-      'gpt-4.1-mini': 200000,
-      'gpt-4.1': 200000,
-      // Note: o3/o4 are Azure-only models
-      // Legacy models
-      'gpt-4': 8192,
-      'gpt-4-32k': 32768,
-      'gpt-4-turbo': 128000,
-      'gpt-4-turbo-preview': 128000,
-      'gpt-3.5-turbo': 4096,
-      'gpt-3.5-turbo-16k': 16384,
-    }
-    return contextWindows[modelName] || 128000
-  }
-
-  getModelCapabilities(modelName) {
-    return {
-      reasoning: modelName.includes('o1') || modelName.includes('gpt-4'),
-      function_calling: !modelName.includes('o1'), // o1 models don't support function calling
-      json_mode: true,
-      multimodal: modelName.includes('gpt-4o') || modelName.includes('gpt-4.1'),
-      largeContext:
-        modelName.includes('4.1') || modelName.includes('o1') || modelName.includes('4o'),
-      promptCaching: modelName.includes('4.1'),
-    }
-  }
-
-  async validateModelAvailability(modelName) {
-    try {
-      const models = await this.getAvailableModels()
-      const model = models.find((m) => m.name === modelName)
-
-      if (model) {
-        return {
-          available: true,
-          model: modelName,
-          capabilities: model.capabilities,
-          contextWindow: model.contextWindow,
-        }
-      }
-      const availableModels = models.map((m) => m.name)
-      return {
-        available: false,
-        error: `Model '${modelName}' not available`,
-        alternatives: availableModels.slice(0, 5),
-      }
-    } catch (error) {
-      return {
-        available: false,
-        error: error.message,
-        alternatives: ['gpt-4o', 'gpt-4o-mini', 'o1-mini', 'o1', 'gpt-4'],
-      }
-    }
-  }
-
-  async testConnection() {
-    try {
-      const response = await this.generateCompletion([{ role: 'user', content: 'Hello' }], {
-        max_tokens: 5,
-      })
-
-      return {
-        success: true,
-        model: response.model,
-        message: 'Connection successful',
-      }
-    } catch (error) {
-      return {
-        success: false,
-        error: error.message,
-      }
-    }
-  }
-
-  getCapabilities(modelName) {
-    return {
-      completion: true,
-      streaming: true,
-      function_calling: true,
-      json_mode: true,
-      reasoning: modelName ? modelName.includes('gpt-4') : true,
-      multimodal: false,
-    }
-  }
-
-  getModelRecommendation(commitDetails) {
-    const { files = 0, lines = 0, breaking = false, complex = false } = commitDetails
-
-    // Use o1 for highly complex reasoning tasks
-    if (breaking || complex || files > 50 || lines > 5000) {
-      return {
-        model: 'o1-mini',
-        reason: 'Highly complex change requiring advanced reasoning',
-      }
-    }
-
-    // Use GPT-4o for complex changes
-    if (files > 20 || lines > 1000) {
-      return {
-        model: 'gpt-4o',
-        reason: 'Complex change requiring advanced analysis',
-      }
-    }
-
-    // Use GPT-4o mini for medium changes
-    if (files > 5 || lines > 200) {
-      return {
-        model: 'gpt-4o-mini',
-        reason: 'Medium-sized change requiring good analysis',
-      }
-    }
-
-    // Use GPT-4o mini for small changes (more capable than 3.5-turbo)
-    return {
-      model: 'gpt-4o-mini',
-      reason: 'Small change, using efficient modern model',
-    }
-  }
-
-  async selectOptimalModel(commitInfo) {
-    const recommendation = this.getModelRecommendation(commitInfo)
-    const validation = await this.validateModelAvailability(recommendation.model)
-
-    if (validation.available) {
-      return {
-        model: recommendation.model,
-        reason: recommendation.reason,
-        capabilities: validation.capabilities,
-      }
-    }
-    // Fallback to default model
-    return {
-      model: this.getDefaultModel(),
-      reason: 'Fallback to default model',
-      capabilities: this.getCapabilities(this.getDefaultModel()),
-    }
-  }
-
-  getProviderModelConfig() {
-    return {
-      smallModel: 'gpt-4o-mini',
-      mediumModel: 'gpt-4o',
-      standardModel: 'gpt-4o',
-      complexModel: 'o1-mini',
-      reasoningModel: 'o1',
-      default: 'gpt-4o',
-      temperature: 0.3,
-      maxTokens: 1000,
-    }
-  }
+  // All common methods now provided by mixins:
+  // - validateModelAvailability() from ModelValidationMixin
+  // - testConnection() from ConnectionTestMixin
+  // - getCapabilities() from CapabilitiesMixin
+  // - getModelRecommendation() from ModelRecommendationMixin
+  // - selectOptimalModel() from ModelRecommendationMixin
+  // - getProviderModelConfig() from ConfigurationMixin
 }
 
 // Apply mixins to add standard provider functionality