bulltrackers-module 1.0.732 → 1.0.733

package/functions/computation-system/layers/profiling.js

@@ -1,537 +0,0 @@
-/**
- * @fileoverview Profiling Layer - Intelligence Engine (V6)
- * Encapsulates advanced behavioral profiling, psychological scoring, and classification schemas.
- * UPDATED: Added AnomalyDetector, SimilarityEngine, and ContentAnalysis.
- */
-
-const SCHEMAS = {
-    USER_TYPES: { NORMAL: 'normal', SPECULATOR: 'speculator', SIGNED_IN: 'SIGNED_IN_USER', POPULAR: 'POPULAR_INVESTOR' },
-    STYLES: { 
-        INVESTOR: 'Investor', 
-        SWING_TRADER: 'Swing Trader', 
-        DAY_TRADER: 'Day Trader', 
-        SCALPER: 'Scalper' 
-    },
-    LABELS: { 
-        ELITE: 'Elite', 
-        SMART: 'Smart Money', 
-        NEUTRAL: 'Neutral', 
-        DUMB: 'Dumb Money', 
-        GAMBLER: 'Gambler' 
-    }
-};
-
-class AnomalyDetector {
-    /**
-     * Detects unusual behavior by comparing current portfolio state to historical averages (30D).
-     * @param {Array} historyTrades - Full trade history
-     * @param {Array} currentPositions - Current portfolio positions
-     * @param {Object} mappings - Sector mappings
-     * @returns {Object} { anomalies: [], warnings: [] }
-     */
-    static detect(historyTrades, currentPositions, mappings) {
-        const anomalies = [];
-        const warnings = [];
-        
-        if (!historyTrades || historyTrades.length < 10) return { anomalies, warnings };
-        
-        // 1. Calculate Historical Baselines (last 30 days vs older)
-        const now = new Date();
-        const thirtyDaysAgo = new Date(now.getTime() - (30 * 86400000));
-        
-        const recentTrades = historyTrades.filter(t => new Date(t.OpenDateTime) > thirtyDaysAgo);
-        const allLeverage = historyTrades.map(t => t.Leverage || 1);
-        const avgLeverage = allLeverage.reduce((a,b) => a+b, 0) / allLeverage.length;
-        
-        // 2. Check for Leverage Anomalies in Current Positions
-        for (const pos of currentPositions) {
-            const currentLev = pos.Leverage || 1;
-            if (currentLev > avgLeverage * 1.5 && currentLev > 2) {
-                warnings.push(`High Leverage Alert: Position ${pos.InstrumentID} has ${currentLev}x leverage (Avg: ${avgLeverage.toFixed(1)}x)`);
-            }
-        }
-
-        // 3. Check for New Sector Exposure
-        const historicalSectors = new Set();
-        historyTrades.forEach(t => {
-            const sector = mappings.instrumentToSector[t.InstrumentID];
-            if (sector) historicalSectors.add(sector);
-        });
-        
-        for (const pos of currentPositions) {
-            const sector = mappings.instrumentToSector[pos.InstrumentID];
-            if (sector && !historicalSectors.has(sector)) {
-                anomalies.push(`New Sector Entry: User entered ${sector} sector for the first time.`);
-                historicalSectors.add(sector); // suppress duplicate alerts
-            }
-        }
-        
-        return { anomalies, warnings };
-    }
-}
-
-class SimilarityEngine {
-    /**
-     * Finds similar investors based on portfolio composition and risk profile.
-     * @param {Object} targetUserContext - The user to match
-     * @param {Array<Object>} candidateContexts - List of other users to compare against
-     * @param {number} limit - Max results
-     */
-    static findPeers(targetUserContext, candidateContexts, limit = 5) {
-        const targetVector = this._buildFeatureVector(targetUserContext);
-        const scores = [];
-
-        for (const candidate of candidateContexts) {
-            // Skip self
-            if (candidate.user.id === targetUserContext.user.id) continue;
-            
-            const candidateVector = this._buildFeatureVector(candidate);
-            const similarity = this._cosineSimilarity(targetVector, candidateVector);
-            
-            scores.push({ 
-                userId: candidate.user.id, 
-                score: similarity,
-                matches: this._explainMatch(targetVector, candidateVector)
-            });
-        }
-        
-        return scores.sort((a,b) => b.score - a.score).slice(0, limit);
-    }
-
-    static _buildFeatureVector(ctx) {
-        // Simplified feature extraction
-        const portfolio = ctx.user.portfolio.today;
-        const positions = portfolio.AggregatedPositions || portfolio.PublicPositions || [];
-        
-        // 1. Sector Weights
-        const sectorMap = {};
-        let totalVal = 0;
-        positions.forEach(p => {
-            // Assume mappings are available in ctx or extracted beforehand
-            // For this snippet, we use InstrumentID as a proxy for asset overlap if sector missing
-            const val = p.Value || 0;
-            totalVal += val;
-            sectorMap[p.InstrumentID] = (sectorMap[p.InstrumentID] || 0) + val;
-        });
-
-        // Normalize
-        const vector = {};
-        if (totalVal > 0) {
-            Object.keys(sectorMap).forEach(k => vector[k] = sectorMap[k] / totalVal);
-        }
-        return vector;
-    }
-
-    static _cosineSimilarity(vecA, vecB) {
-        const keys = new Set([...Object.keys(vecA), ...Object.keys(vecB)]);
-        let dot = 0, magA = 0, magB = 0;
-        keys.forEach(k => {
-            const valA = vecA[k] || 0;
-            const valB = vecB[k] || 0;
-            dot += valA * valB;
-            magA += valA * valA;
-            magB += valB * valB;
-        });
-        if (magA === 0 || magB === 0) return 0;
-        return dot / (Math.sqrt(magA) * Math.sqrt(magB));
-    }
-
-    static _explainMatch(vecA, vecB) {
-        // Find top overlapping keys
-        const overlaps = [];
-        Object.keys(vecA).forEach(k => {
-            if (vecB[k]) overlaps.push(k);
-        });
-        return overlaps.slice(0, 3); // Top 3 common instruments
-    }
-}
-
-class SmartMoneyScorer {
-    static _correlation(x, y) {
-        if (!x || !y || x.length !== y.length || x.length < 2) return 0;
-        const n = x.length;
-        let sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0, sumY2 = 0;
-        for (let i = 0; i < n; i++) {
-            sumX += x[i]; sumY += y[i];
-            sumXY += x[i] * y[i];
-            sumX2 += x[i] * x[i]; sumY2 += y[i] * y[i];
-        }
-        const numerator = (n * sumXY) - (sumX * sumY);
-        const denominator = Math.sqrt(((n * sumX2) - (sumX * sumX)) * ((n * sumY2) - (sumY * sumY)));
-        return (denominator === 0) ? 0 : numerator / denominator;
-    }
-
-    static scorePortfolio(portfolio, userType, prices, mappings, math) {
-        const positions = math.extract.getPositions(portfolio, userType);
-        if (!positions || positions.length === 0) return { score: 0, label: SCHEMAS.LABELS.NEUTRAL };
-
-        let totalInvested = 0;
-        let weightedPnL = 0;
-        let shortInvested = 0;
-        let shortPnL = 0;
-        
-        const weights = [];
-        const pnls = [];
-        const sectors = new Set();
-        const tickers = new Set();
-
-        for (const pos of positions) {
-            const invested = math.extract.getPositionWeight(pos, userType);
-            const pnl = math.extract.getNetProfit(pos); 
-            const instId = math.extract.getInstrumentId(pos);
-            const isShort = math.extract.getDirection(pos) === 'Sell';
-            
-            const sector = mappings.instrumentToSector[instId];
-            const ticker = mappings.instrumentToTicker[instId];
-
-            if (invested > 0) {
-                totalInvested += invested;
-                weightedPnL += (pnl * invested);
-                weights.push(invested);
-                pnls.push(pnl);
-                
-                if (sector) sectors.add(sector);
-                if (ticker) tickers.add(ticker);
-
-                if (isShort) {
-                    shortInvested += invested;
-                    shortPnL += (pnl * invested);
-                }
-            }
-        }
-
-        if (totalInvested === 0) return { score: 0, label: SCHEMAS.LABELS.NEUTRAL };
-
-        const avgPnL = weightedPnL / totalInvested;
-        const allocEfficiency = this._correlation(weights, pnls);
-
-        let hhi = 0;
-        for (const w of weights) {
-            const share = w / totalInvested;
-            hhi += (share * share);
-        }
-        
-        const shortRatio = shortInvested / totalInvested;
-        const avgShortPnL = shortInvested > 0 ? shortPnL / shortInvested : 0;
-
-        let score = 50; 
-
-        if (allocEfficiency > 0.5) score += 20;
-        else if (allocEfficiency < -0.3) score -= 15;
-
-        if (avgPnL > 5) score += 10;
-        if (avgPnL > 20) score += 10;
-        if (avgPnL < -10) score -= 10;
-        if (avgPnL < -25) score -= 15;
-
-        if (hhi > 0.3) {
-            if (avgPnL > 5) score += 10; 
-            else if (avgPnL < -5) score -= 10; 
-        }
-
-        if (sectors.size >= 4) score += 5;
-
-        if (shortRatio > 0.1) {
-            if (avgShortPnL > 0) score += 10; 
-            else score -= 10; 
-        }
-
-        return {
-            score: Math.max(0, Math.min(100, score)),
-            metrics: { allocEfficiency, hhi, avgPnL, shortRatio, sectorCount: sectors.size }
-        };
-    }
-
-    static scoreHistory(historyDoc, prices, mappings, math) {
-        const trades = historyDoc?.PublicHistoryPositions || [];
-        
-        if (trades.length < 5) return { score: 0, label: SCHEMAS.LABELS.NEUTRAL };
-        const validTrades = trades.filter(t => t.OpenDateTime && t.CloseDateTime && t.InstrumentID);
-        if (validTrades.length < 5) return { score: 0, label: SCHEMAS.LABELS.NEUTRAL };
-
-        let wins = 0, losses = 0;
-        let totalWinPct = 0, totalLossPct = 0;
-        let entryScores = [];
-        const assetsTraded = new Map(); 
-
-        validTrades.sort((a, b) => new Date(a.OpenDateTime) - new Date(b.OpenDateTime));
-        const firstDate = new Date(validTrades[0].OpenDateTime);
-        const lastDate = new Date(validTrades[validTrades.length-1].OpenDateTime);
-        const daysActive = Math.max(1, (lastDate - firstDate) / 86400000);
-
-        for (const t of validTrades) {
-            const ticker = mappings.instrumentToTicker[t.InstrumentID];
-            
-            if (!assetsTraded.has(t.InstrumentID)) assetsTraded.set(t.InstrumentID, { count: 0, pnl: 0 });
-            const assetStat = assetsTraded.get(t.InstrumentID);
-            assetStat.count++;
-            assetStat.pnl += t.NetProfit;
-
-            if (t.NetProfit > 0) { wins++; totalWinPct += t.NetProfit; }
-            else { losses++; totalLossPct += Math.abs(t.NetProfit); }
-
-            if (ticker && prices) {
-                const priceHist = math.priceExtractor.getHistory(prices, ticker);
-                if (priceHist && priceHist.length > 0) {
-                    const eff = ExecutionAnalytics.calculateEfficiency(t.OpenRate, priceHist, t.OpenDateTime, t.IsBuy ? 'Buy' : 'Sell');
-                    entryScores.push(eff);
-                }
-            }
-        }
-
-        const avgWin = wins > 0 ? totalWinPct / wins : 0;
-        const avgLoss = losses > 0 ? totalLossPct / losses : 1;
-        const profitFactor = (wins * avgWin) / Math.max(1, (losses * avgLoss));
-        
-        const avgEntrySkill = entryScores.length > 0 ? math.compute.average(entryScores) : 0.5;
-
-        const totalTrades = validTrades.length;
-        const uniqueAssets = assetsTraded.size;
-        const specializationRatio = 1 - (uniqueAssets / totalTrades);
-
-        const tradesPerDay = totalTrades / daysActive;
-
-        let revengeScore = 0;
-        for (const [id, stat] of assetsTraded.entries()) {
-            if (stat.pnl < -20 && stat.count > 5) revengeScore += 1;
-        }
-
-        let score = 50;
-
-        if (profitFactor > 1.2) score += 10;
-        if (profitFactor > 2.0) score += 15;
-        if (profitFactor < 0.8) score -= 15;
-
-        if (avgEntrySkill > 0.7) score += 10; 
-        if (avgEntrySkill < 0.3) score -= 10; 
-
-        if (specializationRatio > 0.6) score += 5; 
-        if (specializationRatio < 0.1 && totalTrades > 20) score -= 5; 
-
-        if (tradesPerDay > 10 && profitFactor < 1.0) score -= 10; 
-
-        if (revengeScore > 0) score -= (revengeScore * 5);
-
-        return {
-            score: Math.max(0, Math.min(100, score)),
-            metrics: { profitFactor, avgEntrySkill, specializationRatio, tradesPerDay, revengeScore }
-        };
-    }
-
-    static scoreHybrid(context) {
-        const { user, prices, mappings, math } = context;
-        
-        const pScore = this.scorePortfolio(user.portfolio.today, user.type, prices, mappings, math);
-        const hScore = this.scoreHistory(user.history.today, prices, mappings, math);
-
-        let finalScore = 50;
-        let method = 'Neutral';
-
-        const hasHistory = hScore && hScore.score > 0;
-        const hasPortfolio = pScore && pScore.score > 0;
-
-        if (hasHistory && hasPortfolio) {
-            finalScore = (hScore.score * 0.6) + (pScore.score * 0.4);
-            method = 'Hybrid';
-        } else if (hasHistory) {
-            finalScore = hScore.score;
-            method = 'HistoryOnly';
-        } else if (hasPortfolio) {
-            finalScore = pScore.score;
-            method = 'PortfolioOnly';
-        }
-
-        let label = SCHEMAS.LABELS.NEUTRAL;
-        if (finalScore >= 80) label = SCHEMAS.LABELS.ELITE;
-        else if (finalScore >= 65) label = SCHEMAS.LABELS.SMART;
-        else if (finalScore <= 35) label = SCHEMAS.LABELS.GAMBLER;
-        else if (finalScore <= 50) label = SCHEMAS.LABELS.DUMB;
-
-        return {
-            totalScore: Math.round(finalScore),
-            label: label,
-            method: method,
-            components: {
-                portfolio: pScore,
-                history: hScore
-            }
-        };
-    }
-}
-
-class CognitiveBiases {
-    static calculateAnchoringScore(openPositions, thresholdPct = 2.0, minDaysHeld = 14) {
-        if (!openPositions || openPositions.length === 0) return 0;
-        let anchoredCount = 0, validPositions = 0;
-        const now = Date.now(), msPerDay = 86400000;
-        for (const pos of openPositions) {
-            if (pos.OpenDateTime) {
-                validPositions++;
-                const ageDays = (now - new Date(pos.OpenDateTime).getTime()) / msPerDay;
-                if (ageDays > minDaysHeld && Math.abs(pos.NetProfit) < thresholdPct) { anchoredCount++; }
-            }
-        }
-        return validPositions > 0 ? (anchoredCount / validPositions) : 0;
-    }
-
-    static calculateDispositionEffect(historyTrades) {
-        let winDur = 0, winCount = 0, lossDur = 0, lossCount = 0;
-        for (const t of historyTrades) {
-            if (!t.OpenDateTime || !t.CloseDateTime) continue;
-            const dur = (new Date(t.CloseDateTime) - new Date(t.OpenDateTime)) / 3600000; 
-            if (t.NetProfit > 0) { winDur += dur; winCount++; } else if (t.NetProfit < 0) { lossDur += dur; lossCount++; }
-        }
-        const avgWinHold = winCount > 0 ? winDur / winCount : 0;
-        const avgLossHold = lossCount > 0 ? lossDur / lossCount : 0;
-        if (avgWinHold === 0) return 2.0; 
-        return avgLossHold / avgWinHold;
-    }
-}
-
-class SkillAttribution {
-    static calculateSelectionAlpha(userPositions, dailyInsights) {
-        let totalAlpha = 0, count = 0;
-        for (const pos of userPositions) {
-            const instrumentId = pos.InstrumentID;
-            let insight = Array.isArray(dailyInsights) ? dailyInsights.find(i => i.instrumentId === instrumentId) : null;
-            if (insight && typeof insight.growth === 'number') {
-                totalAlpha += (pos.NetProfit - insight.growth);
-                count++;
-            }
-        }
-        return count > 0 ? totalAlpha / count : 0;
-    }
-}
-
-class ExecutionAnalytics {
-    static calculateEfficiency(price, priceHistory, date, direction, windowDays = 7) {
-        if (!priceHistory || priceHistory.length === 0) return 0.5;
-        const targetDate = new Date(date);
-        const start = new Date(targetDate); start.setDate(start.getDate() - windowDays);
-        const end = new Date(targetDate); end.setDate(end.getDate() + windowDays);
-        const pricesInWindow = priceHistory.filter(p => { const d = new Date(p.date); return d >= start && d <= end; }).map(p => p.price);
-        if (pricesInWindow.length === 0) return 0.5;
-        const minP = Math.min(...pricesInWindow);
-        const maxP = Math.max(...pricesInWindow);
-        const range = maxP - minP;
-        if (range === 0) return 0.5;
-        const location = (price - minP) / range;
-        if (direction === 'Buy') { return 1 - location; } else { return location; }
-    }
-    static calculateLossTolerance(realizedPnL, maxDrawdown) {
-        if (maxDrawdown === 0) return 1; 
-        return (realizedPnL - maxDrawdown) / Math.abs(maxDrawdown);
-    }
-}
-
-/**
- * UPGRADE: Risk Geometry Class
- * Contains Convex Hull (Monotone Chain) for Efficient Frontier analysis.
- */
-class RiskGeometry {
-    static crossProduct(o, a, b) {
-        return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
-    }
-
-    /**
-     * Computes the Convex Hull of a set of 2D points using Monotone Chain algorithm.
-     * @param {Array<{x: number, y: number}>} points
-     * @returns {Array<{x: number, y: number}>} Points on the hull
-     */
-    static computeConvexHull(points) {
-        if (points.length <= 1) return points;
-        
-        // Sort by x coordinate (and y if x is same)
-        points.sort((a, b) => a.x === b.x ? a.y - b.y : a.x - b.x);
-
-        const lower = [];
-        for (const p of points) {
-            while (lower.length >= 2 && this.crossProduct(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) {
-                lower.pop();
-            }
-            lower.push(p);
-        }
-
-        const upper = [];
-        for (let i = points.length - 1; i >= 0; i--) {
-            const p = points[i];
-            while (upper.length >= 2 && this.crossProduct(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) {
-                upper.pop();
-            }
-            upper.push(p);
-        }
-
-        upper.pop();
-        lower.pop();
-        return lower.concat(upper);
-    }
-}
-
-class Psychometrics {
-    static computeDispositionSkew(historyTrades, currentPositions) {
-        const getMedian = (arr) => { if (!arr.length) return 0; const sorted = [...arr].sort((a, b) => a - b); const mid = Math.floor(sorted.length / 2); return sorted.length % 2 !== 0 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2; };
-        const realized = historyTrades.map(t => t.NetProfit);
-        const unrealized = currentPositions.map(p => p.NetProfit);
-        if (realized.length < 5 || unrealized.length < 5) return 0;
-        return getMedian(realized) - getMedian(unrealized);
-    }
-    static detectRevengeTrading(historyTrades) {
-        let riskSpikes = 0; let losses = 0; if (historyTrades.length === 0) return 0;
-        const avgLev = historyTrades.reduce((sum, t) => sum + (t.Leverage || 1), 0) / historyTrades.length;
-        for (let i = 1; i < historyTrades.length; i++) {
-            const prev = historyTrades[i-1]; const curr = historyTrades[i];
-            if (prev.NetProfit < 0) { losses++; if ((curr.Leverage || 1) > (avgLev * 1.5)) { riskSpikes++; } }
-        }
-        return losses > 0 ? (riskSpikes / losses) : 0;
-    }
-}
-
-class AdaptiveAnalytics {
-    static analyzeDrawdownAdaptation(tradeHistory, drawdownThreshold = -15) {
-        let adaptationScore = 0; let eventCount = 0;
-        for (let i = 0; i < tradeHistory.length - 3; i++) {
-            if (tradeHistory[i].NetProfit < drawdownThreshold) {
-                eventCount++; const nextTrades = tradeHistory.slice(i+1, i+4);
-                const prevLev = tradeHistory[i].Leverage || 1;
-                const nextLevAvg = nextTrades.reduce((s, t) => s + (t.Leverage||1), 0) / 3;
-                if (nextLevAvg < prevLev) adaptationScore += 1; else if (nextLevAvg > prevLev * 1.5) adaptationScore -= 2; 
-                const lostInstrument = tradeHistory[i].InstrumentID;
-                const stuckToSame = nextTrades.every(t => t.InstrumentID === lostInstrument);
-                if (!stuckToSame) adaptationScore += 0.5; 
-            }
-        }
-        return eventCount > 0 ? (adaptationScore / eventCount) : 0;
-    }
-}
-
-class UserClassifier {
-    static classify(context) {
-        const result = SmartMoneyScorer.scoreHybrid(context);
-        return {
-            intelligence: { 
-                label: result.label, 
-                score: result.totalScore, 
-                isSmart: result.totalScore >= 65 
-            },
-            style: { primary: SCHEMAS.STYLES.INVESTOR }, 
-            metrics: {
-                profitFactor: result.components.history?.metrics?.profitFactor || 0,
-                allocEfficiency: result.components.portfolio?.metrics?.allocEfficiency || 0
-            }
-        };
-    }
-}
-
-module.exports = { 
-    SCHEMAS, 
-    UserClassifier,
-    SmartMoneyScorer, 
-    ExecutionAnalytics,
-    Psychometrics,
-    AdaptiveAnalytics,
-    CognitiveBiases,
-    SkillAttribution,
-    RiskGeometry,
-    AnomalyDetector,
-    SimilarityEngine
-};