musubi-sdd 3.5.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 };

package/src/orchestration/index.js

@@ -71,6 +71,19 @@ const {
   createWorkflowOrchestrator
 } = require('./workflow-orchestrator');
 
+const {
+  ReplanningEngine,
+  PlanMonitor,
+  PlanEvaluator,
+  AlternativeGenerator,
+  ReplanHistory,
+  ReplanTrigger,
+  ReplanDecision,
+  defaultReplanningConfig,
+  mergeConfig: mergeReplanningConfig,
+  validateConfig: validateReplanningConfig
+} = require('./replanning');
+
 /**
  * Create a fully configured orchestration engine
  * with default patterns registered
@@ -161,6 +174,18 @@ module.exports = {
   SDDWorkflowTemplates,
   createWorkflowOrchestrator,
 
+  // Replanning Engine
+  ReplanningEngine,
+  PlanMonitor,
+  PlanEvaluator,
+  AlternativeGenerator,
+  ReplanHistory,
+  ReplanTrigger,
+  ReplanDecision,
+  defaultReplanningConfig,
+  mergeReplanningConfig,
+  validateReplanningConfig,
+
   // Constants
   PatternType,
   ExecutionStatus,

package/src/orchestration/patterns/swarm.js

@@ -3,6 +3,8 @@
  * 
  * Enables concurrent execution of multiple skills with
  * P-label task decomposition and dependency tracking.
+ * 
+ * v1.1.0: Added replanning support for dynamic task recovery
  */
 
 const { BasePattern } = require('../pattern-registry');
@@ -37,16 +39,18 @@ class SwarmPattern extends BasePattern {
       name: PatternType.SWARM,
       type: PatternType.SWARM,
       description: 'Execute multiple skills concurrently with dependency tracking',
-      version: '1.0.0',
-      tags: ['parallel', 'concurrent', 'swarm', 'distributed'],
+      version: '1.1.0',
+      tags: ['parallel', 'concurrent', 'swarm', 'distributed', 'replanning'],
       useCases: [
         'Parallel task execution',
         'Independent subtask processing',
         'Load distribution',
-        'Multi-perspective analysis'
+        'Multi-perspective analysis',
+        'Dynamic task recovery with replanning'
       ],
       complexity: 'high',
       supportsParallel: true,
+      supportsReplanning: true,
       requiresHuman: false
     });
 
@@ -58,6 +62,10 @@ class SwarmPattern extends BasePattern {
       retryAttempts: options.retryAttempts || 3,
       quorumThreshold: options.quorumThreshold || 0.5,
       priorityOrder: options.priorityOrder || [PLabel.P0, PLabel.P1, PLabel.P2, PLabel.P3],
+      // Replanning options
+      enableReplanning: options.enableReplanning || false,
+      replanningEngine: options.replanningEngine || null,
+      fallbackSkill: options.fallbackSkill || null,
       ...options
     };
   }
@@ -196,11 +204,48 @@ class SwarmPattern extends BasePattern {
               error: result.reason
             });
 
-            // Retry logic
+            // Try replanning if enabled
+            if (this.options.enableReplanning && this.options.replanningEngine) {
+              const alternative = await this._tryReplanning(
+                task,
+                result.reason,
+                engine,
+                context,
+                sharedContext,
+                results
+              );
+              
+              if (alternative) {
+                // Add alternative task to pending
+                pending.add(alternative.id || alternative.skill);
+                sortedTasks.push(alternative);
+                failed.delete(taskId);
+                
+                engine.emit('swarmTaskReplanned', {
+                  context,
+                  originalTaskId: taskId,
+                  alternativeTask: alternative
+                });
+                continue;
+              }
+            }
+
+            // Retry logic (fallback if replanning not available or failed)
             if (this.options.retryFailed && task.retryCount < this.options.retryAttempts) {
               task.retryCount = (task.retryCount || 0) + 1;
               pending.add(taskId);
               failed.delete(taskId);
+            } else if (this.options.fallbackSkill) {
+              // Use fallback skill
+              const fallbackTask = {
+                ...task,
+                skill: this.options.fallbackSkill,
+                id: `${taskId}-fallback`,
+                originalTaskId: taskId
+              };
+              pending.add(fallbackTask.id);
+              sortedTasks.push(fallbackTask);
+              failed.delete(taskId);
             }
           }
         }
@@ -318,6 +363,68 @@ class SwarmPattern extends BasePattern {
     });
   }
 
+  /**
+   * Try to replan a failed task using ReplanningEngine
+   * @param {Object} task - Failed task
+   * @param {Error} error - Error that caused failure
+   * @param {OrchestrationEngine} engine - Orchestration engine
+   * @param {ExecutionContext} context - Parent context
+   * @param {Object} sharedContext - Shared context
+   * @param {Map} previousResults - Previous results
+   * @returns {Promise<Object|null>} Alternative task or null
+   * @private
+   */
+  async _tryReplanning(task, error, engine, context, sharedContext, previousResults) {
+    const replanningEngine = this.options.replanningEngine;
+    
+    try {
+      // Create context for replanning
+      const replanContext = {
+        completed: [...previousResults.entries()].filter(([, v]) => !v.error).map(([id, result]) => ({
+          id,
+          result
+        })),
+        pending: [],
+        failed: [{
+          id: task.id || task.skill,
+          ...task,
+          error
+        }],
+        sharedContext
+      };
+
+      // Generate alternatives
+      const alternatives = await replanningEngine.generator.generateAlternatives(
+        { ...task, error },
+        replanContext
+      );
+
+      if (alternatives.length > 0) {
+        const best = alternatives[0];
+        
+        // Only use alternatives with sufficient confidence
+        if (best.confidence >= (replanningEngine.config.alternatives?.minConfidence || 0.5)) {
+          return {
+            ...best.task,
+            id: best.task.id || `${task.id || task.skill}-replan`,
+            priority: task.priority,
+            originalTaskId: task.id || task.skill,
+            replanSource: 'llm',
+            replanConfidence: best.confidence
+          };
+        }
+      }
+    } catch (replanError) {
+      engine.emit('swarmReplanFailed', {
+        context,
+        taskId: task.id || task.skill,
+        error: replanError
+      });
+    }
+
+    return null;
+  }
+
   /**
    * Check if swarm should exit early based on strategy
    * @private