musubi-sdd 3.0.1 → 3.6.0

package/src/llm-providers/index.js

@@ -0,0 +1,214 @@
+/**
+ * @fileoverview LLM Provider Factory and Exports for MUSUBI Replanning Engine
+ * @module llm-providers
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { LLMProvider } = require('./base-provider');
+const { CopilotLMProvider } = require('./copilot-provider');
+const { AnthropicLMProvider } = require('./anthropic-provider');
+const { OpenAILMProvider } = require('./openai-provider');
+
+/**
+ * Provider priority order for auto-selection
+ * GitHub Copilot is preferred when available (in VS Code)
+ */
+const PROVIDER_PRIORITY = ['github-copilot', 'anthropic', 'openai'];
+
+/**
+ * Create an LLM provider instance
+ * @param {string} [provider='auto'] - Provider name or 'auto' for automatic selection
+ * @param {Object} [config={}] - Provider configuration
+ * @returns {LLMProvider} Configured provider instance
+ * @throws {Error} If no provider is available
+ */
+function createLLMProvider(provider = 'auto', config = {}) {
+  if (provider === 'auto') {
+    return createAutoProvider(config);
+  }
+
+  return createNamedProvider(provider, config);
+}
+
+/**
+ * Automatically select the best available provider
+ * @param {Object} config - Provider configuration
+ * @returns {LLMProvider} Best available provider
+ * @private
+ */
+function createAutoProvider(config) {
+  // Try providers in priority order
+  for (const providerName of PROVIDER_PRIORITY) {
+    try {
+      const provider = createNamedProvider(providerName, config);
+      
+      // Check if provider can be used
+      if (providerName === 'github-copilot') {
+        // Copilot is available in VS Code context or with token
+        try {
+          require('vscode');
+          return provider;
+        } catch (e) {
+          if (process.env.GITHUB_COPILOT_TOKEN) {
+            return provider;
+          }
+        }
+      } else if (providerName === 'anthropic' && process.env.ANTHROPIC_API_KEY) {
+        return provider;
+      } else if (providerName === 'openai' && process.env.OPENAI_API_KEY) {
+        return provider;
+      }
+    } catch (e) {
+      // Continue to next provider
+    }
+  }
+
+  throw new Error(
+    'No LLM provider available. Please configure one of:\n' +
+    '  - Run inside VS Code with GitHub Copilot extension\n' +
+    '  - Set GITHUB_COPILOT_TOKEN environment variable\n' +
+    '  - Set ANTHROPIC_API_KEY environment variable\n' +
+    '  - Set OPENAI_API_KEY environment variable'
+  );
+}
+
+/**
+ * Create a specific named provider
+ * @param {string} name - Provider name
+ * @param {Object} config - Provider configuration
+ * @returns {LLMProvider} Provider instance
+ * @private
+ */
+function createNamedProvider(name, config) {
+  switch (name.toLowerCase()) {
+    case 'github-copilot':
+    case 'copilot':
+      return new CopilotLMProvider(config);
+    
+    case 'anthropic':
+    case 'claude':
+      return new AnthropicLMProvider(config);
+    
+    case 'openai':
+    case 'gpt':
+      return new OpenAILMProvider(config);
+    
+    default:
+      throw new Error(`Unknown LLM provider: ${name}`);
+  }
+}
+
+/**
+ * Get list of available providers based on current environment
+ * @returns {Promise<Array<{name: string, available: boolean, info: Object}>>}
+ */
+async function getAvailableProviders() {
+  const results = [];
+
+  const providers = [
+    { name: 'github-copilot', class: CopilotLMProvider },
+    { name: 'anthropic', class: AnthropicLMProvider },
+    { name: 'openai', class: OpenAILMProvider }
+  ];
+
+  for (const { name, class: ProviderClass } of providers) {
+    try {
+      const provider = new ProviderClass();
+      const available = await provider.isAvailable();
+      results.push({
+        name,
+        available,
+        info: provider.getInfo()
+      });
+    } catch (e) {
+      results.push({
+        name,
+        available: false,
+        error: e.message
+      });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Mock LLM Provider for testing
+ * Returns predefined responses
+ */
+class MockLLMProvider extends LLMProvider {
+  constructor(config = {}) {
+    super(config);
+    this.name = 'mock';
+    this.responses = config.responses || [];
+    this.responseIndex = 0;
+  }
+
+  async initialize() {
+    this.isInitialized = true;
+  }
+
+  async complete(prompt, options = {}) {
+    const response = this.responses[this.responseIndex] || {
+      content: JSON.stringify({
+        analysis: 'Mock analysis',
+        goal: 'Mock goal',
+        alternatives: [
+          {
+            id: 'mock-alt-1',
+            description: 'Mock alternative',
+            task: { name: 'mock-task', skill: 'mock-skill', parameters: {} },
+            confidence: 0.85,
+            reasoning: 'Mock reasoning',
+            risks: []
+          }
+        ]
+      })
+    };
+
+    this.responseIndex = (this.responseIndex + 1) % Math.max(1, this.responses.length);
+
+    return {
+      content: typeof response.content === 'string' ? response.content : JSON.stringify(response.content),
+      model: 'mock-model',
+      usage: { promptTokens: 100, completionTokens: 50, totalTokens: 150 },
+      finishReason: 'stop'
+    };
+  }
+
+  async embed(text) {
+    // Return a fixed-dimension embedding
+    return new Array(1536).fill(0).map(() => Math.random());
+  }
+
+  async isAvailable() {
+    return true;
+  }
+
+  /**
+   * Set mock responses
+   * @param {Array<Object>} responses - Array of mock responses
+   */
+  setResponses(responses) {
+    this.responses = responses;
+    this.responseIndex = 0;
+  }
+}
+
+module.exports = {
+  // Factory function
+  createLLMProvider,
+  getAvailableProviders,
+  
+  // Provider classes
+  LLMProvider,
+  CopilotLMProvider,
+  AnthropicLMProvider,
+  OpenAILMProvider,
+  MockLLMProvider,
+  
+  // Constants
+  PROVIDER_PRIORITY
+};

package/src/llm-providers/openai-provider.js

@@ -0,0 +1,205 @@
+/**
+ * @fileoverview OpenAI GPT API Provider for MUSUBI Replanning Engine
+ * @module llm-providers/openai-provider
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { LLMProvider } = require('./base-provider');
+
+/**
+ * OpenAI GPT API Provider
+ * Fallback provider with embedding support
+ */
+class OpenAILMProvider extends LLMProvider {
+  /**
+   * Create an OpenAI provider
+   * @param {Object} config - Provider configuration
+   * @param {string} [config.apiKey] - OpenAI API key
+   * @param {string} [config.model='gpt-4o'] - Model to use for completion
+   * @param {string} [config.embeddingModel='text-embedding-3-small'] - Model for embeddings
+   */
+  constructor(config = {}) {
+    super(config);
+    this.name = 'openai';
+    this.apiKey = config.apiKey || process.env.OPENAI_API_KEY;
+    this.config.model = config.model || 'gpt-4o';
+    this.config.embeddingModel = config.embeddingModel || 'text-embedding-3-small';
+    this.endpoint = config.endpoint || 'https://api.openai.com/v1';
+    this.rateLimiter = this.createRateLimiter(60); // 60 RPM default
+  }
+
+  /**
+   * Initialize the OpenAI provider
+   * @returns {Promise<void>}
+   */
+  async initialize() {
+    if (!this.apiKey) {
+      throw new Error('OpenAI API key not found. Set OPENAI_API_KEY environment variable.');
+    }
+    this.isInitialized = true;
+  }
+
+  /**
+   * Complete a prompt using OpenAI GPT API
+   * @param {string} prompt - The prompt to complete
+   * @param {Object} [options={}] - Completion options
+   * @returns {Promise<LLMCompletionResult>} Completion result
+   */
+  async complete(prompt, options = {}) {
+    if (!this.isInitialized) {
+      await this.initialize();
+    }
+
+    const systemPrompt = options.systemPrompt || this.getDefaultSystemPrompt();
+    const messages = this.formatMessages(systemPrompt, prompt);
+
+    return this.rateLimiter(async () => {
+      return this.retryWithBackoff(async () => {
+        const response = await fetch(`${this.endpoint}/chat/completions`, {
+          method: 'POST',
+          headers: {
+            'Authorization': `Bearer ${this.apiKey}`,
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify({
+            model: this.config.model,
+            messages,
+            max_tokens: options.maxTokens || this.config.maxTokens,
+            temperature: options.temperature || this.config.temperature,
+            response_format: options.jsonMode ? { type: 'json_object' } : undefined
+          }),
+          signal: AbortSignal.timeout(this.config.timeout)
+        });
+
+        if (!response.ok) {
+          const error = await response.text();
+          throw new Error(`OpenAI API error: ${response.status} - ${error}`);
+        }
+
+        const data = await response.json();
+
+        return {
+          content: data.choices[0].message.content,
+          model: data.model,
+          usage: {
+            promptTokens: data.usage?.prompt_tokens || 0,
+            completionTokens: data.usage?.completion_tokens || 0,
+            totalTokens: data.usage?.total_tokens || 0
+          },
+          finishReason: data.choices[0].finish_reason
+        };
+      });
+    });
+  }
+
+  /**
+   * Generate embeddings using OpenAI Embedding API
+   * @param {string} text - Text to embed
+   * @returns {Promise<number[]>} Embedding vector
+   */
+  async embed(text) {
+    if (!this.isInitialized) {
+      await this.initialize();
+    }
+
+    return this.rateLimiter(async () => {
+      return this.retryWithBackoff(async () => {
+        const response = await fetch(`${this.endpoint}/embeddings`, {
+          method: 'POST',
+          headers: {
+            'Authorization': `Bearer ${this.apiKey}`,
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify({
+            model: this.config.embeddingModel,
+            input: text
+          }),
+          signal: AbortSignal.timeout(this.config.timeout)
+        });
+
+        if (!response.ok) {
+          const error = await response.text();
+          throw new Error(`OpenAI Embedding API error: ${response.status} - ${error}`);
+        }
+
+        const data = await response.json();
+        return data.data[0].embedding;
+      });
+    });
+  }
+
+  /**
+   * Check if the provider is available
+   * @returns {Promise<boolean>}
+   */
+  async isAvailable() {
+    if (!this.apiKey) {
+      return false;
+    }
+
+    try {
+      // Simple validation - check if API key format is valid
+      // OpenAI API keys start with 'sk-'
+      return this.apiKey.startsWith('sk-') && this.apiKey.length > 20;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  /**
+   * Get provider information
+   * @returns {ProviderInfo}
+   */
+  getInfo() {
+    return {
+      name: this.name,
+      model: this.config.model,
+      embeddingModel: this.config.embeddingModel,
+      isInitialized: this.isInitialized,
+      capabilities: {
+        completion: true,
+        embedding: true,
+        streaming: true,
+        functionCalling: true,
+        jsonMode: true
+      }
+    };
+  }
+
+  /**
+   * Get default system prompt for replanning
+   * @returns {string}
+   * @private
+   */
+  getDefaultSystemPrompt() {
+    return `You are an AI assistant helping with task replanning in a software development workflow.
+Your role is to analyze failed tasks, understand the goal, and generate alternative approaches.
+
+Guidelines:
+1. Be concise and specific in your recommendations
+2. Prioritize practical, actionable alternatives
+3. Consider resource constraints and dependencies
+4. Provide confidence scores for each alternative (0.0 to 1.0)
+5. Explain the reasoning behind each suggestion
+
+When generating alternatives, output valid JSON with this structure:
+{
+  "analysis": "Brief analysis of the failure",
+  "goal": "Extracted goal from the task",
+  "alternatives": [
+    {
+      "id": "alt-1",
+      "description": "Alternative approach",
+      "task": { "name": "task-name", "skill": "skill-name", "parameters": {} },
+      "confidence": 0.8,
+      "reasoning": "Why this might work",
+      "risks": ["potential risk"]
+    }
+  ]
+}`;
+  }
+}
+
+module.exports = { OpenAILMProvider };