@gotza02/mathinking 3.1.6 → 3.1.8

package/dist/tools/sequential-thinking.js

@@ -67,7 +67,8 @@ export class SequentialThinkingManager {
             // Force cleanup by calling purge (if available) or by checking entries
             for (const [key, value] of this.sessions.entries()) {
                 const age = Date.now() - new Date(value.updatedAt).getTime();
-                if (age > 1000 * 60 * 60 * 24) { // 24 hours
+                if (age > 1000 * 60 * 60 * 24) {
+                    // 24 hours
                     this.sessions.delete(key);
                 }
             }
@@ -107,14 +108,14 @@ export class SequentialThinkingManager {
             try {
                 data = await fs.readFile(this.storagePath, 'utf8');
             }
-            catch (primaryError) {
+            catch {
                 // Primary storage failed, try backup
                 try {
                     console.log('[Brain] Primary storage not found, trying backup...');
                     data = await fs.readFile(this.backupPath, 'utf8');
                     useBackup = true;
                 }
-                catch (backupError) {
+                catch {
                     // Backup also failed, start fresh
                     console.log('[Brain] No existing storage found, starting fresh');
                     this.initialized = true;
@@ -234,10 +235,10 @@ export class SequentialThinkingManager {
                     innerResult = this.startSession(validatedInput);
                     break;
                 case 'add_thought':
-                    innerResult = this.addThought(validatedInput);
+                    innerResult = await this.addThought(validatedInput);
                     break;
                 case 'create_branch':
-                    innerResult = this.createBranch(validatedInput);
+                    innerResult = await this.createBranch(validatedInput);
                     break;
                 case 'generate_options':
                     innerResult = this.generateOptions(validatedInput);
@@ -249,16 +250,16 @@ export class SequentialThinkingManager {
                     innerResult = this.selectOption(validatedInput);
                     break;
                 case 'revise_thought':
-                    innerResult = this.reviseThought(validatedInput);
+                    innerResult = await this.reviseThought(validatedInput);
                     break;
                 case 'set_hypothesis':
-                    innerResult = this.setHypothesis(validatedInput);
+                    innerResult = await this.setHypothesis(validatedInput);
                     break;
                 case 'verify_hypothesis':
-                    innerResult = this.verifyHypothesis(validatedInput);
+                    innerResult = await this.verifyHypothesis(validatedInput);
                     break;
                 case 'conclude':
-                    innerResult = this.conclude(validatedInput);
+                    innerResult = await this.conclude(validatedInput);
                     break;
                 // execute_conclusion handled outside
                 case 'reflect':
@@ -276,7 +277,8 @@ export class SequentialThinkingManager {
                 case 'get_history':
                     innerResult = this.getHistory(validatedInput);
                     break;
-                default: innerResult = this.startSession(validatedInput);
+                default:
+                    innerResult = this.startSession(validatedInput);
             }
             if (innerResult.success)
                 await this._saveToStorage();
@@ -317,6 +319,7 @@ export class SequentialThinkingManager {
     }
     research(input) {
         const session = this.getSession(input.sessionId);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         if (!session)
             return { success: false, message: 'Session not found' };
         const topic = input.thought || session.problemStatement;
@@ -391,13 +394,15 @@ export class SequentialThinkingManager {
             suggestedPlan = {
                 planId: 'recovery-' + uuidv4().substring(0, 8),
                 name: 'Network Recovery Plan',
-                tasks: [{
+                tasks: [
+                    {
                         id: 'fallback',
                         name: 'Fallback Echo',
                         toolName: 'echo',
                         toolInput: { msg: 'Recovered using fallback echo due to network failure.' },
                         dependencies: []
-                    }]
+                    }
+                ]
             };
         }
         return {
@@ -420,6 +425,8 @@ export class SequentialThinkingManager {
             thoughtHistory: [],
             branches: [],
             status: 'in_progress',
+            thinkingStyle: input.thinkingStyle || 'Analytical',
+            currentPhase: input.phase || 'Definition',
             createdAt: new Date().toISOString(),
             updatedAt: new Date().toISOString()
         };
@@ -427,10 +434,12 @@ export class SequentialThinkingManager {
         this.lastSessionId = sessionId;
         // 🔧 NEW: Query past solutions for context
         this.queryPastSolutions(session.problemStatement)
-            .then(solutions => {
+            .then((solutions) => {
             if (solutions.length > 0) {
                 console.log(`[Brain] Found ${solutions.length} similar past problems`);
-                const context = solutions.map(s => `- ${s.problem} (relevance: ${(s.relevance * 100).toFixed(0)}%)\n  Patterns: ${s.patterns.join(', ')}`).join('\n');
+                const context = solutions
+                    .map((s) => `- ${s.problem} (relevance: ${(s.relevance * 100).toFixed(0)}%)\n  Patterns: ${s.patterns.join(', ')}`)
+                    .join('\n');
                 // Add as a thought for AI to see
                 const thought = {
                     id: uuidv4(),
@@ -446,20 +455,25 @@ export class SequentialThinkingManager {
                 this._saveToStorage();
             }
         })
-            .catch(err => console.warn('[Brain] Failed to query past solutions:', err));
+            .catch((err) => console.warn('[Brain] Failed to query past solutions:', err));
         return {
             success: true,
             sessionId,
             currentStep: 0,
             totalThoughts: session.totalThoughts,
             status: 'in_progress',
-            message: 'Brain 2.0 Session Started. Ready for Tree of Thoughts. Querying past solutions...'
+            message: `Brain 2.0 Session Started. Style: ${session.thinkingStyle}, Phase: ${session.currentPhase}. Ready for Tree of Thoughts. Querying past solutions...`
         };
     }
-    addThought(input) {
+    async addThought(input) {
         const session = this.getSession(input.sessionId);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         if (!session)
             return { success: false, message: 'Session not found' };
+        if (input.phase)
+            session.currentPhase = input.phase;
+        if (input.thinkingStyle)
+            session.thinkingStyle = input.thinkingStyle;
         session.currentStep++;
         const thought = {
             id: uuidv4(),
@@ -469,9 +483,56 @@ export class SequentialThinkingManager {
             timestamp: new Date().toISOString(),
             confidence: input.confidence ?? 70, // Default confidence
             parentId: input.branchFromThoughtId || this.getLastThoughtId(session),
-            branchLabel: input.branchLabel // Preserve label
+            branchLabel: input.branchLabel, // Preserve label
+            phase: session.currentPhase
         };
         session.thoughtHistory.push(thought);
+        // 🔧 Action 3: Complexity Routing (Simple Heuristic)
+        // If problem statement is short (< 50 chars), suggest simple execution.
+        // If long or contains "plan", "complex", "research", suggest full sequential thinking.
+        let complexityAnalysis;
+        if (session.currentStep === 0) {
+            const problemLength = session.problemStatement.length;
+            const keywords = ['complex', 'plan', 'research', 'analyze', 'strategy', 'architecture'];
+            const isComplex = problemLength > 100 ||
+                keywords.some((k) => session.problemStatement.toLowerCase().includes(k));
+            complexityAnalysis = isComplex
+                ? 'Complexity: HIGH. Recommendation: Use full Sequential Thinking with multiple branches.'
+                : 'Complexity: LOW. Recommendation: You might be able to solve this directly with a single tool call or short sequence.';
+            // Auto-set style for complex problems
+            if (isComplex && session.thinkingStyle === 'Analytical') {
+                // Keep Analytical default
+            }
+        }
+        // 🔧 Action 2: Intelligent Tool Recommendation
+        const recommendedTools = this.recommendTools(thought.thought, session.currentPhase);
+        // 🔧 Action 1+: Guidance based on Style/Phase
+        const guidance = this.getGuidance(session.thinkingStyle, session.currentPhase);
+        // 🔧 Action 5: Deeper Memory Integration (Async check for sub-problems)
+        let relatedMemories = [];
+        if (['decomposition', 'replan', 'hypothesis'].includes(thought.thoughtType)) {
+            // We await this one to provide immediate context, or we could fire-and-forget
+            // For better decision making, immediate is better.
+            try {
+                const past = await this.queryPastSolutions(thought.thought);
+                if (past.length > 0) {
+                    relatedMemories = past.slice(0, 2); // Top 2 relevant memories
+                    thought.metadata = { ...thought.metadata, relatedMemories };
+                }
+            }
+            catch (e) {
+                console.warn('[Brain] Failed to query memory in addThought:', e);
+            }
+        }
+        // 🔧 Action 3: Suggest router tool if complexity is high
+        if (complexityAnalysis && complexityAnalysis.includes('HIGH')) {
+            recommendedTools.push({
+                toolName: 'decompose',
+                confidence: 0.95,
+                rationale: 'High complexity detected. Break down the problem first.',
+                suggestedInput: { thought: 'Break down the main problem into sub-components' }
+            });
+        }
         return {
             success: true,
             sessionId: session.sessionId,
@@ -479,11 +540,125 @@ export class SequentialThinkingManager {
             totalThoughts: session.totalThoughts,
             status: session.status,
             thought,
-            message: `Thought added (${thought.thoughtType})`
+            message: `Thought added (${thought.thoughtType}) - Style: ${session.thinkingStyle}, Phase: ${session.currentPhase}`,
+            recommendedTools,
+            guidance: guidance + (complexityAnalysis ? ` [${complexityAnalysis}]` : ''),
+            metadata: { relatedMemories: relatedMemories.length > 0 ? relatedMemories : undefined }
         };
     }
+    getGuidance(style, phase) {
+        let guidance = '';
+        // Style-based guidance
+        switch (style) {
+            case 'Analytical':
+                guidance +=
+                    'Focus on breaking down the problem into logical components and evaluating data objectively. ';
+                break;
+            case 'Creative':
+                guidance +=
+                    'Brainstorm multiple alternative solutions, even those that seem unconventional. Use analogies. ';
+                break;
+            case 'Critical':
+                guidance +=
+                    'Look for potential flaws, risks, and assumptions in the current line of reasoning. Challenge everything. ';
+                break;
+            case 'Emotional':
+                guidance +=
+                    'Consider the human impact, user experience, and how stakeholders might feel about the solution. ';
+                break;
+            case 'Optimistic':
+                guidance +=
+                    'Focus on the benefits, opportunities, and the "best-case" scenario. What makes this succeed? ';
+                break;
+            case 'Synthesis':
+                guidance +=
+                    'Combine different perspectives and findings into a coherent and actionable conclusion. ';
+                break;
+        }
+        // Phase-based guidance
+        switch (phase) {
+            case 'Definition':
+                guidance += 'Ensure the problem is clearly defined and constraints are understood.';
+                break;
+            case 'Exploration':
+                guidance += 'Gather information and explore the solution space without committing yet.';
+                break;
+            case 'Analysis':
+                guidance += 'Deeply examine the gathered information and identify patterns or root causes.';
+                break;
+            case 'Evaluation':
+                guidance += 'Score and compare different options based on criteria like risk and impact.';
+                break;
+            case 'Synthesis':
+                guidance += 'Merge ideas and start forming the final solution plan.';
+                break;
+            case 'Conclusion':
+                guidance += 'Finalize the result and ensure it directly addresses the original problem.';
+                break;
+        }
+        return guidance.trim();
+    }
+    recommendTools(thought, phase) {
+        const recommendations = [];
+        const text = thought.toLowerCase();
+        // Heuristics based on keywords and phase
+        if (text.includes('search') ||
+            text.includes('find') ||
+            text.includes('research') ||
+            phase === 'Exploration') {
+            recommendations.push({
+                toolName: 'web_search',
+                confidence: 0.9,
+                rationale: 'Thought involves searching for information or is in Exploration phase.',
+                suggestedInput: { query: thought }
+            });
+            recommendations.push({
+                toolName: 'vector_search',
+                confidence: 0.7,
+                rationale: 'Check local semantic memory for related concepts.',
+                suggestedInput: { query: thought }
+            });
+        }
+        if (text.includes('save') || text.includes('remember') || text.includes('note')) {
+            recommendations.push({
+                toolName: 'vector_save',
+                confidence: 0.8,
+                rationale: 'Thought suggests a need to persist information.',
+                suggestedInput: { content: thought }
+            });
+        }
+        if (text.includes('calculate') ||
+            text.includes('compute') ||
+            text.includes('math') ||
+            phase === 'Analysis') {
+            recommendations.push({
+                toolName: 'compute',
+                confidence: 0.8,
+                rationale: 'Analytical thoughts often benefit from precise computation.',
+                suggestedInput: { expression: '...' }
+            });
+        }
+        if (text.includes('file') || text.includes('write') || phase === 'Conclusion') {
+            recommendations.push({
+                toolName: 'write_file',
+                confidence: 0.7,
+                rationale: 'Thought mentions files or is in Conclusion phase, suggesting report generation.',
+                suggestedInput: { file_path: '...', content: '...' }
+            });
+        }
+        if (text.includes('list') || text.includes('directory')) {
+            recommendations.push({
+                toolName: 'list_directory',
+                confidence: 0.9,
+                rationale: 'Direct mention of directory/listing.',
+                suggestedInput: { dir_path: '.' }
+            });
+        }
+        return recommendations;
+    }
     generateOptions(input) {
         const session = this.getSession(input.sessionId);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         if (!session)
             return { success: false, message: 'Session not found' };
         // 🔧 NEW: Generate 3-5 distinct options using templates
@@ -492,7 +667,9 @@ export class SequentialThinkingManager {
         const thought = {
             id: uuidv4(),
             stepNumber: session.currentStep,
-            thought: `GENERATED OPTIONS:\n${options.map((o, i) => `${i + 1}. ${o.label}\n   ${o.description}\n   Effort: ${o.estimatedEffort}, Risk: ${o.riskLevel}`).join('\n')}`,
+            thought: `GENERATED OPTIONS:\n${options
+                .map((o, i) => `${i + 1}. ${o.label}\n   ${o.description}\n   Effort: ${o.estimatedEffort}, Risk: ${o.riskLevel}`)
+                .join('\n')}`,
             thoughtType: 'option_generation',
             timestamp: new Date().toISOString(),
             confidence: 75,
@@ -514,6 +691,7 @@ export class SequentialThinkingManager {
     }
     evaluateOptions(input) {
         const session = this.getSession(input.sessionId);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         if (!session)
             return { success: false, message: 'Session not found' };
         // 🔧 NEW: Evaluate last thought's options
@@ -526,9 +704,10 @@ export class SequentialThinkingManager {
                 totalThoughts: session.totalThoughts,
                 status: session.status,
                 message: 'No options found in last thought. Use generateOptions first.'
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
             };
         }
-        const options = lastThought.metadata.options;
+        const options = lastThought.metadata.options || [];
         // 🔧 BUG FIX: Validate array before processing
         if (!Array.isArray(options) || options.length === 0) {
             return {
@@ -538,6 +717,7 @@ export class SequentialThinkingManager {
                 totalThoughts: session.totalThoughts,
                 status: session.status,
                 message: 'Invalid options in metadata. Use generateOptions first.'
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
             };
         }
         const evaluatedOptions = options.map((opt) => {
@@ -547,7 +727,7 @@ export class SequentialThinkingManager {
             return {
                 ...opt,
                 scores: { feasibility, impact, risk },
-                totalScore: (feasibility * 0.4) + (impact * 0.4) + ((1 - risk) * 0.2),
+                totalScore: feasibility * 0.4 + impact * 0.4 + (1 - risk) * 0.2,
                 reasoning: `Feasibility: ${(feasibility * 100).toFixed(0)}%, Impact: ${(impact * 100).toFixed(0)}%, Risk: ${(risk * 100).toFixed(0)}%`,
                 confidence: 80,
                 uncertainty: 0.15
@@ -557,7 +737,9 @@ export class SequentialThinkingManager {
         const thought = {
             id: uuidv4(),
             stepNumber: session.currentStep,
-            thought: `EVALUATED OPTIONS:\n${evaluatedOptions.map((o, i) => `${i + 1}. ${o.label}: ${o.totalScore.toFixed(2)}\n   ${o.reasoning}`).join('\n')}`,
+            thought: `EVALUATED OPTIONS:\n${evaluatedOptions
+                .map((o, i) => `${i + 1}. ${o.label}: ${o.totalScore.toFixed(2)}\n   ${o.reasoning}`)
+                .join('\n')}`,
             thoughtType: 'option_evaluation',
             timestamp: new Date().toISOString(),
             confidence: 80,
@@ -578,6 +760,8 @@ export class SequentialThinkingManager {
             };
         }
         const best = [...evaluatedOptions].sort((a, b) => b.totalScore - a.totalScore)[0];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const bestOption = best;
         return {
             success: true,
             sessionId: session.sessionId,
@@ -585,27 +769,30 @@ export class SequentialThinkingManager {
             totalThoughts: session.totalThoughts,
             status: session.status,
             thought,
-            message: `Evaluated ${evaluatedOptions.length} options. Best: ${best.label} (${best.totalScore.toFixed(2)})`,
+            message: `Evaluated ${evaluatedOptions.length} options. Best: ${bestOption.label} (${bestOption.totalScore.toFixed(2)})`,
             nextSuggestedActions: ['select_option']
         };
     }
     selectOption(input) {
         const session = this.getSession(input.sessionId);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         if (!session)
             return { success: false, message: 'Session not found' };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         if (!input.optionId)
             return { success: false, message: 'optionId required' };
-        const selected = session.thoughtHistory.find(t => t.id === input.optionId);
+        const selected = session.thoughtHistory.find((t) => t.id === input.optionId);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         if (!selected)
             return { success: false, message: 'Option not found' };
         // 🔧 NEW: Enhanced selection with evaluation data
         const evalThought = session.thoughtHistory
-            .filter(t => t.thoughtType === 'option_evaluation')
+            .filter((t) => t.thoughtType === 'option_evaluation')
             .slice(-1)[0];
         let evalData = null;
         if (evalThought?.metadata?.evaluatedOptions) {
             const options = evalThought.metadata.evaluatedOptions;
-            evalData = options.find((o) => o.id === input.optionId);
+            evalData = options.find((o) => o.id === input.optionId) || null;
         }
         const confidence = evalData?.confidence || 85;
         const uncertainty = evalData?.uncertainty || 0.15;
@@ -659,7 +846,9 @@ export class SequentialThinkingManager {
         };
         session.thoughtHistory.push(thought);
         if (input.thought && input.thought.length > 50) {
-            vectorMemory.add(`Reflexion on ${session.problemStatement}: ${input.thought}`, { sessionId: session.sessionId });
+            vectorMemory.add(`Reflexion on ${session.problemStatement}: ${input.thought}`, {
+                sessionId: session.sessionId
+            });
         }
         return {
             success: true,
@@ -707,16 +896,21 @@ export class SequentialThinkingManager {
             plan = {
                 planId: 'auto-' + uuidv4(),
                 name: 'Auto Plan',
-                tasks: [{
+                tasks: [
+                    {
                         id: 't1',
                         name: 'Auto Echo',
                         toolName: 'echo',
                         toolInput: { text: 'Running fallback due to invalid plan format.' },
                         dependencies: []
-                    }]
+                    }
+                ]
             };
         }
-        const execResult = await orchestratorManager.process({ action: 'execute_plan', plan: plan });
+        const execResult = await orchestratorManager.process({
+            action: 'execute_plan',
+            plan: plan
+        });
         // 🔧 NEW: Learn from execution outcome
         await this.analyzeExecutionOutcome(session, execResult);
         await this.process({
@@ -733,7 +927,9 @@ export class SequentialThinkingManager {
             currentStep: session.currentStep,
             totalThoughts: session.totalThoughts,
             status: session.status,
-            message: execResult.success ? `Execution Success. Reflexion triggered.` : `Execution Failed: ${execResult.message}. Reflexion triggered.`,
+            message: execResult.success
+                ? `Execution Success. Reflexion triggered.`
+                : `Execution Failed: ${execResult.message}. Reflexion triggered.`,
             executionResult: execResult.result,
             metadata: { validationErrors: execResult.validationErrors }
         };
@@ -754,7 +950,9 @@ export class SequentialThinkingManager {
         return this.sessions.get(id);
     }
     getLastThoughtId(session) {
-        return session.thoughtHistory.length > 0 ? session.thoughtHistory[session.thoughtHistory.length - 1].id : undefined;
+        return session.thoughtHistory.length > 0
+            ? session.thoughtHistory[session.thoughtHistory.length - 1].id
+            : undefined;
     }
     // 🔧 NEW: Helper methods for ToT implementation
     generateThoughtOptions(session, context) {
@@ -792,22 +990,25 @@ export class SequentialThinkingManager {
         // 🔧 BUG FIX: Add null safety
         if (!opt || typeof opt !== 'object')
             return 0.5;
+        const effort = opt.estimatedEffort;
         const effortMap = { low: 0.9, medium: 0.6, high: 0.3 };
-        return effortMap[opt.estimatedEffort] || 0.5;
+        return effortMap[effort] || 0.5;
     }
     estimateImpact(opt) {
         // 🔧 BUG FIX: Add null safety
         if (!opt || typeof opt !== 'object')
             return 0.5;
+        const risk = opt.riskLevel;
         const riskMap = { low: 0.4, medium: 0.7, high: 0.9 };
-        return riskMap[opt.riskLevel] || 0.5;
+        return riskMap[risk] || 0.5;
     }
     estimateRisk(opt) {
         // 🔧 BUG FIX: Add null safety
         if (!opt || typeof opt !== 'object')
             return 0.5;
+        const risk = opt.riskLevel;
         const riskMap = { low: 0.1, medium: 0.4, high: 0.7 };
-        return riskMap[opt.riskLevel] || 0.5;
+        return riskMap[risk] || 0.5;
     }
     // 🔧 NEW: Learning System methods
     async analyzeExecutionOutcome(session, result) {
@@ -846,7 +1047,9 @@ export class SequentialThinkingManager {
         }
         else {
             const errorMsg = result.message || result.result?.errors?.[0]?.error || '';
-            if (errorMsg.includes('fetch') || errorMsg.includes('network') || errorMsg.includes('ECONNREFUSED')) {
+            if (errorMsg.includes('fetch') ||
+                errorMsg.includes('network') ||
+                errorMsg.includes('ECONNREFUSED')) {
                 patterns.push('network-failure');
             }
             if (errorMsg.includes('timeout') || errorMsg.includes('timed out')) {
@@ -893,7 +1096,7 @@ export class SequentialThinkingManager {
         const query = `Similar problems to: ${problem}`;
         try {
             const results = await vectorMemory.search(query, 5);
-            return results.map(r => ({
+            return results.map((r) => ({
                 problem: r.item.content,
                 solution: r.item.metadata,
                 relevance: r.score || 0.5,
@@ -906,10 +1109,18 @@ export class SequentialThinkingManager {
             return [];
         }
     }
-    createBranch(input) { return this.addThought(input); }
-    reviseThought(input) { return this.addThought({ ...input, thoughtType: 'revision' }); }
-    setHypothesis(input) { return this.addThought({ ...input, thoughtType: 'hypothesis' }); }
-    verifyHypothesis(input) { return this.addThought({ ...input, thoughtType: 'verification' }); }
+    createBranch(input) {
+        return this.addThought(input);
+    }
+    reviseThought(input) {
+        return this.addThought({ ...input, thoughtType: 'revision' });
+    }
+    setHypothesis(input) {
+        return this.addThought({ ...input, thoughtType: 'hypothesis' });
+    }
+    verifyHypothesis(input) {
+        return this.addThought({ ...input, thoughtType: 'verification' });
+    }
     conclude(input) {
         const session = this.getSession(input.sessionId);
         if (session) {