@polybiouslabs/polybious/dist/core/simulation.js

Polybius is a next-generation intelligent agent framework built for adaptability across diverse domains. It merges contextual awareness, multi-agent collaboration, and predictive reasoning to deliver dynamic, self-optimizing performance.

import { logger } from '../config/logger.js';
import * as fs from 'fs/promises';
import * as path from 'path';

export class ScenarioSimulationEngine {
    scenarios = new Map();
    models = new Map();
    historicalData = [];
    simulationPath;
    
    constructor() {
        this.simulationPath = path.join('data', 'simulations', 'scenarios.json');
        this.initializeModels();
        this.loadSimulations();
    }

    async runScenario(description, parameters = {}) {
        const scenarioId = `sim_${Date.now()}_${Math.random().toString(36).substring(7)}`;
        
        logger.info(`Running scenario simulation: ${description}`);
        
        const scenario = {
            id: scenarioId,
            description,
            parameters,
            timestamp: new Date(),
            status: 'running'
        };

        this.scenarios.set(scenarioId, scenario);

        try {
            // Analyze scenario type and select appropriate model
            const scenarioType = this.classifyScenario(description);
            const model = this.models.get(scenarioType) || this.models.get('general');
            
            // Run simulation
            const result = await this.executeSimulation(scenario, model);
            
            scenario.status = 'completed';
            scenario.result = result;
            scenario.completedAt = new Date();
            
            await this.saveSimulations();
            
            logger.info(`Scenario simulation completed`, {
                id: scenarioId,
                trend: result.trend,
                confidence: result.confidence
            });

            return result;
            
        } catch (error) {
            scenario.status = 'failed';
            scenario.error = error.message;
            logger.error(`Scenario simulation failed`, { id: scenarioId, error: error.message });
            throw error;
        }
    }

    async trainModel(historicalData, modelType = 'general') {
        logger.info(`Training model: ${modelType} with ${historicalData.length} data points`);
        
        const model = this.models.get(modelType) || this.createNewModel(modelType);
        
        // Process training data
        const processedData = this.preprocessTrainingData(historicalData, modelType);
        
        // Update model weights and patterns
        await this.updateModelWeights(model, processedData);
        
        // Validate model performance
        const validation = await this.validateModel(model, processedData);
        
        model.lastTrained = new Date();
        model.accuracy = validation.accuracy;
        model.dataPoints = historicalData.length;
        
        this.models.set(modelType, model);
        
        logger.info(`Model training completed`, {
            modelType,
            accuracy: validation.accuracy,
            dataPoints: historicalData.length
        });
        
        return validation;
    }

    async getRecommendations(currentState, scenarioType = 'general') {
        const model = this.models.get(scenarioType) || this.models.get('general');
        const analysis = await this.analyzeCurrentState(currentState, model);
        
        const recommendations = [];
        
        // Generate actionable recommendations based on analysis
        if (analysis.risk > 0.7) {
            recommendations.push({
                type: 'risk_mitigation',
                priority: 'high',
                action: 'Implement risk mitigation strategies immediately',
                impact: 'Reduces potential negative outcomes by 40-60%',
                confidence: analysis.confidence
            });
        }
        
        if (analysis.opportunities.length > 0) {
            analysis.opportunities.forEach(opp => {
                recommendations.push({
                    type: 'opportunity',
                    priority: opp.priority || 'medium',
                    action: opp.description,
                    impact: opp.expectedImpact || 'Moderate positive impact expected',
                    confidence: opp.confidence || 0.6
                });
            });
        }
        
        if (analysis.trends.length > 0) {
            const strongTrends = analysis.trends.filter(t => t.strength > 0.6);
            strongTrends.forEach(trend => {
                recommendations.push({
                    type: 'trend_alignment',
                    priority: 'medium',
                    action: `Align strategy with ${trend.direction} trend in ${trend.area}`,
                    impact: `Potential ${trend.direction === 'positive' ? 'growth' : 'protection'} of 20-40%`,
                    confidence: trend.strength
                });
            });
        }

        return {
            timestamp: new Date(),
            scenarioType,
            currentState: analysis.stateScore,
            recommendations: recommendations.sort((a, b) => {
                const priorityOrder = { high: 3, medium: 2, low: 1 };
                return (priorityOrder[b.priority] || 0) - (priorityOrder[a.priority] || 0);
            }),
            overallConfidence: recommendations.reduce((sum, r) => sum + r.confidence, 0) / recommendations.length || 0
        };
    }

    async executeSimulation(scenario, model) {
        // Extract key variables from scenario description
        const variables = this.extractScenarioVariables(scenario.description);
        
        // Apply model predictions
        const basePrediction = await this.applyModel(model, variables, scenario.parameters);
        
        // Add uncertainty and noise
        const uncertainty = this.calculateUncertainty(variables, model);
        const finalPrediction = this.applyUncertainty(basePrediction, uncertainty);
        
        // Determine trend direction and confidence
        const trend = this.determineTrend(finalPrediction);
        const confidence = Math.max(0.1, Math.min(0.95, basePrediction.confidence * (1 - uncertainty)));
        
        return {
            trend,
            confidence,
            prediction: finalPrediction,
            factors: variables,
            modelUsed: model.type,
            uncertainty,
            details: {
                riskScore: finalPrediction.risk || 0.3,
                opportunityScore: finalPrediction.opportunity || 0.4,
                timeHorizon: scenario.parameters.timeHorizon || '3-6 months',
                keyDrivers: finalPrediction.keyDrivers || ['market_conditions', 'resource_availability'],
                alternativeOutcomes: this.generateAlternatives(finalPrediction)
            }
        };
    }

    classifyScenario(description) {
        const desc = description.toLowerCase();
        
        if (desc.includes('market') || desc.includes('sales') || desc.includes('revenue')) {
            return 'market';
        }
        if (desc.includes('risk') || desc.includes('threat') || desc.includes('security')) {
            return 'risk';
        }
        if (desc.includes('user') || desc.includes('customer') || desc.includes('engagement')) {
            return 'behavioral';
        }
        if (desc.includes('resource') || desc.includes('capacity') || desc.includes('performance')) {
            return 'operational';
        }
        if (desc.includes('trend') || desc.includes('future') || desc.includes('forecast')) {
            return 'predictive';
        }
        
        return 'general';
    }

    extractScenarioVariables(description) {
        const variables = {
            timeFrame: this.extractTimeFrame(description),
            domain: this.classifyScenario(description),
            complexity: this.assessComplexity(description),
            stakeholders: this.identifyStakeholders(description),
            resources: this.identifyResources(description)
        };
        
        return variables;
    }

    extractTimeFrame(description) {
        const timePatterns = [
            { pattern: /(\d+)\s*(day|week|month|year)s?/i, multiplier: { day: 1, week: 7, month: 30, year: 365 } },
            { pattern: /short.?term/i, value: 30 },
            { pattern: /medium.?term/i, value: 90 },
            { pattern: /long.?term/i, value: 365 },
            { pattern: /immediate/i, value: 7 },
            { pattern: /quarter/i, value: 90 }
        ];

        for (const { pattern, multiplier, value } of timePatterns) {
            const match = description.match(pattern);
            if (match) {
                if (multiplier && match[2]) {
                    return parseInt(match[1]) * multiplier[match[2].toLowerCase()];
                }
                if (value) return value;
            }
        }
        
        return 60; // Default: 2 months
    }

    assessComplexity(description) {
        let complexity = 0.3; // Base complexity
        
        const complexityIndicators = [
            'multiple', 'various', 'complex', 'intricate', 'sophisticated',
            'interdependent', 'cascading', 'systemic', 'comprehensive'
        ];
        
        complexityIndicators.forEach(indicator => {
            if (description.toLowerCase().includes(indicator)) {
                complexity += 0.1;
            }
        });
        
        return Math.min(1.0, complexity);
    }

    identifyStakeholders(description) {
        const stakeholderPatterns = [
            'customer', 'user', 'client', 'team', 'employee', 'manager',
            'investor', 'partner', 'supplier', 'competitor', 'regulator'
        ];
        
        return stakeholderPatterns.filter(pattern => 
            description.toLowerCase().includes(pattern)
        );
    }

    identifyResources(description) {
        const resourcePatterns = [
            'budget', 'time', 'staff', 'technology', 'data', 'infrastructure',
            'capital', 'expertise', 'tools', 'platform'
        ];
        
        return resourcePatterns.filter(pattern =>
            description.toLowerCase().includes(pattern)
        );
    }

    async applyModel(model, variables, parameters) {
        const baseScore = 0.5;
        let prediction = {
            score: baseScore,
            confidence: 0.7,
            risk: 0.3,
            opportunity: 0.4,
            keyDrivers: []
        };

        // Apply model-specific logic
        if (model.type === 'market') {
            prediction = this.applyMarketModel(prediction, variables, parameters);
        } else if (model.type === 'behavioral') {
            prediction = this.applyBehavioralModel(prediction, variables, parameters);
        } else if (model.type === 'risk') {
            prediction = this.applyRiskModel(prediction, variables, parameters);
        } else {
            prediction = this.applyGeneralModel(prediction, variables, parameters);
        }

        // Apply historical patterns from model
        if (model.patterns && model.patterns.length > 0) {
            const patternAdjustment = this.applyHistoricalPatterns(prediction, model.patterns, variables);
            prediction.score = (prediction.score + patternAdjustment.score) / 2;
            prediction.confidence *= patternAdjustment.confidenceMultiplier;
        }

        return prediction;
    }

    applyMarketModel(prediction, variables, parameters) {
        // Market-specific predictions
        if (variables.timeFrame < 30) {
            prediction.confidence *= 0.9; // Short-term market predictions are less certain
        }
        if (variables.stakeholders.includes('competitor')) {
            prediction.risk += 0.1;
        }
        if (variables.resources.includes('budget') || variables.resources.includes('capital')) {
            prediction.opportunity += 0.1;
        }
        
        prediction.keyDrivers = ['market_conditions', 'competition', 'economic_factors'];
        return prediction;
    }

    applyBehavioralModel(prediction, variables, parameters) {
        // User behavior predictions
        if (variables.stakeholders.includes('user') || variables.stakeholders.includes('customer')) {
            prediction.score += 0.1;
        }
        if (variables.complexity > 0.7) {
            prediction.confidence *= 0.8; // Complex behavioral scenarios are harder to predict
        }
        
        prediction.keyDrivers = ['user_preferences', 'engagement_patterns', 'adoption_rate'];
        return prediction;
    }

    applyRiskModel(prediction, variables, parameters) {
        // Risk assessment predictions
        prediction.risk += variables.complexity * 0.2;
        if (variables.timeFrame > 180) {
            prediction.risk += 0.1; // Longer timeframes increase uncertainty
        }
        
        prediction.keyDrivers = ['threat_likelihood', 'impact_severity', 'mitigation_effectiveness'];
        return prediction;
    }

    applyGeneralModel(prediction, variables, parameters) {
        // General-purpose predictions
        prediction.score += (variables.resources.length * 0.05);
        prediction.risk += (variables.complexity - 0.5) * 0.1;
        
        prediction.keyDrivers = ['resource_availability', 'execution_capability', 'external_factors'];
        return prediction;
    }

    applyHistoricalPatterns(prediction, patterns, variables) {
        let scoreAdjustment = 0;
        let confidenceMultiplier = 1;
        
        patterns.forEach(pattern => {
            const similarity = this.calculatePatternSimilarity(pattern.variables, variables);
            if (similarity > 0.5) {
                scoreAdjustment += (pattern.outcome - 0.5) * similarity * 0.2;
                confidenceMultiplier += similarity * 0.1;
            }
        });
        
        return {
            score: Math.max(0, Math.min(1, prediction.score + scoreAdjustment)),
            confidenceMultiplier: Math.min(1.2, confidenceMultiplier)
        };
    }

    calculatePatternSimilarity(patternVars, currentVars) {
        let similarity = 0;
        let comparisons = 0;
        
        // Compare domains
        if (patternVars.domain === currentVars.domain) {
            similarity += 0.3;
        }
        comparisons++;
        
        // Compare complexity
        const complexityDiff = Math.abs(patternVars.complexity - currentVars.complexity);
        similarity += Math.max(0, (1 - complexityDiff)) * 0.2;
        comparisons++;
        
        // Compare time frames
        const timeDiff = Math.abs(patternVars.timeFrame - currentVars.timeFrame) / Math.max(patternVars.timeFrame, currentVars.timeFrame);
        similarity += Math.max(0, (1 - timeDiff)) * 0.2;
        comparisons++;
        
        // Compare stakeholders
        const commonStakeholders = patternVars.stakeholders.filter(s => currentVars.stakeholders.includes(s));
        if (patternVars.stakeholders.length > 0 || currentVars.stakeholders.length > 0) {
            similarity += (commonStakeholders.length / Math.max(patternVars.stakeholders.length, currentVars.stakeholders.length)) * 0.3;
            comparisons++;
        }
        
        return comparisons > 0 ? similarity / comparisons : 0;
    }

    calculateUncertainty(variables, model) {
        let uncertainty = 0.1; // Base uncertainty
        
        // Time horizon affects uncertainty
        if (variables.timeFrame > 90) uncertainty += 0.1;
        if (variables.timeFrame > 365) uncertainty += 0.2;
        
        // Complexity affects uncertainty
        uncertainty += variables.complexity * 0.2;
        
        // Model confidence
        if (model.accuracy < 0.7) uncertainty += 0.1;
        
        // Stakeholder complexity
        if (variables.stakeholders.length > 3) uncertainty += 0.1;
        
        return Math.min(0.5, uncertainty);
    }

    applyUncertainty(prediction, uncertainty) {
        const noiseFactor = (Math.random() - 0.5) * uncertainty;
        
        return {
            ...prediction,
            score: Math.max(0.1, Math.min(0.9, prediction.score + noiseFactor)),
            confidence: Math.max(0.1, prediction.confidence - uncertainty / 2)
        };
    }

    determineTrend(prediction) {
        if (prediction.score > 0.6) {
            return prediction.score > 0.8 ? 'strong_positive' : 'positive';
        } else if (prediction.score < 0.4) {
            return prediction.score < 0.2 ? 'strong_negative' : 'negative';
        }
        return 'neutral';
    }

    generateAlternatives(prediction) {
        const alternatives = [];
        
        // Optimistic scenario
        alternatives.push({
            name: 'optimistic',
            probability: 0.2,
            outcome: Math.min(0.9, prediction.score + 0.2),
            description: 'Best-case scenario with favorable conditions'
        });
        
        // Pessimistic scenario
        alternatives.push({
            name: 'pessimistic',
            probability: 0.2,
            outcome: Math.max(0.1, prediction.score - 0.2),
            description: 'Worst-case scenario with adverse conditions'
        });
        
        // Most likely scenario
        alternatives.push({
            name: 'most_likely',
            probability: 0.6,
            outcome: prediction.score,
            description: 'Expected outcome based on current trends'
        });
        
        return alternatives;
    }

    async analyzeCurrentState(currentState, model) {
        const stateScore = this.calculateStateScore(currentState);
        const risk = this.assessRisk(currentState, model);
        const opportunities = await this.identifyOpportunities(currentState, model);
        const trends = await this.identifyTrends(currentState, model);
        
        return {
            stateScore,
            risk,
            opportunities,
            trends,
            confidence: Math.min(0.9, model.accuracy || 0.6)
        };
    }

    calculateStateScore(state) {
        if (typeof state === 'number') return Math.max(0, Math.min(1, state));
        
        if (typeof state === 'object' && state !== null) {
            const metrics = Object.values(state).filter(v => typeof v === 'number');
            return metrics.length > 0 ? metrics.reduce((sum, v) => sum + v, 0) / metrics.length : 0.5;
        }
        
        return 0.5; // Default neutral score
    }

    assessRisk(currentState, model) {
        let risk = 0.3; // Base risk
        
        if (model.type === 'risk') {
            risk = 0.5; // Higher base risk for risk-focused models
        }
        
        // Analyze state for risk indicators
        if (typeof currentState === 'object' && currentState !== null) {
            if (currentState.volatility > 0.7) risk += 0.2;
            if (currentState.uncertainty > 0.6) risk += 0.1;
            if (currentState.externalThreats > 0.5) risk += 0.15;
        }
        
        return Math.min(0.9, risk);
    }

    async identifyOpportunities(currentState, model) {
        const opportunities = [];
        
        // Generic opportunity identification
        if (typeof currentState === 'object' && currentState !== null) {
            if (currentState.growth > 0.6) {
                opportunities.push({
                    description: 'Leverage current growth momentum',
                    priority: 'high',
                    expectedImpact: 'Significant positive impact on outcomes',
                    confidence: 0.7
                });
            }
            
            if (currentState.efficiency < 0.5 && currentState.resources > 0.6) {
                opportunities.push({
                    description: 'Optimize resource utilization',
                    priority: 'medium',
                    expectedImpact: 'Improve efficiency by 20-30%',
                    confidence: 0.6
                });
            }
            
            if (currentState.marketPosition > 0.7) {
                opportunities.push({
                    description: 'Expand market presence',
                    priority: 'medium',
                    expectedImpact: 'Potential market share increase',
                    confidence: 0.5
                });
            }
        }
        
        return opportunities;
    }

    async identifyTrends(currentState, model) {
        const trends = [];
        
        // Analyze historical patterns to identify trends
        if (this.historicalData.length > 0) {
            const recentData = this.historicalData.slice(-10);
            
            // Simple trend analysis
            if (recentData.length >= 3) {
                const values = recentData.map(d => d.value || 0.5);
                const isIncreasing = values.slice(-3).every((val, i, arr) => i === 0 || val >= arr[i - 1]);
                const isDecreasing = values.slice(-3).every((val, i, arr) => i === 0 || val <= arr[i - 1]);
                
                if (isIncreasing) {
                    trends.push({
                        area: 'performance',
                        direction: 'positive',
                        strength: 0.7,
                        description: 'Consistent upward trend detected'
                    });
                } else if (isDecreasing) {
                    trends.push({
                        area: 'performance',
                        direction: 'negative',
                        strength: 0.6,
                        description: 'Declining trend detected'
                    });
                }
            }
        }
        
        return trends;
    }

    initializeModels() {
        const modelTypes = ['general', 'market', 'behavioral', 'risk', 'operational', 'predictive'];
        
        modelTypes.forEach(type => {
            this.models.set(type, {
                type,
                accuracy: 0.6 + Math.random() * 0.2, // 60-80% base accuracy
                patterns: [],
                weights: this.initializeWeights(),
                lastTrained: new Date(),
                dataPoints: 0
            });
        });
    }

    initializeWeights() {
        return {
            timeWeight: 0.2,
            complexityWeight: 0.3,
            stakeholderWeight: 0.2,
            resourceWeight: 0.2,
            historyWeight: 0.1
        };
    }

    createNewModel(modelType) {
        const model = {
            type: modelType,
            accuracy: 0.5,
            patterns: [],
            weights: this.initializeWeights(),
            lastTrained: new Date(),
            dataPoints: 0
        };
        
        this.models.set(modelType, model);
        return model;
    }

    preprocessTrainingData(data, modelType) {
        return data.map(item => ({
            variables: this.extractScenarioVariables(item.description || ''),
            outcome: item.outcome || 0.5,
            timestamp: new Date(item.timestamp || Date.now())
        }));
    }

    async updateModelWeights(model, processedData) {
        if (processedData.length === 0) return;
        
        // Simple weight adjustment based on outcomes
        const avgOutcome = processedData.reduce((sum, item) => sum + item.outcome, 0) / processedData.length;
        
        if (avgOutcome > 0.6) {
            model.weights.resourceWeight += 0.05;
            model.weights.stakeholderWeight += 0.05;
        } else if (avgOutcome < 0.4) {
            model.weights.complexityWeight += 0.05;
            model.weights.timeWeight += 0.05;
        }
        
        // Normalize weights
        const totalWeight = Object.values(model.weights).reduce((sum, w) => sum + w, 0);
        Object.keys(model.weights).forEach(key => {
            model.weights[key] /= totalWeight;
        });
        
        // Store patterns
        model.patterns = processedData;
    }

    async validateModel(model, data) {
        if (data.length < 2) {
            return { accuracy: 0.5, testSamples: data.length };
        }
        
        // Simple validation: use 70% for training, 30% for testing
        const testSize = Math.max(1, Math.floor(data.length * 0.3));
        const testData = data.slice(-testSize);
        
        let correctPredictions = 0;
        
        for (const testItem of testData) {
            const prediction = await this.applyModel(model, testItem.variables, {});
            const predicted = prediction.score > 0.5 ? 1 : 0;
            const actual = testItem.outcome > 0.5 ? 1 : 0;
            
            if (predicted === actual) {
                correctPredictions++;
            }
        }
        
        const accuracy = correctPredictions / testData.length;
        return { accuracy, testSamples: testData.length };
    }

    async loadSimulations() {
        try {
            await fs.mkdir(path.dirname(this.simulationPath), { recursive: true });
            const data = await fs.readFile(this.simulationPath, 'utf8');
            const parsed = JSON.parse(data);
            
            if (parsed.scenarios) {
                parsed.scenarios.forEach(scenario => {
                    scenario.timestamp = new Date(scenario.timestamp);
                    if (scenario.completedAt) scenario.completedAt = new Date(scenario.completedAt);
                    this.scenarios.set(scenario.id, scenario);
                });
            }
            
            if (parsed.models) {
                parsed.models.forEach(([type, model]) => {
                    model.lastTrained = new Date(model.lastTrained);
                    if (model.patterns) {
                        model.patterns.forEach(pattern => {
                            pattern.timestamp = new Date(pattern.timestamp);
                        });
                    }
                    this.models.set(type, model);
                });
            }
            
            if (parsed.historicalData) {
                this.historicalData = parsed.historicalData.map(item => ({
                    ...item,
                    timestamp: new Date(item.timestamp)
                }));
            }
            
            logger.info(`Loaded ${this.scenarios.size} scenarios and ${this.models.size} models`);
        } catch (error) {
            logger.debug('No existing simulation file found, starting fresh');
        }
    }

    async saveSimulations() {
        try {
            const data = {
                scenarios: Array.from(this.scenarios.values()),
                models: Array.from(this.models.entries()),
                historicalData: this.historicalData,
                savedAt: new Date().toISOString()
            };
            await fs.writeFile(this.simulationPath, JSON.stringify(data, null, 2));
        } catch (error) {
            logger.error('Failed to save simulations', { error });
        }
    }
}