musubi-sdd 5.1.0 → 5.6.1

package/src/orchestration/replanning/alternative-generator.js

@@ -22,7 +22,7 @@ class AlternativeGenerator {
       maxAlternatives: 3,
       minConfidence: 0.5,
       includeRetryOption: true,
-      respectDependencies: true
+      respectDependencies: true,
     };
     this.contextAnalyzer = new ContextAnalyzer();
     this.confidenceScorer = new ConfidenceScorer(options.scorerConfig);
@@ -35,7 +35,7 @@ class AlternativeGenerator {
    * @param {Object} [options={}] - Generation options
    * @returns {Promise<Alternative[]>} Ranked alternatives
    */
-  async generateAlternatives(failedTask, context, options = {}) {
+  async generateAlternatives(failedTask, context, _options = {}) {
     // Analyze context to understand the situation
     const analysis = await this.analyzeContext(failedTask, context);
 
@@ -60,9 +60,7 @@ class AlternativeGenerator {
     const scoredAlternatives = await this.scoreAlternatives(alternatives, context);
 
     // Filter by minimum confidence
-    const filtered = scoredAlternatives.filter(
-      alt => alt.confidence >= this.config.minConfidence
-    );
+    const filtered = scoredAlternatives.filter(alt => alt.confidence >= this.config.minConfidence);
 
     // Limit to max alternatives
     const limited = filtered.slice(0, this.config.maxAlternatives);
@@ -86,7 +84,7 @@ class AlternativeGenerator {
    * @param {Object} context - Execution context
    * @returns {string} Goal description
    */
-  extractGoal(task, context) {
+  extractGoal(task, _context) {
     // Try to get goal from task metadata
     if (task.goal) return task.goal;
     if (task.description) return task.description;
@@ -112,7 +110,7 @@ class AlternativeGenerator {
    * @private
    */
   buildPrompt(failedTask, context, analysis, goal) {
-    const errorInfo = failedTask.error 
+    const errorInfo = failedTask.error
       ? `Error: ${failedTask.error.message || failedTask.error}`
       : 'Unknown error';
 
@@ -168,16 +166,16 @@ Provide your confidence (0.0-1.0) for each alternative based on likelihood of su
                 properties: {
                   name: { type: 'string' },
                   skill: { type: 'string' },
-                  parameters: { type: 'object' }
-                }
+                  parameters: { type: 'object' },
+                },
               },
               confidence: { type: 'number', minimum: 0, maximum: 1 },
               reasoning: { type: 'string' },
-              risks: { type: 'array', items: { type: 'string' } }
-            }
-          }
-        }
-      }
+              risks: { type: 'array', items: { type: 'string' } },
+            },
+          },
+        },
+      },
     };
   }
 
@@ -189,7 +187,7 @@ Provide your confidence (0.0-1.0) for each alternative based on likelihood of su
    * @returns {Alternative[]} Processed alternatives
    * @private
    */
-  processLLMResponse(response, failedTask, context) {
+  processLLMResponse(response, failedTask, _context) {
     if (!response || !response.alternatives) {
       return [];
     }
@@ -202,14 +200,14 @@ Provide your confidence (0.0-1.0) for each alternative based on likelihood of su
         name: alt.task?.name || failedTask.name,
         skill: alt.task?.skill || failedTask.skill,
         parameters: alt.task?.parameters || failedTask.parameters,
-        originalTaskId: failedTask.id
+        originalTaskId: failedTask.id,
       },
       confidence: alt.confidence || 0.5,
       llmConfidence: alt.confidence || 0.5,
       reasoning: alt.reasoning || '',
       risks: alt.risks || [],
       source: 'llm',
-      analysisContext: response.analysis
+      analysisContext: response.analysis,
     }));
   }
 
@@ -226,13 +224,13 @@ Provide your confidence (0.0-1.0) for each alternative based on likelihood of su
       task: {
         ...failedTask,
         id: `${failedTask.id || 'task'}-retry`,
-        retryOf: failedTask.id
+        retryOf: failedTask.id,
       },
       confidence: 0.3, // Low initial confidence for retries
       llmConfidence: 0.3,
       reasoning: 'Retry the failed task - may succeed on transient errors',
       risks: ['May fail with same error', 'Time cost if error persists'],
-      source: 'system'
+      source: 'system',
     };
   }
 
@@ -245,12 +243,12 @@ Provide your confidence (0.0-1.0) for each alternative based on likelihood of su
    */
   async scoreAlternatives(alternatives, context) {
     const scored = await Promise.all(
-      alternatives.map(async (alt) => {
+      alternatives.map(async alt => {
         const score = await this.confidenceScorer.score(alt, context);
         return {
           ...alt,
           confidence: score.overall,
-          confidenceBreakdown: score
+          confidenceBreakdown: score,
         };
       })
     );
@@ -286,8 +284,8 @@ class ContextAnalyzer {
       failureContext: {
         error: failedTask.error,
         attemptCount: failedTask.attempts || 1,
-        lastAttemptTime: failedTask.lastAttemptTime || Date.now()
-      }
+        lastAttemptTime: failedTask.lastAttemptTime || Date.now(),
+      },
     };
   }
 
@@ -300,10 +298,7 @@ class ContextAnalyzer {
   extractAvailableSkills(context) {
     if (context.skills) return Object.keys(context.skills);
     if (context.registry) return context.registry.getSkillNames();
-    return [
-      'analyze', 'generate', 'validate', 'implement',
-      'test', 'review', 'document', 'deploy'
-    ];
+    return ['analyze', 'generate', 'validate', 'implement', 'test', 'review', 'document', 'deploy'];
   }
 
   /**
@@ -316,11 +311,11 @@ class ContextAnalyzer {
   extractDependencies(task, context) {
     const taskDeps = task.dependencies || [];
     const completedIds = (context.completed || []).map(t => t.id);
-    
+
     return {
       required: taskDeps,
       satisfied: taskDeps.filter(d => completedIds.includes(d)),
-      unsatisfied: taskDeps.filter(d => !completedIds.includes(d))
+      unsatisfied: taskDeps.filter(d => !completedIds.includes(d)),
     };
   }
 
@@ -333,10 +328,10 @@ class ContextAnalyzer {
   extractResources(context) {
     return {
       concurrency: context.maxConcurrency || 5,
-      timeRemaining: context.timeout 
+      timeRemaining: context.timeout
         ? context.timeout - (Date.now() - (context.startTime || Date.now()))
         : null,
-      memoryAvailable: true
+      memoryAvailable: true,
     };
   }
 }
@@ -354,7 +349,7 @@ class ConfidenceScorer {
       llm: config.llmWeight || 0.4,
       history: config.historyWeight || 0.3,
       resource: config.resourceWeight || 0.2,
-      complexity: config.complexityWeight || 0.1
+      complexity: config.complexityWeight || 0.1,
     };
     this.history = new Map();
   }
@@ -379,7 +374,7 @@ class ConfidenceScorer {
     const complexityScore = this.getComplexityScore(alternative);
 
     // Weighted combination
-    const overall = 
+    const overall =
       llmScore * this.weights.llm +
       historyScore * this.weights.history +
       resourceScore * this.weights.resource +
@@ -391,8 +386,8 @@ class ConfidenceScorer {
         llm: Math.round(llmScore * 100) / 100,
         history: Math.round(historyScore * 100) / 100,
         resource: Math.round(resourceScore * 100) / 100,
-        complexity: Math.round(complexityScore * 100) / 100
-      }
+        complexity: Math.round(complexityScore * 100) / 100,
+      },
     };
   }
 
@@ -417,7 +412,7 @@ class ConfidenceScorer {
    */
   getResourceScore(alternative, context) {
     let score = 1.0;
-    
+
     // Check time constraints
     if (context.resources?.timeRemaining != null) {
       const estimatedTime = alternative.estimatedTime || 30000;
@@ -445,12 +440,12 @@ class ConfidenceScorer {
    */
   getComplexityScore(alternative) {
     let complexity = 0;
-    
+
     // More risks = lower score
     if (alternative.risks) {
       complexity += alternative.risks.length * 0.1;
     }
-    
+
     // More parameters = slightly lower score
     const params = alternative.task.parameters || {};
     complexity += Object.keys(params).length * 0.02;
@@ -501,8 +496,8 @@ class ConfidenceScorer {
  * @property {Object} components - Component scores
  */
 
-module.exports = { 
-  AlternativeGenerator, 
-  ContextAnalyzer, 
-  ConfidenceScorer 
+module.exports = {
+  AlternativeGenerator,
+  ContextAnalyzer,
+  ConfidenceScorer,
 };

package/src/orchestration/replanning/config.js

@@ -13,24 +13,24 @@
 const ReplanTrigger = {
   /** Task execution failed */
   TASK_FAILED: 'task-failed',
-  
+
   /** Task execution timed out */
   TIMEOUT: 'timeout',
-  
+
   /** Context or requirements changed */
   CONTEXT_CHANGED: 'context-changed',
-  
+
   /** A more efficient path was discovered */
   BETTER_PATH_FOUND: 'better-path-found',
-  
+
   /** Human operator requested replanning */
   HUMAN_REQUEST: 'human-request',
-  
+
   /** Goal determined to be unreachable with current approach */
   GOAL_UNREACHABLE: 'goal-unreachable',
-  
+
   /** Resource constraints changed */
-  RESOURCE_CHANGED: 'resource-changed'
+  RESOURCE_CHANGED: 'resource-changed',
 };
 
 /**
@@ -40,30 +40,30 @@ const ReplanTrigger = {
 const ReplanDecision = {
   /** Continue with current plan */
   CONTINUE: 'continue',
-  
+
   /** Retry the failed task */
   RETRY: 'retry',
-  
+
   /** Skip the failed task */
   SKIP: 'skip',
-  
+
   /** Replace task with alternative */
   REPLACE: 'replace',
-  
+
   /** Insert new tasks into plan */
   INSERT: 'insert',
-  
+
   /** Remove tasks from plan */
   REMOVE: 'remove',
-  
+
   /** Reorder remaining tasks */
   REORDER: 'reorder',
-  
+
   /** Abort execution */
   ABORT: 'abort',
-  
+
   /** Request human intervention */
-  HUMAN_REVIEW: 'human-review'
+  HUMAN_REVIEW: 'human-review',
 };
 
 /**
@@ -85,30 +85,30 @@ const defaultReplanningConfig = {
      * @type {string}
      */
     provider: 'auto',
-    
+
     /**
      * Model override (optional)
      * @type {string|null}
      */
     model: null,
-    
+
     /**
      * Maximum tokens for LLM response
      * @type {number}
      */
     maxTokens: 2048,
-    
+
     /**
      * Temperature for LLM generation
      * @type {number}
      */
     temperature: 0.7,
-    
+
     /**
      * Timeout for LLM requests in milliseconds
      * @type {number}
      */
-    timeout: 60000
+    timeout: 60000,
   },
 
   /**
@@ -123,26 +123,26 @@ const defaultReplanningConfig = {
       ReplanTrigger.TASK_FAILED,
       ReplanTrigger.TIMEOUT,
       ReplanTrigger.CONTEXT_CHANGED,
-      ReplanTrigger.HUMAN_REQUEST
+      ReplanTrigger.HUMAN_REQUEST,
     ],
-    
+
     /**
      * Number of consecutive failures before triggering replanning
      * @type {number}
      */
     failureThreshold: 2,
-    
+
     /**
      * Task timeout in milliseconds
      * @type {number}
      */
     taskTimeout: 300000, // 5 minutes
-    
+
     /**
      * Enable proactive better-path detection
      * @type {boolean}
      */
-    enableBetterPathDetection: false
+    enableBetterPathDetection: false,
   },
 
   /**
@@ -154,30 +154,30 @@ const defaultReplanningConfig = {
      * @type {number}
      */
     maxAlternatives: 3,
-    
+
     /**
      * Minimum confidence score to accept an alternative (0.0 - 1.0)
      * @type {number}
      */
     minConfidence: 0.5,
-    
+
     /**
      * Confidence threshold requiring human approval
      * @type {number}
      */
     humanApprovalThreshold: 0.7,
-    
+
     /**
      * Include original task as fallback option
      * @type {boolean}
      */
     includeRetryOption: true,
-    
+
     /**
      * Consider task dependencies when generating alternatives
      * @type {boolean}
      */
-    respectDependencies: true
+    respectDependencies: true,
   },
 
   /**
@@ -189,24 +189,24 @@ const defaultReplanningConfig = {
      * @type {number}
      */
     llmWeight: 0.4,
-    
+
     /**
      * Weight for historical success rate
      * @type {number}
      */
     historyWeight: 0.3,
-    
+
     /**
      * Weight for resource availability
      * @type {number}
      */
     resourceWeight: 0.2,
-    
+
     /**
      * Weight for complexity score
      * @type {number}
      */
-    complexityWeight: 0.1
+    complexityWeight: 0.1,
   },
 
   /**
@@ -218,30 +218,30 @@ const defaultReplanningConfig = {
      * @type {boolean}
      */
     enabled: true,
-    
+
     /**
      * Maximum events to keep in memory
      * @type {number}
      */
     maxEvents: 1000,
-    
+
     /**
      * Persist history to file system
      * @type {boolean}
      */
     persist: false,
-    
+
     /**
      * History file path (relative to project root)
      * @type {string}
      */
     filePath: 'storage/replanning-history.json',
-    
+
     /**
      * Export format for reports
      * @type {string}
      */
-    exportFormat: 'markdown'
+    exportFormat: 'markdown',
   },
 
   /**
@@ -253,24 +253,24 @@ const defaultReplanningConfig = {
      * @type {boolean}
      */
     enabled: true,
-    
+
     /**
      * Timeout for human response in milliseconds
      * @type {number}
      */
     timeout: 300000, // 5 minutes
-    
+
     /**
      * Default action on timeout
      * @type {string}
      */
     defaultOnTimeout: 'abort',
-    
+
     /**
      * Always require approval for these trigger types
      * @type {string[]}
      */
-    alwaysApprove: [ReplanTrigger.GOAL_UNREACHABLE]
+    alwaysApprove: [ReplanTrigger.GOAL_UNREACHABLE],
   },
 
   /**
@@ -282,19 +282,19 @@ const defaultReplanningConfig = {
      * @type {string[]}
      */
     enabledPatterns: ['swarm', 'sequential', 'workflow'],
-    
+
     /**
      * Emit events for replanning actions
      * @type {boolean}
      */
     emitEvents: true,
-    
+
     /**
      * Event prefix for replanning events
      * @type {string}
      */
-    eventPrefix: 'replan'
-  }
+    eventPrefix: 'replan',
+  },
 };
 
 /**
@@ -315,7 +315,7 @@ function mergeConfig(userConfig = {}) {
  */
 function deepMerge(target, source) {
   const result = { ...target };
-  
+
   for (const key of Object.keys(source)) {
     if (source[key] instanceof Object && key in target && target[key] instanceof Object) {
       result[key] = deepMerge(target[key], source[key]);
@@ -323,7 +323,7 @@ function deepMerge(target, source) {
       result[key] = source[key];
     }
   }
-  
+
   return result;
 }
 
@@ -339,18 +339,22 @@ function validateConfig(config) {
   if (config.alternatives?.minConfidence < 0 || config.alternatives?.minConfidence > 1) {
     errors.push('alternatives.minConfidence must be between 0 and 1');
   }
-  
-  if (config.alternatives?.humanApprovalThreshold < 0 || config.alternatives?.humanApprovalThreshold > 1) {
+
+  if (
+    config.alternatives?.humanApprovalThreshold < 0 ||
+    config.alternatives?.humanApprovalThreshold > 1
+  ) {
     errors.push('alternatives.humanApprovalThreshold must be between 0 and 1');
   }
 
   // Validate evaluation weights sum to 1
   const evaluation = config.evaluation || {};
-  const weightSum = (evaluation.llmWeight || 0) + 
-                   (evaluation.historyWeight || 0) + 
-                   (evaluation.resourceWeight || 0) + 
-                   (evaluation.complexityWeight || 0);
-  
+  const weightSum =
+    (evaluation.llmWeight || 0) +
+    (evaluation.historyWeight || 0) +
+    (evaluation.resourceWeight || 0) +
+    (evaluation.complexityWeight || 0);
+
   if (Math.abs(weightSum - 1.0) > 0.01) {
     errors.push(`Evaluation weights must sum to 1.0, got ${weightSum}`);
   }
@@ -365,7 +369,7 @@ function validateConfig(config) {
 
   return {
     valid: errors.length === 0,
-    errors
+    errors,
   };
 }
 
@@ -374,5 +378,5 @@ module.exports = {
   ReplanDecision,
   defaultReplanningConfig,
   mergeConfig,
-  validateConfig
+  validateConfig,
 };