musubi-sdd 5.1.0 → 5.6.1

package/src/orchestration/replanning/replanning-engine.js

@@ -8,7 +8,12 @@
 'use strict';
 
 const EventEmitter = require('events');
-const { ReplanTrigger, ReplanDecision, mergeConfig, defaultReplanningConfig } = require('./config');
+const {
+  _ReplanTrigger,
+  ReplanDecision,
+  mergeConfig,
+  _defaultReplanningConfig,
+} = require('./config');
 const { PlanMonitor } = require('./plan-monitor');
 const { PlanEvaluator } = require('./plan-evaluator');
 const { AlternativeGenerator } = require('./alternative-generator');
@@ -26,26 +31,26 @@ class ReplanningEngine extends EventEmitter {
    */
   constructor(orchestrationEngine = null, options = {}) {
     super();
-    
+
     this.engine = orchestrationEngine;
     this.config = mergeConfig(options.config || options);
-    
+
     // Initialize components
     this.llmProvider = options.llmProvider || this.createLLMProvider();
     this.monitor = new PlanMonitor({ config: this.config });
     this.evaluator = new PlanEvaluator({ config: this.config.evaluation });
     this.generator = new AlternativeGenerator(this.llmProvider, {
       config: this.config.alternatives,
-      scorerConfig: this.config.evaluation
+      scorerConfig: this.config.evaluation,
     });
     this.history = new ReplanHistory({ config: this.config.history });
-    
+
     // State
     this.currentPlan = null;
     this.planVersion = 0;
     this.isExecuting = false;
     this.executionContext = null;
-    
+
     // Wire up monitor events
     this.setupMonitorEvents();
   }
@@ -63,13 +68,13 @@ class ReplanningEngine extends EventEmitter {
       console.warn('Failed to create LLM provider:', error.message);
       // Return a mock provider that warns on use
       return {
-        complete: async () => { 
-          throw new Error('No LLM provider available for replanning'); 
+        complete: async () => {
+          throw new Error('No LLM provider available for replanning');
         },
-        completeJSON: async () => { 
-          throw new Error('No LLM provider available for replanning'); 
+        completeJSON: async () => {
+          throw new Error('No LLM provider available for replanning');
         },
-        isAvailable: async () => false
+        isAvailable: async () => false,
       };
     }
   }
@@ -79,11 +84,11 @@ class ReplanningEngine extends EventEmitter {
    * @private
    */
   setupMonitorEvents() {
-    this.monitor.on('trigger', async (trigger) => {
+    this.monitor.on('trigger', async trigger => {
       if (this.config.integration?.emitEvents) {
         this.emit(`${this.config.integration.eventPrefix}:trigger`, trigger);
       }
-      
+
       // Handle the trigger
       try {
         await this.handleTrigger(trigger);
@@ -108,7 +113,7 @@ class ReplanningEngine extends EventEmitter {
     this.currentPlan = this.normalizePlan(plan);
     this.planVersion = 0;
     this.isExecuting = true;
-    
+
     // Initialize execution context
     this.executionContext = {
       planId: this.currentPlan.id,
@@ -116,30 +121,26 @@ class ReplanningEngine extends EventEmitter {
       completed: [],
       pending: [...(this.currentPlan.tasks || [])],
       failed: [],
-      retries: 0
+      retries: 0,
     };
 
     // Record initial snapshot
-    this.history.recordSnapshot(
-      this.currentPlan.id,
-      this.currentPlan,
-      'Initial plan'
-    );
+    this.history.recordSnapshot(this.currentPlan.id, this.currentPlan, 'Initial plan');
 
     // Start monitoring
     this.monitor.watch(this.currentPlan.id, {
       plan: this.currentPlan,
       tasks: this.currentPlan.tasks,
-      ...this.executionContext
+      ...this.executionContext,
     });
 
     try {
       // Execute with replanning loop
       const result = await this.executeLoop(options);
-      
+
       this.isExecuting = false;
       this.monitor.unwatch(this.currentPlan.id);
-      
+
       return result;
     } catch (error) {
       this.isExecuting = false;
@@ -157,55 +158,54 @@ class ReplanningEngine extends EventEmitter {
   async executeLoop(options) {
     while (this.executionContext.pending.length > 0 && this.isExecuting) {
       const task = this.executionContext.pending.shift();
-      
+
       try {
         // Execute task
         const result = await this.executeTask(task, options);
-        
+
         // Record success
         this.executionContext.completed.push({
           ...task,
           result,
           duration: result.duration,
-          completedAt: Date.now()
+          completedAt: Date.now(),
         });
-        
+
         // Report to monitor
         this.monitor.reportResult(this.currentPlan.id, {
           taskId: task.id,
           status: 'success',
-          output: result
+          output: result,
         });
-        
+
         // Record in evaluator
         this.evaluator.recordExecution(task.skill || task.name, {
           success: true,
-          duration: result.duration
+          duration: result.duration,
         });
-        
       } catch (error) {
         // Record failure
         const failedTask = {
           ...task,
           error,
           failedAt: Date.now(),
-          attempts: (task.attempts || 0) + 1
+          attempts: (task.attempts || 0) + 1,
         };
         this.executionContext.failed.push(failedTask);
-        
+
         // Report to monitor (may trigger replanning)
         const trigger = this.monitor.reportResult(this.currentPlan.id, {
           taskId: task.id,
           status: 'failed',
-          error
+          error,
         });
-        
+
         // Record in evaluator
         this.evaluator.recordExecution(task.skill || task.name, {
           success: false,
-          duration: Date.now() - (task.startTime || Date.now())
+          duration: Date.now() - (task.startTime || Date.now()),
         });
-        
+
         // If trigger was detected, wait for replanning to complete
         if (trigger) {
           // Replanning is handled by trigger event
@@ -227,18 +227,18 @@ class ReplanningEngine extends EventEmitter {
    */
   async executeTask(task, options) {
     task.startTime = Date.now();
-    
+
     if (this.engine) {
       // Delegate to orchestration engine
       return this.engine.executeSkill(task.skill || task.name, task.parameters, options);
     }
-    
+
     // Mock execution for testing
     await new Promise(resolve => setTimeout(resolve, 100));
     return {
       success: true,
       duration: Date.now() - task.startTime,
-      output: `Executed ${task.skill || task.name}`
+      output: `Executed ${task.skill || task.name}`,
     };
   }
 
@@ -250,16 +250,16 @@ class ReplanningEngine extends EventEmitter {
    */
   async handleTrigger(trigger) {
     const failedTask = this.executionContext.failed[this.executionContext.failed.length - 1];
-    
+
     // Generate alternatives
     const alternatives = await this.generator.generateAlternatives(
       failedTask,
       this.executionContext
     );
-    
+
     // Select best alternative or request human input
     const decision = await this.selectAlternative(alternatives, trigger);
-    
+
     // Record the replan event
     const event = this.history.record({
       trigger: trigger.type,
@@ -269,29 +269,31 @@ class ReplanningEngine extends EventEmitter {
         id: failedTask.id,
         name: failedTask.name,
         skill: failedTask.skill,
-        error: failedTask.error?.message
+        error: failedTask.error?.message,
       },
       alternatives: alternatives.map(a => ({
         id: a.id,
         description: a.description,
-        confidence: a.confidence
+        confidence: a.confidence,
       })),
-      selectedAlternative: decision.alternative ? {
-        id: decision.alternative.id,
-        description: decision.alternative.description,
-        confidence: decision.alternative.confidence,
-        reasoning: decision.alternative.reasoning
-      } : null,
+      selectedAlternative: decision.alternative
+        ? {
+            id: decision.alternative.id,
+            description: decision.alternative.description,
+            confidence: decision.alternative.confidence,
+            reasoning: decision.alternative.reasoning,
+          }
+        : null,
       context: {
         completedCount: this.executionContext.completed.length,
         pendingCount: this.executionContext.pending.length,
-        failedCount: this.executionContext.failed.length
-      }
+        failedCount: this.executionContext.failed.length,
+      },
     });
-    
+
     // Apply the decision
     await this.applyDecision(decision, trigger);
-    
+
     // Emit replan event
     this.emit('replan', { event, decision, alternatives });
   }
@@ -307,17 +309,17 @@ class ReplanningEngine extends EventEmitter {
     // Check if human approval is always required for this trigger
     const alwaysApprove = this.config.humanInLoop?.alwaysApprove || [];
     const requiresApproval = alwaysApprove.includes(trigger.type);
-    
+
     if (alternatives.length === 0) {
       return {
         type: ReplanDecision.ABORT,
         alternative: null,
-        reason: 'No viable alternatives found'
+        reason: 'No viable alternatives found',
       };
     }
-    
+
     const bestAlternative = alternatives[0];
-    
+
     // Check if confidence is below threshold
     const threshold = this.config.alternatives?.humanApprovalThreshold || 0.7;
     if (requiresApproval || bestAlternative.confidence < threshold) {
@@ -325,12 +327,12 @@ class ReplanningEngine extends EventEmitter {
         return this.requestHumanApproval(alternatives, trigger);
       }
     }
-    
+
     // Auto-select best alternative
     return {
       type: this.getDecisionType(bestAlternative),
       alternative: bestAlternative,
-      reason: `Auto-selected with confidence ${bestAlternative.confidence}`
+      reason: `Auto-selected with confidence ${bestAlternative.confidence}`,
     };
   }
 
@@ -358,26 +360,26 @@ class ReplanningEngine extends EventEmitter {
    * @private
    */
   async requestHumanApproval(alternatives, trigger) {
-    return new Promise((resolve) => {
+    return new Promise(resolve => {
       const timeout = this.config.humanInLoop?.timeout || 300000;
-      
+
       // Emit event for human review
       this.emit('replan:review-required', {
         trigger,
         alternatives,
         timeout,
-        respond: (decision) => {
+        respond: decision => {
           resolve(decision);
-        }
+        },
       });
-      
+
       // Timeout handling
       setTimeout(() => {
         const defaultAction = this.config.humanInLoop?.defaultOnTimeout || 'abort';
         resolve({
           type: defaultAction === 'abort' ? ReplanDecision.ABORT : ReplanDecision.SKIP,
           alternative: null,
-          reason: 'Human approval timeout'
+          reason: 'Human approval timeout',
         });
       }, timeout);
     });
@@ -389,31 +391,32 @@ class ReplanningEngine extends EventEmitter {
    * @param {Object} trigger - Original trigger
    * @private
    */
-  async applyDecision(decision, trigger) {
+  async applyDecision(decision, _trigger) {
     const planId = this.currentPlan.id;
-    
+
     switch (decision.type) {
-      case ReplanDecision.RETRY:
+      case ReplanDecision.RETRY: {
         // Add task back to pending
         const retryTask = {
           ...decision.alternative.task,
-          attempts: (decision.alternative.task.attempts || 0) + 1
+          attempts: (decision.alternative.task.attempts || 0) + 1,
         };
         this.executionContext.pending.unshift(retryTask);
         this.executionContext.retries++;
         break;
-        
+      }
+
       case ReplanDecision.REPLACE:
         // Add alternative task to pending
         this.executionContext.pending.unshift(decision.alternative.task);
         this.planVersion++;
         this.history.recordSnapshot(planId, this.currentPlan, 'Task replaced');
         break;
-        
+
       case ReplanDecision.SKIP:
         // Do nothing, task is already removed from pending
         break;
-        
+
       case ReplanDecision.INSERT:
         // Insert new tasks at appropriate position
         if (decision.tasks) {
@@ -421,26 +424,26 @@ class ReplanningEngine extends EventEmitter {
           this.planVersion++;
         }
         break;
-        
+
       case ReplanDecision.ABORT:
         // Stop execution
         this.isExecuting = false;
         break;
-        
+
       case ReplanDecision.HUMAN_REVIEW:
         // Already handled
         break;
-        
+
       default:
         console.warn(`Unknown decision type: ${decision.type}`);
     }
-    
+
     // Update history with outcome
     const lastEvent = this.history.getEvents({ limit: 1, sort: 'desc' })[0];
     if (lastEvent) {
       lastEvent.outcome = {
         success: decision.type !== ReplanDecision.ABORT,
-        applied: decision.type
+        applied: decision.type,
       };
     }
   }
@@ -451,11 +454,8 @@ class ReplanningEngine extends EventEmitter {
    * @private
    */
   generateResult() {
-    const evaluation = this.evaluator.evaluate(
-      this.currentPlan,
-      this.executionContext
-    );
-    
+    const evaluation = this.evaluator.evaluate(this.currentPlan, this.executionContext);
+
     return {
       planId: this.currentPlan.id,
       planVersion: this.planVersion,
@@ -466,7 +466,7 @@ class ReplanningEngine extends EventEmitter {
       evaluation,
       replanCount: this.planVersion,
       history: this.history.getMetrics(),
-      duration: Date.now() - this.executionContext.startTime
+      duration: Date.now() - this.executionContext.startTime,
     };
   }
 
@@ -484,16 +484,16 @@ class ReplanningEngine extends EventEmitter {
         name: task.name || task.skill,
         skill: task.skill || task.name,
         parameters: task.parameters || {},
-        dependencies: task.dependencies || []
+        dependencies: task.dependencies || [],
       };
       return normalized;
     });
-    
+
     return {
       ...plan,
       id: plan.id || `plan-${Date.now()}`,
       version: plan.version || 1,
-      tasks: normalizedTasks
+      tasks: normalizedTasks,
     };
   }
 
@@ -510,7 +510,7 @@ class ReplanningEngine extends EventEmitter {
     }
     return this.engine.execute(plan.pattern || 'sequential', {
       ...options,
-      tasks: plan.tasks
+      tasks: plan.tasks,
     });
   }
 
@@ -523,7 +523,7 @@ class ReplanningEngine extends EventEmitter {
     if (!this.isExecuting) {
       throw new Error('Cannot replan when not executing');
     }
-    
+
     this.monitor.requestReplan(this.currentPlan.id, reason);
   }
 
@@ -536,12 +536,12 @@ class ReplanningEngine extends EventEmitter {
     if (!this.currentPlan) {
       throw new Error('No active plan');
     }
-    
+
     const normalizedTask = {
       id: task.id || `task-${Date.now()}`,
-      ...task
+      ...task,
     };
-    
+
     if (position === 'start') {
       this.executionContext.pending.unshift(normalizedTask);
     } else if (position === 'end') {
@@ -555,7 +555,7 @@ class ReplanningEngine extends EventEmitter {
         this.executionContext.pending.push(normalizedTask);
       }
     }
-    
+
     this.planVersion++;
     this.emit('plan:modified', { action: 'add', task: normalizedTask });
   }
@@ -569,7 +569,7 @@ class ReplanningEngine extends EventEmitter {
     if (!this.currentPlan) {
       throw new Error('No active plan');
     }
-    
+
     const index = this.executionContext.pending.findIndex(t => t.id === taskId);
     if (index !== -1) {
       const removed = this.executionContext.pending.splice(index, 1)[0];
@@ -577,7 +577,7 @@ class ReplanningEngine extends EventEmitter {
       this.emit('plan:modified', { action: 'remove', task: removed });
       return true;
     }
-    
+
     return false;
   }
 
@@ -589,11 +589,9 @@ class ReplanningEngine extends EventEmitter {
     if (!this.currentPlan) {
       throw new Error('No active plan');
     }
-    
-    const taskMap = new Map(
-      this.executionContext.pending.map(t => [t.id, t])
-    );
-    
+
+    const taskMap = new Map(this.executionContext.pending.map(t => [t.id, t]));
+
     const reordered = [];
     for (const id of taskIds) {
       const task = taskMap.get(id);
@@ -602,10 +600,10 @@ class ReplanningEngine extends EventEmitter {
         taskMap.delete(id);
       }
     }
-    
+
     // Add remaining tasks at end
     reordered.push(...taskMap.values());
-    
+
     this.executionContext.pending = reordered;
     this.planVersion++;
     this.emit('plan:modified', { action: 'reorder', order: taskIds });
@@ -621,7 +619,7 @@ class ReplanningEngine extends EventEmitter {
     if (!this.currentPlan) {
       throw new Error('No active plan');
     }
-    
+
     const task = this.executionContext.pending.find(t => t.id === taskId);
     if (task) {
       Object.assign(task, updates);
@@ -629,7 +627,7 @@ class ReplanningEngine extends EventEmitter {
       this.emit('plan:modified', { action: 'modify', taskId, updates });
       return true;
     }
-    
+
     return false;
   }
 
@@ -642,7 +640,7 @@ class ReplanningEngine extends EventEmitter {
     return {
       events: this.history.getEvents(filter),
       metrics: this.history.getMetrics(),
-      snapshots: this.currentPlan ? this.history.getSnapshots(this.currentPlan.id) : []
+      snapshots: this.currentPlan ? this.history.getSnapshots(this.currentPlan.id) : [],
     };
   }
 
@@ -652,11 +650,11 @@ class ReplanningEngine extends EventEmitter {
    */
   getCurrentPlan() {
     if (!this.currentPlan) return null;
-    
+
     return {
       ...this.currentPlan,
       version: this.planVersion,
-      context: this.executionContext
+      context: this.executionContext,
     };
   }