musubi-sdd 5.0.0 → 5.6.1

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

@@ -17,7 +17,7 @@ const STRATEGY = {
   TREE_OF_THOUGHT: 'tree-of-thought',
   REFLECTION: 'reflection',
   DECOMPOSITION: 'decomposition',
-  ANALOGY: 'analogy'
+  ANALOGY: 'analogy',
 };
 
 /**
@@ -30,7 +30,7 @@ const STEP_TYPE = {
   PLAN: 'plan',
   ACT: 'act',
   REFLECT: 'reflect',
-  REFINE: 'refine'
+  REFINE: 'refine',
 };
 
 /**
@@ -75,20 +75,20 @@ class ReasoningEngine extends EventEmitter {
    */
   constructor(options = {}) {
     super();
-    
+
     this.strategy = options.strategy || STRATEGY.CHAIN_OF_THOUGHT;
     this.maxSteps = options.maxSteps ?? 20;
     this.minConfidence = options.minConfidence ?? 0.6;
     this.enableReflection = options.enableReflection ?? true;
     this.enableBacktracking = options.enableBacktracking ?? true;
     this.timeout = options.timeout ?? 60000;
-    
+
     // State
     this.traces = new Map();
     this.currentTrace = null;
     this.stepCounter = 0;
   }
-  
+
   /**
    * Start reasoning about a problem
    * @param {string} problem - Problem statement
@@ -98,7 +98,7 @@ class ReasoningEngine extends EventEmitter {
   async reason(problem, context = {}) {
     const traceId = this.generateId();
     const startTime = Date.now();
-    
+
     const trace = {
       id: traceId,
       problem,
@@ -106,14 +106,14 @@ class ReasoningEngine extends EventEmitter {
       steps: [],
       conclusion: null,
       successful: false,
-      totalTime: 0
+      totalTime: 0,
     };
-    
+
     this.currentTrace = trace;
     this.traces.set(traceId, trace);
-    
+
     this.emit('reasoning:start', { traceId, problem, strategy: this.strategy });
-    
+
     try {
       // Select reasoning strategy
       let result;
@@ -136,23 +136,27 @@ class ReasoningEngine extends EventEmitter {
         default:
           result = await this.chainOfThought(problem, context);
       }
-      
+
       trace.conclusion = result.conclusion;
       trace.successful = result.successful;
-      
     } catch (error) {
-      this.addStep(STEP_TYPE.REFLECT, `Reasoning failed: ${error.message}`, { error: error.message }, 0);
+      this.addStep(
+        STEP_TYPE.REFLECT,
+        `Reasoning failed: ${error.message}`,
+        { error: error.message },
+        0
+      );
       trace.successful = false;
     }
-    
+
     trace.totalTime = Date.now() - startTime;
     this.currentTrace = null;
-    
+
     this.emit('reasoning:complete', { trace });
-    
+
     return trace;
   }
-  
+
   /**
    * Chain of Thought reasoning
    * @private
@@ -160,39 +164,54 @@ class ReasoningEngine extends EventEmitter {
   async chainOfThought(problem, context) {
     // Step 1: Observe
     this.addStep(STEP_TYPE.OBSERVE, `Analyzing problem: ${problem}`, { context }, 0.9);
-    
+
     // Step 2: Decompose into sub-problems
     const subProblems = this.decomposeProlem(problem);
-    this.addStep(STEP_TYPE.THINK, `Identified ${subProblems.length} sub-problems:\n${subProblems.map((p, i) => `${i + 1}. ${p}`).join('\n')}`, { subProblems }, 0.8);
-    
+    this.addStep(
+      STEP_TYPE.THINK,
+      `Identified ${subProblems.length} sub-problems:\n${subProblems.map((p, i) => `${i + 1}. ${p}`).join('\n')}`,
+      { subProblems },
+      0.8
+    );
+
     // Step 3: Process each sub-problem
     const solutions = [];
     for (const subProblem of subProblems) {
       this.addStep(STEP_TYPE.THINK, `Working on: ${subProblem}`, {}, 0.7);
-      
+
       const solution = await this.solveSubProblem(subProblem, context);
       solutions.push({ problem: subProblem, solution });
-      
+
       this.addStep(STEP_TYPE.ACT, `Solution: ${solution}`, { subProblem, solution }, 0.8);
     }
-    
+
     // Step 4: Synthesize
     const conclusion = this.synthesize(solutions);
-    this.addStep(STEP_TYPE.PLAN, `Synthesizing solutions into final answer`, { solutionCount: solutions.length }, 0.85);
-    
+    this.addStep(
+      STEP_TYPE.PLAN,
+      `Synthesizing solutions into final answer`,
+      { solutionCount: solutions.length },
+      0.85
+    );
+
     // Step 5: Reflect if enabled
     if (this.enableReflection) {
       const reflection = this.reflect(problem, conclusion, solutions);
-      this.addStep(STEP_TYPE.REFLECT, reflection.content, { confidence: reflection.confidence }, reflection.confidence);
-      
+      this.addStep(
+        STEP_TYPE.REFLECT,
+        reflection.content,
+        { confidence: reflection.confidence },
+        reflection.confidence
+      );
+
       if (reflection.confidence < this.minConfidence && this.enableBacktracking) {
         return this.backtrack(problem, context, reflection);
       }
     }
-    
+
     return { conclusion, successful: true };
   }
-  
+
   /**
    * Tree of Thought reasoning - explore multiple paths
    * @private
@@ -200,43 +219,58 @@ class ReasoningEngine extends EventEmitter {
   async treeOfThought(problem, context) {
     const branches = [];
     const maxBranches = 3;
-    
+
     this.addStep(STEP_TYPE.OBSERVE, `Exploring multiple reasoning paths for: ${problem}`, {}, 0.9);
-    
+
     // Generate multiple initial thoughts
     const initialThoughts = this.generateThoughts(problem, maxBranches);
-    this.addStep(STEP_TYPE.THINK, `Generated ${initialThoughts.length} reasoning branches`, { branches: initialThoughts }, 0.8);
-    
+    this.addStep(
+      STEP_TYPE.THINK,
+      `Generated ${initialThoughts.length} reasoning branches`,
+      { branches: initialThoughts },
+      0.8
+    );
+
     // Explore each branch
     for (const thought of initialThoughts) {
       const branch = {
         thought,
         steps: [],
         conclusion: null,
-        score: 0
+        score: 0,
       };
-      
+
       this.addStep(STEP_TYPE.PLAN, `Exploring branch: ${thought}`, {}, 0.7);
-      
+
       // Develop this branch
       const developed = await this.developBranch(thought, problem, context);
       branch.steps = developed.steps;
       branch.conclusion = developed.conclusion;
       branch.score = this.evaluateBranch(branch);
-      
+
       branches.push(branch);
-      this.addStep(STEP_TYPE.REFLECT, `Branch score: ${branch.score.toFixed(2)}`, { conclusion: branch.conclusion }, branch.score);
+      this.addStep(
+        STEP_TYPE.REFLECT,
+        `Branch score: ${branch.score.toFixed(2)}`,
+        { conclusion: branch.conclusion },
+        branch.score
+      );
     }
-    
+
     // Select best branch
     branches.sort((a, b) => b.score - a.score);
     const best = branches[0];
-    
-    this.addStep(STEP_TYPE.ACT, `Selected best reasoning path with score ${best.score.toFixed(2)}`, { conclusion: best.conclusion }, best.score);
-    
+
+    this.addStep(
+      STEP_TYPE.ACT,
+      `Selected best reasoning path with score ${best.score.toFixed(2)}`,
+      { conclusion: best.conclusion },
+      best.score
+    );
+
     return { conclusion: best.conclusion, successful: best.score >= this.minConfidence };
   }
-  
+
   /**
    * Reflective reasoning - iterate and improve
    * @private
@@ -245,81 +279,111 @@ class ReasoningEngine extends EventEmitter {
     let currentSolution = null;
     let iterations = 0;
     const maxIterations = 3;
-    
+
     this.addStep(STEP_TYPE.OBSERVE, `Starting reflective reasoning for: ${problem}`, {}, 0.9);
-    
+
     while (iterations < maxIterations) {
       iterations++;
-      
+
       // Generate or refine solution
       if (!currentSolution) {
         currentSolution = await this.generateInitialSolution(problem, context);
-        this.addStep(STEP_TYPE.THINK, `Initial solution: ${currentSolution}`, { iteration: iterations }, 0.7);
+        this.addStep(
+          STEP_TYPE.THINK,
+          `Initial solution: ${currentSolution}`,
+          { iteration: iterations },
+          0.7
+        );
       } else {
         currentSolution = await this.refineSolution(currentSolution, problem, context);
-        this.addStep(STEP_TYPE.REFINE, `Refined solution: ${currentSolution}`, { iteration: iterations }, 0.8);
+        this.addStep(
+          STEP_TYPE.REFINE,
+          `Refined solution: ${currentSolution}`,
+          { iteration: iterations },
+          0.8
+        );
       }
-      
+
       // Reflect on solution
       const reflection = this.reflect(problem, currentSolution, []);
-      this.addStep(STEP_TYPE.REFLECT, reflection.content, { confidence: reflection.confidence }, reflection.confidence);
-      
+      this.addStep(
+        STEP_TYPE.REFLECT,
+        reflection.content,
+        { confidence: reflection.confidence },
+        reflection.confidence
+      );
+
       if (reflection.confidence >= this.minConfidence) {
         return { conclusion: currentSolution, successful: true };
       }
     }
-    
+
     return { conclusion: currentSolution, successful: false };
   }
-  
+
   /**
    * Decomposition reasoning - divide and conquer
    * @private
    */
   async decompositionReasoning(problem, context) {
     this.addStep(STEP_TYPE.OBSERVE, `Decomposing problem: ${problem}`, {}, 0.9);
-    
+
     // Hierarchical decomposition
     const decomposition = this.hierarchicalDecompose(problem);
-    this.addStep(STEP_TYPE.PLAN, `Problem decomposition:\n${this.formatDecomposition(decomposition)}`, { decomposition }, 0.85);
-    
+    this.addStep(
+      STEP_TYPE.PLAN,
+      `Problem decomposition:\n${this.formatDecomposition(decomposition)}`,
+      { decomposition },
+      0.85
+    );
+
     // Solve bottom-up
     const solved = await this.solveBottomUp(decomposition, context);
-    this.addStep(STEP_TYPE.ACT, `Solved ${solved.solvedCount} sub-problems`, { solved: solved.results }, 0.8);
-    
+    this.addStep(
+      STEP_TYPE.ACT,
+      `Solved ${solved.solvedCount} sub-problems`,
+      { solved: solved.results },
+      0.8
+    );
+
     // Compose solution
     const conclusion = this.composeSolution(solved.results);
     this.addStep(STEP_TYPE.THINK, `Composed final solution`, { conclusion }, 0.85);
-    
+
     return { conclusion, successful: true };
   }
-  
+
   /**
    * Analogy reasoning - use similar cases
    * @private
    */
   async analogyReasoning(problem, context) {
     this.addStep(STEP_TYPE.OBSERVE, `Finding analogies for: ${problem}`, {}, 0.9);
-    
+
     // Find similar cases
     const analogies = this.findAnalogies(problem, context);
     this.addStep(STEP_TYPE.THINK, `Found ${analogies.length} similar cases`, { analogies }, 0.8);
-    
+
     if (analogies.length === 0) {
-      this.addStep(STEP_TYPE.REFLECT, 'No suitable analogies found, falling back to chain of thought', {}, 0.5);
+      this.addStep(
+        STEP_TYPE.REFLECT,
+        'No suitable analogies found, falling back to chain of thought',
+        {},
+        0.5
+      );
       return this.chainOfThought(problem, context);
     }
-    
+
     // Apply best analogy
     const best = analogies[0];
     this.addStep(STEP_TYPE.PLAN, `Applying analogy: ${best.description}`, { analogy: best }, 0.75);
-    
+
     const conclusion = this.applyAnalogy(best, problem, context);
     this.addStep(STEP_TYPE.ACT, `Derived solution from analogy`, { conclusion }, 0.8);
-    
+
     return { conclusion, successful: true };
   }
-  
+
   /**
    * Add a reasoning step
    * @param {string} type - Step type
@@ -329,25 +393,25 @@ class ReasoningEngine extends EventEmitter {
    */
   addStep(type, content, metadata = {}, confidence = 0.5) {
     if (!this.currentTrace) return;
-    
+
     const step = {
       id: `step-${++this.stepCounter}`,
       type,
       content,
       metadata,
       confidence,
-      timestamp: Date.now()
+      timestamp: Date.now(),
     };
-    
+
     this.currentTrace.steps.push(step);
     this.emit('reasoning:step', { step, traceId: this.currentTrace.id });
-    
+
     // Check step limit
     if (this.currentTrace.steps.length >= this.maxSteps) {
       throw new Error('Maximum reasoning steps exceeded');
     }
   }
-  
+
   /**
    * Decompose problem into sub-problems
    * @private
@@ -355,11 +419,11 @@ class ReasoningEngine extends EventEmitter {
   decomposeProlem(problem) {
     // Simple keyword-based decomposition
     const parts = [];
-    
+
     // Look for conjunction patterns
     const conjunctions = ['and', 'then', 'also', 'additionally', 'furthermore'];
     let remaining = problem;
-    
+
     for (const conj of conjunctions) {
       const regex = new RegExp(`\\s+${conj}\\s+`, 'gi');
       if (regex.test(remaining)) {
@@ -369,26 +433,24 @@ class ReasoningEngine extends EventEmitter {
         break;
       }
     }
-    
+
     if (remaining) {
       parts.push(remaining);
     }
-    
+
     // Clean up and filter
-    return parts
-      .map(p => p.trim())
-      .filter(p => p.length > 0);
+    return parts.map(p => p.trim()).filter(p => p.length > 0);
   }
-  
+
   /**
    * Solve a sub-problem
    * @private
    */
-  async solveSubProblem(subProblem, context) {
+  async solveSubProblem(subProblem, _context) {
     // Simplified solution generation
     return `Resolved: ${subProblem.substring(0, 50)}...`;
   }
-  
+
   /**
    * Synthesize solutions
    * @private
@@ -396,10 +458,10 @@ class ReasoningEngine extends EventEmitter {
   synthesize(solutions) {
     if (solutions.length === 0) return 'No solutions found';
     if (solutions.length === 1) return solutions[0].solution;
-    
+
     return solutions.map(s => s.solution).join(' → ');
   }
-  
+
   /**
    * Reflect on solution
    * @private
@@ -408,40 +470,45 @@ class ReasoningEngine extends EventEmitter {
     // Simple reflection logic
     const hasConclusion = conclusion && conclusion.length > 0;
     const hasMultipleSolutions = solutions.length > 1;
-    
+
     let confidence = 0.5;
     let content = 'Analyzing solution quality...';
-    
+
     if (hasConclusion) {
       confidence += 0.2;
       content = 'Solution generated successfully.';
     }
-    
+
     if (hasMultipleSolutions) {
       confidence += 0.1;
       content += ' Multiple approaches considered.';
     }
-    
+
     // Check if conclusion addresses the problem
     const problemWords = problem.toLowerCase().split(/\s+/);
     const conclusionWords = (conclusion || '').toLowerCase().split(/\s+/);
     const overlap = problemWords.filter(w => conclusionWords.includes(w)).length;
-    
+
     if (overlap > 2) {
       confidence += 0.1;
       content += ' Conclusion appears relevant to problem.';
     }
-    
+
     return { confidence: Math.min(confidence, 1), content };
   }
-  
+
   /**
    * Backtrack and try alternative approach
    * @private
    */
   async backtrack(problem, context, reflection) {
-    this.addStep(STEP_TYPE.REFLECT, `Confidence too low (${reflection.confidence.toFixed(2)}), backtracking...`, {}, reflection.confidence);
-    
+    this.addStep(
+      STEP_TYPE.REFLECT,
+      `Confidence too low (${reflection.confidence.toFixed(2)}), backtracking...`,
+      {},
+      reflection.confidence
+    );
+
     // Try decomposition as fallback
     const decomposition = this.decomposeProlem(problem);
     if (decomposition.length > 1) {
@@ -453,44 +520,40 @@ class ReasoningEngine extends EventEmitter {
       const conclusion = this.synthesize(solutions);
       return { conclusion, successful: true };
     }
-    
+
     return { conclusion: 'Unable to reach confident solution', successful: false };
   }
-  
+
   /**
    * Generate multiple initial thoughts
    * @private
    */
   generateThoughts(problem, count) {
     const thoughts = [];
-    const approaches = [
-      'Direct approach: ',
-      'Step-by-step: ',
-      'Alternative perspective: '
-    ];
-    
+    const approaches = ['Direct approach: ', 'Step-by-step: ', 'Alternative perspective: '];
+
     for (let i = 0; i < Math.min(count, approaches.length); i++) {
       thoughts.push(`${approaches[i]}${problem.substring(0, 50)}`);
     }
-    
+
     return thoughts;
   }
-  
+
   /**
    * Develop a reasoning branch
    * @private
    */
-  async developBranch(thought, problem, context) {
+  async developBranch(thought, _problem, _context) {
     const steps = [];
-    
+
     steps.push({ content: `Developing: ${thought}`, type: 'develop' });
     steps.push({ content: `Analyzing implications`, type: 'analyze' });
-    
+
     const conclusion = `Branch conclusion for: ${thought.substring(0, 30)}`;
-    
+
     return { steps, conclusion };
   }
-  
+
   /**
    * Evaluate a reasoning branch
    * @private
@@ -498,30 +561,30 @@ class ReasoningEngine extends EventEmitter {
   evaluateBranch(branch) {
     // Simple scoring based on step count and conclusion
     let score = 0.5;
-    
+
     if (branch.conclusion) score += 0.2;
     if (branch.steps.length > 0) score += 0.1;
     if (branch.steps.length > 2) score += 0.1;
-    
+
     return Math.min(score, 1);
   }
-  
+
   /**
    * Generate initial solution
    * @private
    */
-  async generateInitialSolution(problem, context) {
+  async generateInitialSolution(problem, _context) {
     return `Initial approach to: ${problem.substring(0, 50)}`;
   }
-  
+
   /**
    * Refine existing solution
    * @private
    */
-  async refineSolution(solution, problem, context) {
+  async refineSolution(solution, _problem, _context) {
     return `Refined: ${solution}`;
   }
-  
+
   /**
    * Hierarchical decomposition
    * @private
@@ -531,11 +594,11 @@ class ReasoningEngine extends EventEmitter {
       root: problem,
       children: this.decomposeProlem(problem).map(p => ({
         content: p,
-        children: []
-      }))
+        children: [],
+      })),
     };
   }
-  
+
   /**
    * Format decomposition for display
    * @private
@@ -543,23 +606,23 @@ class ReasoningEngine extends EventEmitter {
   formatDecomposition(decomposition, indent = 0) {
     const prefix = '  '.repeat(indent);
     let result = `${prefix}└ ${decomposition.root || decomposition.content}`;
-    
+
     if (decomposition.children) {
       for (const child of decomposition.children) {
         result += '\n' + this.formatDecomposition(child, indent + 1);
       }
     }
-    
+
     return result;
   }
-  
+
   /**
    * Solve problems bottom-up
    * @private
    */
   async solveBottomUp(decomposition, context) {
     const results = [];
-    
+
     // Solve leaf nodes first
     if (decomposition.children) {
       for (const child of decomposition.children) {
@@ -567,10 +630,10 @@ class ReasoningEngine extends EventEmitter {
         results.push({ problem: child.content, solution });
       }
     }
-    
+
     return { results, solvedCount: results.length };
   }
-  
+
   /**
    * Compose solution from parts
    * @private
@@ -579,25 +642,25 @@ class ReasoningEngine extends EventEmitter {
     if (results.length === 0) return 'No solution components';
     return results.map(r => r.solution).join('; ');
   }
-  
+
   /**
    * Find analogies for problem
    * @private
    */
-  findAnalogies(problem, context) {
+  findAnalogies(_problem, _context) {
     // Placeholder for analogy retrieval
     // In real implementation, would search knowledge base
     return [];
   }
-  
+
   /**
    * Apply analogy to derive solution
    * @private
    */
-  applyAnalogy(analogy, problem, context) {
+  applyAnalogy(analogy, _problem, _context) {
     return `Applied ${analogy.description} to derive solution`;
   }
-  
+
   /**
    * Generate unique ID
    * @private
@@ -605,7 +668,7 @@ class ReasoningEngine extends EventEmitter {
   generateId() {
     return `trace-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
   }
-  
+
   /**
    * Get reasoning trace by ID
    * @param {string} traceId - Trace identifier
@@ -614,7 +677,7 @@ class ReasoningEngine extends EventEmitter {
   getTrace(traceId) {
     return this.traces.get(traceId) || null;
   }
-  
+
   /**
    * Get all traces
    * @returns {ReasoningTrace[]}
@@ -622,7 +685,7 @@ class ReasoningEngine extends EventEmitter {
   getAllTraces() {
     return Array.from(this.traces.values());
   }
-  
+
   /**
    * Clear all traces
    */
@@ -630,7 +693,7 @@ class ReasoningEngine extends EventEmitter {
     this.traces.clear();
     this.stepCounter = 0;
   }
-  
+
   /**
    * Get statistics
    * @returns {Object}
@@ -639,20 +702,19 @@ class ReasoningEngine extends EventEmitter {
     const traces = this.getAllTraces();
     const successful = traces.filter(t => t.successful).length;
     const totalSteps = traces.reduce((sum, t) => sum + t.steps.length, 0);
-    const avgTime = traces.length > 0 
-      ? traces.reduce((sum, t) => sum + t.totalTime, 0) / traces.length 
-      : 0;
-    
+    const avgTime =
+      traces.length > 0 ? traces.reduce((sum, t) => sum + t.totalTime, 0) / traces.length : 0;
+
     return {
       totalTraces: traces.length,
       successfulTraces: successful,
       successRate: traces.length > 0 ? successful / traces.length : 0,
       totalSteps,
       averageStepsPerTrace: traces.length > 0 ? totalSteps / traces.length : 0,
-      averageTime: avgTime
+      averageTime: avgTime,
     };
   }
-  
+
   /**
    * Export trace to readable format
    * @param {string} traceId - Trace identifier
@@ -661,22 +723,22 @@ class ReasoningEngine extends EventEmitter {
   exportTrace(traceId) {
     const trace = this.getTrace(traceId);
     if (!trace) return '';
-    
+
     let output = `# Reasoning Trace: ${trace.id}\n\n`;
     output += `**Problem:** ${trace.problem}\n\n`;
     output += `**Strategy:** ${trace.strategy}\n\n`;
     output += `## Steps\n\n`;
-    
+
     for (const step of trace.steps) {
       output += `### ${step.type.toUpperCase()} (confidence: ${step.confidence.toFixed(2)})\n`;
       output += `${step.content}\n\n`;
     }
-    
+
     output += `## Conclusion\n\n`;
     output += `${trace.conclusion || 'No conclusion reached'}\n\n`;
     output += `**Successful:** ${trace.successful ? 'Yes' : 'No'}\n`;
     output += `**Total Time:** ${trace.totalTime}ms\n`;
-    
+
     return output;
   }
 }
@@ -706,5 +768,5 @@ module.exports = {
   createReasoningEngine,
   reason,
   STRATEGY,
-  STEP_TYPE
+  STEP_TYPE,
 };