@entro314labs/ai-changelog-generator 3.1.1 → 3.2.0

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

@@ -4,40 +4,40 @@
  * Supports multi-provider routing, chat completion, and latest models
  */
 
-import { InferenceClient } from '@huggingface/inference';
-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 { InferenceClient } from '@huggingface/inference'
+
+import { BaseProvider } from '../core/base-provider.js'
+import { applyMixins } from '../utils/base-provider-helpers.js'
+import { buildClientOptions } from '../utils/provider-utils.js'
 
 class HuggingFaceProvider 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(), {
-      timeout: 60000
-    });
+      timeout: 60000,
+    })
 
     this.client = new InferenceClient({
       token: clientOptions.apiKey,
       endpointUrl: clientOptions.endpointUrl,
-      timeout: clientOptions.timeout
-    });
+      timeout: clientOptions.timeout,
+    })
   }
 
   getName() {
-    return 'huggingface';
+    return 'huggingface'
   }
 
   isAvailable() {
-    return !!this.config.HUGGINGFACE_API_KEY;
+    return !!this.config.HUGGINGFACE_API_KEY
   }
 
   async generateCompletion(messages, options = {}) {
@@ -45,13 +45,13 @@ class HuggingFaceProvider extends BaseProvider {
       return this.handleProviderError(
         new Error('Hugging Face provider is not configured'),
         'generate_completion'
-      );
+      )
     }
 
     try {
-      const modelConfig = this.getProviderModelConfig();
-      const modelId = options.model || modelConfig.standardModel;
-      const provider = options.provider || 'auto';
+      const modelConfig = this.getProviderModelConfig()
+      const modelId = options.model || modelConfig.standardModel
+      const provider = options.provider || 'auto'
 
       const params = {
         model: modelId,
@@ -59,34 +59,34 @@ class HuggingFaceProvider extends BaseProvider {
         max_tokens: options.max_tokens || 1000,
         temperature: options.temperature || 0.3,
         top_p: options.top_p || 0.95,
-        stream: false
-      };
+        stream: false,
+      }
 
       if (provider && provider !== 'auto') {
-        params.provider = provider;
+        params.provider = provider
       }
 
       if (options.tools && this.getCapabilities(modelId).function_calling) {
-        params.tools = this.formatTools(options.tools);
-        params.tool_choice = options.tool_choice || 'auto';
+        params.tools = this.formatTools(options.tools)
+        params.tool_choice = options.tool_choice || 'auto'
       }
 
       if (options.stream && typeof options.onStreamData === 'function') {
-        params.stream = true;
+        params.stream = true
 
-        let fullContent = '';
-        const stream = this.client.chatCompletionStream(params);
+        let fullContent = ''
+        const stream = this.client.chatCompletionStream(params)
 
         for await (const chunk of stream) {
-          const chunkContent = chunk.choices[0]?.delta?.content || '';
+          const chunkContent = chunk.choices[0]?.delta?.content || ''
           if (chunkContent) {
-            fullContent += chunkContent;
+            fullContent += chunkContent
             options.onStreamData({
               content: chunkContent,
               model: modelId,
               finish_reason: null,
-              done: false
-            });
+              done: false,
+            })
           }
 
           if (chunk.choices[0]?.finish_reason) {
@@ -94,9 +94,9 @@ class HuggingFaceProvider extends BaseProvider {
               content: '',
               model: modelId,
               finish_reason: chunk.choices[0].finish_reason,
-              done: true
-            });
-            break;
+              done: true,
+            })
+            break
           }
         }
 
@@ -104,77 +104,78 @@ class HuggingFaceProvider extends BaseProvider {
           content: fullContent,
           model: modelId,
           tokens: this.estimateTokenCount(fullContent),
-          finish_reason: 'stop'
-        };
+          finish_reason: 'stop',
+        }
       }
 
-      const response = await this.client.chatCompletion(params);
+      const response = await this.client.chatCompletion(params)
 
-      const choice = response.choices[0];
-      const content = choice.message.content;
+      const choice = response.choices[0]
+      const content = choice.message.content
 
-      const toolCalls = choice.message.tool_calls ?
-        choice.message.tool_calls.map(call => ({
-          id: call.id,
-          type: call.type,
-          function: {
-            name: call.function.name,
-            arguments: call.function.arguments
-          }
-        })) : undefined;
+      const toolCalls = choice.message.tool_calls
+        ? choice.message.tool_calls.map((call) => ({
+            id: call.id,
+            type: call.type,
+            function: {
+              name: call.function.name,
+              arguments: call.function.arguments,
+            },
+          }))
+        : undefined
 
       return {
-        content: content,
+        content,
         model: response.model || modelId,
         tokens: response.usage?.total_tokens || this.estimateTokenCount(content),
         finish_reason: choice.finish_reason || 'stop',
-        tool_calls: toolCalls
-      };
+        tool_calls: toolCalls,
+      }
     } catch (error) {
       if (error.message.includes('rate limit') || error.message.includes('quota')) {
-        console.warn('Hugging Face rate limit hit, implementing backoff...');
-        await this.sleep(2000);
+        console.warn('Hugging Face rate limit hit, implementing backoff...')
+        await this.sleep(2000)
       }
 
-      return this.handleProviderError(error, 'generate_completion', { model: options.model });
+      return this.handleProviderError(error, 'generate_completion', { model: options.model })
     }
   }
 
   // HuggingFace-specific helper methods
   formatMessages(messages) {
-    return messages.map(msg => {
+    return messages.map((msg) => {
       if (msg.role === 'system') {
-        return { role: 'system', content: msg.content };
+        return { role: 'system', content: msg.content }
       }
       return {
         role: msg.role === 'assistant' ? 'assistant' : 'user',
-        content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)
-      };
-    });
+        content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+      }
+    })
   }
 
   formatTools(tools) {
-    return tools.map(tool => {
+    return tools.map((tool) => {
       if (tool.type === 'function') {
         return {
           type: 'function',
           function: {
             name: tool.function.name,
             description: tool.function.description || '',
-            parameters: tool.function.parameters || {}
-          }
-        };
+            parameters: tool.function.parameters || {},
+          },
+        }
       }
-      return tool;
-    });
+      return tool
+    })
   }
 
   estimateTokenCount(text) {
-    return Math.ceil(text.length / 4);
+    return Math.ceil(text.length / 4)
   }
 
   sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
+    return new Promise((resolve) => setTimeout(resolve, ms))
   }
 
   getAvailableModels() {
@@ -189,7 +190,7 @@ class HuggingFaceProvider extends BaseProvider {
         outputCost: 0.000009,
         features: ['text', 'tools', 'multilingual'],
         description: 'Latest Qwen model with enhanced capabilities',
-        provider: 'auto'
+        provider: 'auto',
       },
       {
         id: 'meta-llama/Llama-3.3-70B-Instruct',
@@ -200,7 +201,7 @@ class HuggingFaceProvider extends BaseProvider {
         outputCost: 0.000006,
         features: ['text', 'tools', 'reasoning'],
         description: 'Latest Llama 3.3 with improved reasoning',
-        provider: 'together'
+        provider: 'together',
       },
       {
         id: 'meta-llama/Llama-3.1-405B-Instruct',
@@ -211,7 +212,7 @@ class HuggingFaceProvider extends BaseProvider {
         outputCost: 0.000015,
         features: ['text', 'tools', 'reasoning'],
         description: 'Most capable Llama model from Meta AI',
-        provider: 'replicate'
+        provider: 'replicate',
       },
       {
         id: 'mistralai/Mixtral-8x22B-Instruct-v0.1',
@@ -222,7 +223,7 @@ class HuggingFaceProvider extends BaseProvider {
         outputCost: 0.0000027,
         features: ['text', 'tools', 'multilingual'],
         description: 'Large mixture of experts model from Mistral',
-        provider: 'together'
+        provider: 'together',
       },
       {
         id: 'microsoft/WizardLM-2-8x22B',
@@ -233,28 +234,28 @@ class HuggingFaceProvider extends BaseProvider {
         outputCost: 0.000003,
         features: ['text', 'reasoning', 'complex_tasks'],
         description: 'Advanced reasoning model from Microsoft',
-        provider: 'sambanova'
+        provider: 'sambanova',
       },
       {
         id: 'black-forest-labs/FLUX.1-dev',
         name: 'FLUX.1 Dev',
         contextWindow: 0,
         maxOutput: 0,
-        inputCost: 0.000050,
-        outputCost: 0.000050,
+        inputCost: 0.00005,
+        outputCost: 0.00005,
         features: ['text_to_image', 'high_quality'],
         description: 'State-of-the-art text-to-image generation',
-        provider: 'replicate'
-      }
-    ];
+        provider: 'replicate',
+      },
+    ]
   }
 
   getDefaultModel() {
-    return 'Qwen/Qwen2.5-72B-Instruct';
+    return 'Qwen/Qwen2.5-72B-Instruct'
   }
 
   getRequiredEnvVars() {
-    return ['HUGGINGFACE_API_KEY'];
+    return ['HUGGINGFACE_API_KEY']
   }
 
   getProviderModelConfig() {
@@ -267,21 +268,27 @@ class HuggingFaceProvider extends BaseProvider {
       multilingualModel: 'mistralai/Mixtral-8x22B-Instruct-v0.1',
       default: 'Qwen/Qwen2.5-72B-Instruct',
       temperature: 0.3,
-      maxTokens: 1000
-    };
+      maxTokens: 1000,
+    }
   }
 
   getModelCapabilities(modelName) {
     return {
-      reasoning: modelName.includes('Llama-3') || modelName.includes('WizardLM') || modelName.includes('Qwen'),
+      reasoning:
+        modelName.includes('Llama-3') ||
+        modelName.includes('WizardLM') ||
+        modelName.includes('Qwen'),
       function_calling: modelName.includes('Instruct') && !modelName.includes('FLUX'),
       json_mode: true,
       multimodal: modelName.includes('FLUX'),
-      largeContext: modelName.includes('Llama-3.3') || modelName.includes('Mixtral') || modelName.includes('Qwen'),
+      largeContext:
+        modelName.includes('Llama-3.3') ||
+        modelName.includes('Mixtral') ||
+        modelName.includes('Qwen'),
       multilingual: modelName.includes('Qwen') || modelName.includes('Mixtral'),
       multiProvider: true,
-      imageGeneration: modelName.includes('FLUX')
-    };
+      imageGeneration: modelName.includes('FLUX'),
+    }
   }
 
   getCapabilities(modelName) {
@@ -292,10 +299,10 @@ class HuggingFaceProvider extends BaseProvider {
       json_mode: true,
       reasoning: modelName ? this.getModelCapabilities(modelName).reasoning : true,
       multimodal: modelName ? this.getModelCapabilities(modelName).multimodal : false,
-      multiProvider: true
-    };
+      multiProvider: true,
+    }
   }
 }
 
 // Apply mixins to add standard provider functionality
-export default applyMixins(HuggingFaceProvider, 'huggingface');
+export default applyMixins(HuggingFaceProvider, 'huggingface')

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

@@ -1,14 +1,15 @@
-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';
+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;
+    super(config)
+    this.client = null
     if (this.isAvailable()) {
-      this.initializeClient();
+      this.initializeClient()
     }
   }
 
@@ -17,71 +18,79 @@ class LMStudioProvider extends BaseProvider {
       baseURL: 'http://localhost:1234/v1',
       apiKey: 'lm-studio', // Not required by LM Studio
       timeout: 120000,
-      maxRetries: 2
-    });
-    
+      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';
+    return 'lmstudio'
   }
 
   isAvailable() {
-    return !!this.config.LMSTUDIO_API_BASE;
+    return !!this.config.LMSTUDIO_API_BASE
   }
 
   async generateCompletion(messages, options) {
     if (!this.isAvailable()) {
       return this.handleProviderError(
-        new Error('LM Studio provider is not configured'), 
+        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,
+      model:
+        options.model ||
+        this.config.AI_MODEL ||
+        this.config.LMSTUDIO_MODEL ||
+        this.config.LMSTUDIO_DEFAULT_MODEL ||
+        'local-model',
+      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
-    };
+      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';
+      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' };
+    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 };
+      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);
+    const response = await this.client.chat.completions.create(params)
 
     // Extract tool calls if present
-    let toolCalls = null;
+    let toolCalls = null
     if (response.choices[0]?.message?.tool_calls?.length > 0) {
-      toolCalls = response.choices[0].message.tool_calls;
+      toolCalls = response.choices[0].message.tool_calls
     }
 
     return {
@@ -89,54 +98,60 @@ class LMStudioProvider extends BaseProvider {
       model: response.model,
       tokens: response.usage?.total_tokens || 0,
       finish_reason: response.choices[0].finish_reason,
-      tool_calls: toolCalls
-    };
+      tool_calls: toolCalls,
+    }
   }
 
-
   getCapabilities(modelName) {
-    const model = modelName || this.config.AI_MODEL || this.config.LMSTUDIO_MODEL || this.config.LMSTUDIO_DEFAULT_MODEL || 'local-model';
-    
+    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
-    };
-    
+      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;
-      
+      capabilities.json_mode = true
+
       // Llama 3 models likely support function calling
       if (model.includes('3')) {
-        capabilities.tool_use = true;
+        capabilities.tool_use = true
       }
     }
-    
+
     // Mistral models
     else if (model.toLowerCase().includes('mistral')) {
-      capabilities.json_mode = true;
-      
+      capabilities.json_mode = true
+
       // Mixtral models likely have better reasoning
       if (model.toLowerCase().includes('mixtral')) {
-        capabilities.reasoning = true;
+        capabilities.reasoning = true
       }
     }
-    
+
     // Vision models
-    if (model.toLowerCase().includes('vision') || 
-        model.toLowerCase().includes('llava') || 
-        model.toLowerCase().includes('bakllava')) {
-      capabilities.vision = true;
+    if (
+      model.toLowerCase().includes('vision') ||
+      model.toLowerCase().includes('llava') ||
+      model.toLowerCase().includes('bakllava')
+    ) {
+      capabilities.vision = true
     }
-    
-    return capabilities;
+
+    return capabilities
   }
 
   getAvailableModels() {
@@ -146,10 +161,10 @@ class LMStudioProvider extends BaseProvider {
         name: 'Local Model (LM Studio)',
         contextWindow: 4096,
         maxOutput: 2048,
-        inputCost: 0,  // Local models are free
+        inputCost: 0, // Local models are free
         outputCost: 0,
         features: ['text', 'local'],
-        description: 'Local model running in LM Studio'
+        description: 'Local model running in LM Studio',
       },
       {
         id: 'llama-3-8b-instruct',
@@ -159,7 +174,7 @@ class LMStudioProvider extends BaseProvider {
         inputCost: 0,
         outputCost: 0,
         features: ['text', 'tools', 'local'],
-        description: 'Local Llama 3 8B instruction-tuned model'
+        description: 'Local Llama 3 8B instruction-tuned model',
       },
       {
         id: 'mistral-7b-instruct',
@@ -169,7 +184,7 @@ class LMStudioProvider extends BaseProvider {
         inputCost: 0,
         outputCost: 0,
         features: ['text', 'reasoning', 'local'],
-        description: 'Local Mistral 7B instruction-tuned model'
+        description: 'Local Mistral 7B instruction-tuned model',
       },
       {
         id: 'llava-1.5-7b',
@@ -179,11 +194,11 @@ class LMStudioProvider extends BaseProvider {
         inputCost: 0,
         outputCost: 0,
         features: ['text', 'vision', 'local'],
-        description: 'Local vision-language model'
-      }
-    ];
+        description: 'Local vision-language model',
+      },
+    ]
   }
 }
 
 // Apply mixins to add standard provider functionality
-export default applyMixins(LMStudioProvider, 'lmstudio');
+export default applyMixins(LMStudioProvider, 'lmstudio')