@entro314labs/ai-changelog-generator 3.1.1 → 3.2.0

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

@@ -1,48 +1,48 @@
-import { OpenAI } from 'openai';
-import { BaseProvider } from '../core/base-provider.js';
-import { ProviderError } from '../../../shared/utils/utils.js';
-import { applyMixins, ProviderResponseHandler } from '../utils/base-provider-helpers.js';
-import { buildClientOptions } from '../utils/provider-utils.js';
+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) {
-    super(config);
-    this.openai = null;
+    super(config)
+    this.openai = null
     if (this.isAvailable()) {
-      this.initializeClient();
+      this.initializeClient()
     }
   }
 
   initializeClient() {
     const clientOptions = buildClientOptions(this.getProviderConfig(), {
       timeout: 60000,
-      maxRetries: 2
-    });
+      maxRetries: 2,
+    })
 
     this.openai = new OpenAI({
       apiKey: clientOptions.apiKey,
       organization: clientOptions.organization,
       project: clientOptions.project,
       timeout: clientOptions.timeout,
-      maxRetries: clientOptions.maxRetries
-    });
+      maxRetries: clientOptions.maxRetries,
+    })
   }
 
   getName() {
-    return 'openai';
+    return 'openai'
   }
 
   isAvailable() {
-    const apiKey = this.config.OPENAI_API_KEY;
-    return apiKey && apiKey.trim() !== '' && apiKey.startsWith('sk-');
+    const apiKey = this.config.OPENAI_API_KEY
+    return apiKey && apiKey.trim() !== '' && apiKey.startsWith('sk-')
   }
 
   getRequiredEnvVars() {
-    return ['OPENAI_API_KEY'];
+    return ['OPENAI_API_KEY']
   }
 
   getDefaultModel() {
-    return 'gpt-4o';
+    return 'gpt-4o'
   }
 
   async generateCompletion(messages, options = {}) {
@@ -50,28 +50,28 @@ export class OpenAIProvider extends BaseProvider {
       this,
       'generate_completion',
       async () => {
-        const modelConfig = this.getProviderModelConfig();
+        const modelConfig = this.getProviderModelConfig()
         const params = {
           model: options.model || modelConfig.standardModel || this.getDefaultModel(),
           messages,
           max_tokens: options.max_tokens || 1000,
           temperature: options.temperature || 0.3,
-        };
+        }
 
         // Add tool calling if provided
         if (options.tools) {
-          params.tools = options.tools;
-          params.tool_choice = options.tool_choice || 'auto';
+          params.tools = options.tools
+          params.tool_choice = options.tool_choice || 'auto'
         }
 
         // Add streaming if requested
         if (options.stream) {
-          params.stream = true;
-          const stream = await this.openai.chat.completions.create(params);
-          return { stream, model: params.model };
+          params.stream = true
+          const stream = await this.openai.chat.completions.create(params)
+          return { stream, model: params.model }
         }
 
-        const completion = await this.openai.chat.completions.create(params);
+        const completion = await this.openai.chat.completions.create(params)
 
         return {
           text: completion.choices[0].message.content,
@@ -80,32 +80,32 @@ export class OpenAIProvider extends BaseProvider {
           usage: completion.usage,
           tokens: completion.usage.total_tokens,
           finish_reason: completion.choices[0].finish_reason,
-          tool_calls: completion.choices[0].message.tool_calls
-        };
+          tool_calls: completion.choices[0].message.tool_calls,
+        }
       },
       { model: options.model }
-    );
+    )
   }
 
   async generateText(messages, model = null) {
-    const response = await this.generateCompletion(messages, { model });
-    return response;
+    const response = await this.generateCompletion(messages, { model })
+    return response
   }
 
   async getAvailableModels() {
     try {
-      const models = await this.openai.models.list();
+      const models = await this.openai.models.list()
       return models.data
-        .filter(m => m.id.includes('gpt') || m.id.includes('o1'))
-        .map(m => ({
+        .filter((m) => m.id.includes('gpt') || m.id.includes('o1'))
+        .map((m) => ({
           name: m.id,
           id: m.id,
           description: `OpenAI ${m.id}`,
           contextWindow: this.getModelContextWindow(m.id),
-          capabilities: this.getModelCapabilities(m.id)
-        }));
-    } catch (error) {
-      return [];
+          capabilities: this.getModelCapabilities(m.id),
+        }))
+    } catch (_error) {
+      return []
     }
   }
 
@@ -114,7 +114,7 @@ export class OpenAIProvider extends BaseProvider {
       // Latest 2025 models
       'gpt-4o': 128000,
       'gpt-4o-mini': 128000,
-      'o1': 200000,
+      o1: 200000,
       'o1-mini': 128000,
       'gpt-4.1-nano': 200000,
       'gpt-4.1-mini': 200000,
@@ -126,9 +126,9 @@ export class OpenAIProvider extends BaseProvider {
       'gpt-4-turbo': 128000,
       'gpt-4-turbo-preview': 128000,
       'gpt-3.5-turbo': 4096,
-      'gpt-3.5-turbo-16k': 16384
-    };
-    return contextWindows[modelName] || 128000;
+      'gpt-3.5-turbo-16k': 16384,
+    }
+    return contextWindows[modelName] || 128000
   }
 
   getModelCapabilities(modelName) {
@@ -137,56 +137,56 @@ export class OpenAIProvider extends BaseProvider {
       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')
-    };
+      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);
+      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
-        };
-      } else {
-        const availableModels = models.map(m => m.name);
-        return {
-          available: false,
-          error: `Model '${modelName}' not available`,
-          alternatives: availableModels.slice(0, 5)
-        };
+          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']
-      };
+        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 });
+      const response = await this.generateCompletion([{ role: 'user', content: 'Hello' }], {
+        max_tokens: 5,
+      })
 
       return {
         success: true,
         model: response.model,
-        message: 'Connection successful'
-      };
+        message: 'Connection successful',
+      }
     } catch (error) {
       return {
         success: false,
-        error: error.message
-      };
+        error: error.message,
+      }
     }
   }
 
@@ -197,61 +197,60 @@ export class OpenAIProvider extends BaseProvider {
       function_calling: true,
       json_mode: true,
       reasoning: modelName ? modelName.includes('gpt-4') : true,
-      multimodal: false
-    };
+      multimodal: false,
+    }
   }
 
   getModelRecommendation(commitDetails) {
-    const { files = 0, lines = 0, breaking = false, complex = false } = 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'
-      };
+        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'
-      };
+        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'
-      };
+        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'
-    };
+      reason: 'Small change, using efficient modern model',
+    }
   }
 
   async selectOptimalModel(commitInfo) {
-    const recommendation = this.getModelRecommendation(commitInfo);
-    const validation = await this.validateModelAvailability(recommendation.model);
+    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
-      };
-    } else {
-      // Fallback to default model
-      return {
-        model: this.getDefaultModel(),
-        reason: 'Fallback to default model',
-        capabilities: this.getCapabilities(this.getDefaultModel())
-      };
+        capabilities: validation.capabilities,
+      }
+    }
+    // Fallback to default model
+    return {
+      model: this.getDefaultModel(),
+      reason: 'Fallback to default model',
+      capabilities: this.getCapabilities(this.getDefaultModel()),
     }
   }
 
@@ -264,10 +263,10 @@ export class OpenAIProvider extends BaseProvider {
       reasoningModel: 'o1',
       default: 'gpt-4o',
       temperature: 0.3,
-      maxTokens: 1000
-    };
+      maxTokens: 1000,
+    }
   }
 }
 
 // Apply mixins to add standard provider functionality
-export default applyMixins ? applyMixins(OpenAIProvider, 'openai') : OpenAIProvider;
+export default applyMixins ? applyMixins(OpenAIProvider, 'openai') : OpenAIProvider