musubi-sdd 5.0.0 → 5.6.1

package/src/orchestration/skill-executor.js

@@ -1,7 +1,7 @@
 /**
  * Skill Executor - Execute skills with priority, retry, and guardrails
  * Sprint 3.2: Skill System Architecture
- * 
+ *
  * Features:
  * - P-label priority execution (P0-P3)
  * - Parallel and sequential execution
@@ -23,7 +23,7 @@ const ExecutionStatus = {
   FAILED: 'failed',
   CANCELLED: 'cancelled',
   TIMEOUT: 'timeout',
-  SKIPPED: 'skipped'
+  SKIPPED: 'skipped',
 };
 
 /**
@@ -55,7 +55,7 @@ class ExecutionResult {
       error: this.error,
       duration: this.duration,
       attempts: this.attempts,
-      metadata: this.metadata
+      metadata: this.metadata,
     };
   }
 }
@@ -96,7 +96,7 @@ class ExecutionContext {
     return new ExecutionContext({
       ...options,
       parentContext: this,
-      variables: options.variables || {}
+      variables: options.variables || {},
     });
   }
 }
@@ -107,27 +107,27 @@ class ExecutionContext {
 class IOValidator {
   constructor() {
     this.typeValidators = {
-      string: (v) => typeof v === 'string',
-      number: (v) => typeof v === 'number' && !isNaN(v),
-      boolean: (v) => typeof v === 'boolean',
-      array: (v) => Array.isArray(v),
-      object: (v) => typeof v === 'object' && v !== null && !Array.isArray(v),
-      any: () => true
+      string: v => typeof v === 'string',
+      number: v => typeof v === 'number' && !isNaN(v),
+      boolean: v => typeof v === 'boolean',
+      array: v => Array.isArray(v),
+      object: v => typeof v === 'object' && v !== null && !Array.isArray(v),
+      any: () => true,
     };
   }
 
   validateInput(input, schema) {
     const errors = [];
-    
+
     for (const field of schema) {
       const value = input[field.name];
-      
+
       // Required check
       if (field.required && (value === undefined || value === null)) {
         errors.push(`Missing required input: ${field.name}`);
         continue;
       }
-      
+
       // Type check
       if (value !== undefined && value !== null && field.type) {
         const validator = this.typeValidators[field.type];
@@ -135,7 +135,7 @@ class IOValidator {
           errors.push(`Invalid type for ${field.name}: expected ${field.type}`);
         }
       }
-      
+
       // Custom validation
       if (field.validate && value !== undefined) {
         try {
@@ -148,23 +148,23 @@ class IOValidator {
         }
       }
     }
-    
+
     return {
       valid: errors.length === 0,
-      errors
+      errors,
     };
   }
 
   validateOutput(output, schema) {
     const errors = [];
-    
+
     for (const field of schema) {
       const value = output?.[field.name];
-      
+
       if (field.required && (value === undefined || value === null)) {
         errors.push(`Missing required output: ${field.name}`);
       }
-      
+
       if (value !== undefined && value !== null && field.type) {
         const validator = this.typeValidators[field.type];
         if (validator && !validator(value)) {
@@ -172,10 +172,10 @@ class IOValidator {
         }
       }
     }
-    
+
     return {
       valid: errors.length === 0,
-      errors
+      errors,
     };
   }
 }
@@ -192,21 +192,21 @@ class SkillExecutor extends EventEmitter {
     this.activeExecutions = new Map();
     this.executionHistory = [];
     this.maxHistorySize = options.maxHistorySize || 1000;
-    
+
     // Hooks
     this.hooks = {
       beforeExecute: options.beforeExecute || [],
       afterExecute: options.afterExecute || [],
-      onError: options.onError || []
+      onError: options.onError || [],
     };
-    
+
     // Options
     this.options = {
       defaultTimeout: options.defaultTimeout || 30000,
       maxConcurrent: options.maxConcurrent || 10,
-      enableMetrics: options.enableMetrics !== false
+      enableMetrics: options.enableMetrics !== false,
     };
-    
+
     this._concurrentCount = 0;
   }
 
@@ -218,58 +218,58 @@ class SkillExecutor extends EventEmitter {
     if (!skillEntry) {
       throw new Error(`Skill '${skillId}' not found`);
     }
-    
+
     const { metadata, handler } = skillEntry;
-    
+
     if (!handler) {
       throw new Error(`Skill '${skillId}' has no handler`);
     }
-    
+
     // Create execution context
     const context = new ExecutionContext({
       skillId,
       input,
       variables: options.variables,
-      metadata: options.metadata
+      metadata: options.metadata,
     });
-    
+
     // Create result
     const result = new ExecutionResult({
       skillId,
-      status: ExecutionStatus.PENDING
+      status: ExecutionStatus.PENDING,
     });
-    
+
     // Track execution
     this.activeExecutions.set(context.executionId, { context, result, cancelled: false });
-    
+
     try {
       // Check concurrency limit
       if (this._concurrentCount >= this.options.maxConcurrent) {
         await this._waitForSlot();
       }
       this._concurrentCount++;
-      
+
       // Validate input
       const inputValidation = this.validator.validateInput(input, metadata.inputs);
       if (!inputValidation.valid) {
         throw new Error(`Input validation failed: ${inputValidation.errors.join(', ')}`);
       }
-      
+
       // Run guardrails (pre-execution)
       await this._runGuardrails('pre', { skillId, input, context });
-      
+
       // Run beforeExecute hooks
       for (const hook of this.hooks.beforeExecute) {
         await hook(context, metadata);
       }
-      
+
       // Start execution
       result.status = ExecutionStatus.RUNNING;
       result.startTime = Date.now();
       context.startTime = result.startTime;
-      
+
       this.emit('execution-started', { executionId: context.executionId, skillId });
-      
+
       // Execute with retry
       const output = await this._executeWithRetry(
         handler,
@@ -278,68 +278,66 @@ class SkillExecutor extends EventEmitter {
         options.timeout || metadata.timeout || this.options.defaultTimeout,
         result
       );
-      
+
       // Validate output
       const outputValidation = this.validator.validateOutput(output, metadata.outputs);
       if (!outputValidation.valid) {
         throw new Error(`Output validation failed: ${outputValidation.errors.join(', ')}`);
       }
-      
+
       // Run guardrails (post-execution)
       await this._runGuardrails('post', { skillId, input, output, context });
-      
+
       // Complete
       result.status = ExecutionStatus.COMPLETED;
       result.output = output;
       result.endTime = Date.now();
       result.duration = result.endTime - result.startTime;
-      
+
       // Run afterExecute hooks
       for (const hook of this.hooks.afterExecute) {
         await hook(context, result);
       }
-      
+
       // Record stats
       if (this.options.enableMetrics) {
         this.registry.recordExecution(skillId, true, result.duration);
       }
-      
-      this.emit('execution-completed', { 
-        executionId: context.executionId, 
-        skillId, 
-        duration: result.duration 
+
+      this.emit('execution-completed', {
+        executionId: context.executionId,
+        skillId,
+        duration: result.duration,
       });
-      
     } catch (error) {
-      result.status = this.activeExecutions.get(context.executionId)?.cancelled 
-        ? ExecutionStatus.CANCELLED 
+      result.status = this.activeExecutions.get(context.executionId)?.cancelled
+        ? ExecutionStatus.CANCELLED
         : ExecutionStatus.FAILED;
       result.error = error.message;
       result.endTime = Date.now();
       result.duration = result.startTime ? result.endTime - result.startTime : 0;
-      
+
       // Run onError hooks
       for (const hook of this.hooks.onError) {
         await hook(error, context, result);
       }
-      
+
       // Record stats
       if (this.options.enableMetrics) {
         this.registry.recordExecution(skillId, false, result.duration);
       }
-      
-      this.emit('execution-failed', { 
-        executionId: context.executionId, 
-        skillId, 
-        error: error.message 
+
+      this.emit('execution-failed', {
+        executionId: context.executionId,
+        skillId,
+        error: error.message,
       });
-      
     } finally {
       this._concurrentCount--;
       this.activeExecutions.delete(context.executionId);
       this._addToHistory(result);
     }
-    
+
     return result;
   }
 
@@ -352,7 +350,7 @@ class SkillExecutor extends EventEmitter {
       const priorityOrder = { P0: 0, P1: 1, P2: 2, P3: 3 };
       return (priorityOrder[a.priority] || 2) - (priorityOrder[b.priority] || 2);
     });
-    
+
     // Group by priority
     const priorityGroups = new Map();
     for (const task of sortedTasks) {
@@ -362,51 +360,52 @@ class SkillExecutor extends EventEmitter {
       }
       priorityGroups.get(priority).push(task);
     }
-    
+
     const results = new Map();
-    
+
     // Execute P0 first (blocking)
     if (priorityGroups.has('P0')) {
       for (const task of priorityGroups.get('P0')) {
         const result = await this.execute(task.skillId, task.input, task.options);
         results.set(task.skillId, result);
-        
+
         // P0 failure stops everything
         if (!result.success && options.failFast !== false) {
           return { results: Object.fromEntries(results), partial: true };
         }
       }
     }
-    
+
     // Execute P1-P3 in parallel within each priority level
     for (const priority of ['P1', 'P2', 'P3']) {
       if (priorityGroups.has(priority)) {
         const groupTasks = priorityGroups.get(priority);
         const groupResults = await Promise.allSettled(
-          groupTasks.map(task => 
-            this.execute(task.skillId, task.input, task.options)
-          )
+          groupTasks.map(task => this.execute(task.skillId, task.input, task.options))
         );
-        
+
         groupTasks.forEach((task, index) => {
           const settled = groupResults[index];
           if (settled.status === 'fulfilled') {
             results.set(task.skillId, settled.value);
           } else {
-            results.set(task.skillId, new ExecutionResult({
-              skillId: task.skillId,
-              status: ExecutionStatus.FAILED,
-              error: settled.reason?.message || 'Unknown error'
-            }));
+            results.set(
+              task.skillId,
+              new ExecutionResult({
+                skillId: task.skillId,
+                status: ExecutionStatus.FAILED,
+                error: settled.reason?.message || 'Unknown error',
+              })
+            );
           }
         });
       }
     }
-    
+
     return {
       results: Object.fromEntries(results),
       partial: false,
-      summary: this._summarizeResults(results)
+      summary: this._summarizeResults(results),
     };
   }
 
@@ -415,20 +414,20 @@ class SkillExecutor extends EventEmitter {
    */
   async executeSequential(tasks, options = {}) {
     const results = [];
-    
+
     for (const task of tasks) {
       const result = await this.execute(task.skillId, task.input, task.options);
       results.push(result);
-      
+
       if (!result.success && options.stopOnError !== false) {
         break;
       }
     }
-    
+
     return {
       results,
       completed: results.length === tasks.length,
-      summary: this._summarizeResults(new Map(results.map(r => [r.skillId, r])))
+      summary: this._summarizeResults(new Map(results.map(r => [r.skillId, r]))),
     };
   }
 
@@ -438,29 +437,28 @@ class SkillExecutor extends EventEmitter {
   async executeWithDependencies(skillId, input = {}, options = {}) {
     const order = this.registry.resolveDependencies(skillId);
     const results = new Map();
-    
+
     for (const depSkillId of order) {
       // Use output from dependencies as input
-      const depInput = depSkillId === skillId 
-        ? input 
-        : this._mergeInputFromResults(results, depSkillId);
-      
+      const depInput =
+        depSkillId === skillId ? input : this._mergeInputFromResults(results, depSkillId);
+
       const result = await this.execute(depSkillId, depInput, options);
       results.set(depSkillId, result);
-      
+
       if (!result.success) {
         return {
           results: Object.fromEntries(results),
           failed: true,
-          failedAt: depSkillId
+          failedAt: depSkillId,
         };
       }
     }
-    
+
     return {
       results: Object.fromEntries(results),
       failed: false,
-      finalResult: results.get(skillId)
+      finalResult: results.get(skillId),
     };
   }
 
@@ -522,46 +520,46 @@ class SkillExecutor extends EventEmitter {
     const maxRetries = retryPolicy?.maxRetries || 0;
     const backoffMs = retryPolicy?.backoffMs || 1000;
     const backoffMultiplier = retryPolicy?.backoffMultiplier || 2;
-    
+
     let lastError;
     let currentBackoff = backoffMs;
-    
+
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
       result.attempts = attempt + 1;
-      
+
       // Check if cancelled
       const execution = this.activeExecutions.get(context.executionId);
       if (execution?.cancelled) {
         throw new Error('Execution cancelled');
       }
-      
+
       try {
         // Execute with timeout
         const output = await this._executeWithTimeout(handler, context, timeout);
         return output;
       } catch (error) {
         lastError = error;
-        
+
         // Check if retryable
         if (!this._isRetryable(error)) {
           throw error;
         }
-        
+
         if (attempt < maxRetries) {
-          this.emit('execution-retry', { 
-            executionId: context.executionId, 
+          this.emit('execution-retry', {
+            executionId: context.executionId,
             skillId: context.skillId,
             attempt: attempt + 1,
             maxRetries,
-            nextRetryMs: currentBackoff
+            nextRetryMs: currentBackoff,
           });
-          
+
           await this._sleep(currentBackoff);
           currentBackoff *= backoffMultiplier;
         }
       }
     }
-    
+
     throw lastError;
   }
 
@@ -570,7 +568,7 @@ class SkillExecutor extends EventEmitter {
       const timeoutId = setTimeout(() => {
         reject(new Error(`Execution timeout after ${timeout}ms`));
       }, timeout);
-      
+
       Promise.resolve(handler(context.input, context))
         .then(result => {
           clearTimeout(timeoutId);
@@ -599,7 +597,7 @@ class SkillExecutor extends EventEmitter {
       'Execution cancelled',
       'Input validation failed',
       'Output validation failed',
-      'Guardrail'
+      'Guardrail',
     ];
     return !nonRetryable.some(msg => error.message.includes(msg));
   }
@@ -625,7 +623,7 @@ class SkillExecutor extends EventEmitter {
     let success = 0;
     let failed = 0;
     let totalDuration = 0;
-    
+
     for (const result of resultsMap.values()) {
       if (result.success) {
         success++;
@@ -634,17 +632,17 @@ class SkillExecutor extends EventEmitter {
       }
       totalDuration += result.duration || 0;
     }
-    
+
     return {
       total: resultsMap.size,
       success,
       failed,
       totalDuration,
-      averageDuration: resultsMap.size > 0 ? totalDuration / resultsMap.size : 0
+      averageDuration: resultsMap.size > 0 ? totalDuration / resultsMap.size : 0,
     };
   }
 
-  _mergeInputFromResults(results, skillId) {
+  _mergeInputFromResults(results, _skillId) {
     // Simple merge - could be extended with explicit mappings
     const merged = {};
     for (const result of results.values()) {
@@ -661,5 +659,5 @@ module.exports = {
   ExecutionResult,
   ExecutionContext,
   ExecutionStatus,
-  IOValidator
+  IOValidator,
 };