aiden-shared-calculations-unified 1.0.86 → 1.0.88

package/calculations/capitulation/asset-volatility-estimator.js

@@ -0,0 +1,96 @@
+/**
+ * @fileoverview CORE Product Line (Pass 1 - Meta)
+ * Calculates annualized volatility using the new priceExtractor.
+ */
+class AssetVolatilityEstimator {
+    constructor() {
+        this.result = {};
+    }
+
+    static getMetadata() {
+        return {
+            type: 'meta',
+            rootDataDependencies: ['price'], 
+            isHistorical: false,
+            userType: 'n/a',
+            category: 'market_stats'
+        };
+    }
+
+    static getDependencies() { return []; }
+
+    static getSchema() {
+        const tickerSchema = {
+            "type": "object",
+            "properties": {
+                "volatility_30d": { "type": "number" },
+                "last_price": { "type": "number" },
+                "data_points": { "type": "number" }
+            },
+            "required": ["volatility_30d"]
+        };
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
+    }
+
+    process(context) {
+        // FIXED: Destructure 'mappings' to resolve real tickers
+        const { math, prices, mappings } = context; 
+        
+        // FIXED: Destructure 'priceExtractor' directly (matches worker.js injection)
+        const { compute, priceExtractor } = math; 
+
+        // 1. Get ALL histories properly sorted and parsed
+        const allHistories = priceExtractor.getAllHistories(prices);
+
+        for (const [key, candles] of allHistories.entries()) {
+            // RESOLUTION FIX: 
+            // 'key' is likely an index string ("0") because mock data is an array.
+            // We must resolve this to the real Ticker Symbol for the result map.
+            let ticker = key;
+
+            if (prices.history && prices.history[key] && prices.history[key].instrumentId) {
+                const instId = prices.history[key].instrumentId;
+                if (mappings && mappings.instrumentToTicker && mappings.instrumentToTicker[instId]) {
+                    ticker = mappings.instrumentToTicker[instId];
+                }
+            }
+
+            if (candles.length < 10) continue;
+
+            // 2. Calculate Log Returns
+            const logReturns = [];
+            let lastPrice = 0;
+
+            for (let i = 1; i < candles.length; i++) {
+                const prev = candles[i-1].price;
+                const curr = candles[i].price;
+                
+                if (prev > 0 && curr > 0) {
+                    logReturns.push(Math.log(curr / prev));
+                    lastPrice = curr;
+                }
+            }
+
+            // 3. Filter 30-Day Lookback
+            const LOOKBACK = 30;
+            const relevantReturns = logReturns.slice(-LOOKBACK);
+
+            if (relevantReturns.length < 5) continue;
+
+            // 4. Calculate Stats
+            const stdDev = compute.standardDeviation(relevantReturns);
+            const annualizedVol = stdDev * Math.sqrt(365);
+
+            this.result[ticker] = {
+                volatility_30d: annualizedVol,
+                last_price: lastPrice,
+                data_points: relevantReturns.length
+            };
+        }
+    }
+
+    async getResult() { return this.result; }
+    reset() { this.result = {}; }
+}
+
+module.exports = AssetVolatilityEstimator;

package/calculations/capitulation/retail-capitulation-risk-forecast.js

@@ -0,0 +1,173 @@
+/**
+ * @fileoverview CORE Product Line (Pass 2 - Standard)
+ * Calculates capitulation risk using DYNAMIC volatility from asset-volatility-estimator.
+ * Relies on 'schema.md' definitions for portfolio extraction via MathPrimitives.
+ */
+
+class RetailCapitulationRiskForecast {
+    constructor() {
+        this.assetRiskProfiles = new Map();
+        this.tickerMap = null;
+        
+        // FIX: Use a container object (like the Maps in other calculations)
+        // This allows us to MUTATE 'deps.mathLib' instead of RE-ASSIGNING 'this.mathLib'
+        this.deps = { mathLib: null };
+    }
+
+    static getMetadata() {
+        return {
+            type: 'standard',
+            rootDataDependencies: ['portfolio', 'history'],
+            isHistorical: false,
+            userType: 'all',
+            category: 'risk_models'
+        };
+    }
+
+    static getDependencies() {
+        return ['asset-volatility-estimator']; 
+    }
+
+    static getSchema() {
+        const tickerSchema = {
+            "type": "object",
+            "properties": {
+                "capitulation_probability": { "type": "number" },
+                "at_risk_user_count": { "type": "number" },
+                "average_pain_threshold_pct": { "type": "number" },
+                "used_volatility": { "type": "number" }
+            },
+            "required": ["capitulation_probability", "at_risk_user_count"]
+        };
+        
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
+    }
+
+    _initAsset(ticker, currentPrice, volatility) {
+        if (!this.assetRiskProfiles.has(ticker)) {
+            this.assetRiskProfiles.set(ticker, {
+                currentPrice: currentPrice,
+                volatility: volatility, 
+                profiles: []
+            });
+        }
+    }
+
+    process(context) {
+        const { user, mappings, math, computed } = context;
+        const { extract, history, compute, signals } = math;
+
+        // 1. Capture Libraries via MUTATION
+        // We are retrieving the 'deps' object (GET) and mutating its property.
+        // This bypasses the Proxy SET trap entirely.
+        if (!this.deps.mathLib && compute) {
+            this.deps.mathLib = compute;
+        }
+        
+        if (!this.tickerMap) {
+            this.tickerMap = mappings.instrumentToTicker;
+        }
+
+        // 2. Determine User's "Pain Threshold"
+        const historyDoc = history.getDailyHistory(user);
+        const summary = history.getSummary(historyDoc);
+        let personalPainThreshold = (summary && summary.avgLossPct < 0) 
+            ? summary.avgLossPct 
+            : -25.0;
+
+        // 3. Analyze Positions
+        const positions = extract.getPositions(user.portfolio.today, user.type);
+
+       for (const pos of positions) {
+            const instId = extract.getInstrumentId(pos);
+            
+            if (!this.tickerMap) continue;
+
+            const ticker = this.tickerMap[instId];
+            
+            if (!ticker) continue;
+
+            // Fetch Dependency
+            const assetStats = signals.getPreviousState(computed, 'asset-volatility-estimator', ticker);
+            
+            const dynamicVol = assetStats ? assetStats.volatility_30d : 0.60;
+            const currentPrice = assetStats ? assetStats.last_price : 0;
+
+            if (currentPrice <= 0) continue;
+
+            // Get P&L from Position Schema
+            const netProfit = extract.getNetProfit(pos);     
+            
+            // Calculate Entry Price using the Dependency Price
+            const entryPrice = extract.deriveEntryPrice(currentPrice, netProfit);
+
+            if (entryPrice > 0) {
+                this._initAsset(ticker, currentPrice, dynamicVol);
+                this.assetRiskProfiles.get(ticker).profiles.push({
+                    entryPrice: entryPrice,
+                    thresholdPct: personalPainThreshold
+                });
+            }
+        }
+    }
+
+    async getResult() {
+        const result = {};
+        const TIME_HORIZON_DAYS = 3;      
+        const SIMULATION_COUNT = 1000;    
+        
+        // Access the library from the container
+        const mathLib = this.deps.mathLib;
+
+        if (!mathLib || !mathLib.simulateGBM) {
+            console.log('[DEBUG RCRF] MathLib missing in deps container!');
+            return {};
+        }
+
+        for (const [ticker, data] of this.assetRiskProfiles.entries()) {
+            if (data.profiles.length < 1) { 
+                 continue; 
+            }
+            
+            try {
+                // 1. Generate Price Paths
+                const pricePaths = mathLib.simulateGBM(
+                    data.currentPrice, 
+                    data.volatility, 
+                    TIME_HORIZON_DAYS, 
+                    SIMULATION_COUNT
+                );
+                
+                if (!pricePaths || pricePaths.length === 0) continue;
+
+                // 2. Run Population Breakdown
+                const capitulationProb = mathLib.simulatePopulationBreakdown(
+                    pricePaths, 
+                    data.profiles
+                );
+
+                const totalThreshold = data.profiles.reduce((acc, p) => acc + p.thresholdPct, 0);
+                const avgThreshold = totalThreshold / data.profiles.length;
+
+                result[ticker] = {
+                    capitulation_probability: parseFloat(capitulationProb.toFixed(4)),
+                    at_risk_user_count: data.profiles.length,
+                    average_pain_threshold_pct: parseFloat(avgThreshold.toFixed(2)),
+                    used_volatility: parseFloat(data.volatility.toFixed(4))
+                };
+            } catch (err) {
+                console.log(`[DEBUG RCRF] Error processing ${ticker}: ${err.message}`);
+            }
+        }
+        
+        return result;
+    }
+
+    reset() {
+        this.assetRiskProfiles.clear();
+        this.tickerMap = null;
+        this.deps.mathLib = null; // Reset the container
+    }
+}
+
+module.exports = RetailCapitulationRiskForecast;

package/calculations/core/asset-cost-basis-profile.js

@@ -0,0 +1,127 @@
+/**
+ * @fileoverview Core Calculation (Pass 2)
+ * Generates the "Ghost Book" - KDE of Holder Cost Basis.
+ * ARCHITECTURE COMPLIANT: Uses Context for Math & Prices.
+ */
+class AssetCostBasisProfile {
+    constructor() {
+        // Map<Ticker, Map<PriceKey, Weight>>
+        this.assetBins = new Map(); 
+        this.tickerMap = null;
+        // FIX 1: Change state name to clearly indicate storage of the function pointer
+        this.computeKDE_func = null; 
+    }
+
+    static getMetadata() {
+        return {
+            type: 'standard',
+            rootDataDependencies: ['portfolio'], 
+            dependencies: [], 
+            isHistorical: false,
+            userType: 'all', 
+            category: 'core_distribution'
+        };
+    }
+
+    static getDependencies() { return []; }
+
+    static getSchema() {
+        const profileSchema = {
+            "type": "object",
+            "properties": {
+                "profile": { 
+                    "type": "array", 
+                    "items": { "type": "object", "properties": { "price": {"type": "number"}, "density": {"type": "number"} } } 
+                },
+                "current_price": { "type": "number" },
+                "total_inventory_weight": { "type": "number" }
+            }
+        };
+        return { "type": "object", "patternProperties": { "^.*$": profileSchema } };
+    }
+
+    process(context) {
+        const { user, mappings, math } = context; 
+        
+        // FIX 2 (CRITICAL): Store the *function pointer* itself from math.distribution.computeKDE.
+        // This is necessary because storing the class object (math.distribution) breaks the static method reference when serialized/deserialized by worker threads.
+        if (!this.computeKDE_func) {
+            this.computeKDE_func = math.distribution.computeKDE;
+        }
+        
+        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
+
+        const { extract } = math; 
+
+        const positions = extract.getPositions(user.portfolio.today, user.type);
+
+        for (const pos of positions) {
+            const instId = extract.getInstrumentId(pos);
+            const ticker = this.tickerMap[instId];
+            
+            if (!ticker) continue;
+
+            const currentPrice = extract.getCurrentRate(pos); 
+            if (currentPrice <= 0) continue;
+
+            const netProfitPct = extract.getNetProfit(pos); 
+            const weight = extract.getPositionWeight(pos, user.type); 
+            
+            if (netProfitPct <= -99.9) continue;
+
+            const entryPrice = currentPrice / (1 + (netProfitPct / 100.0));
+
+            const priceKey = Number(entryPrice.toPrecision(6));
+
+            if (!this.assetBins.has(ticker)) {
+                this.assetBins.set(ticker, { bins: new Map(), currentPrice });
+            }
+            const asset = this.assetBins.get(ticker);
+            
+            asset.currentPrice = currentPrice; 
+            
+            const currentWeight = asset.bins.get(priceKey) || 0;
+            asset.bins.set(priceKey, currentWeight + weight);
+        }
+    }
+
+    async getResult() {
+        const result = {};
+        
+        // Use the function pointer stored in state. No longer need the corrupted 'DistributionAnalytics' variable.
+        const computeKDE = this.computeKDE_func; 
+
+        if (!computeKDE) return {}; // Safety guard
+
+        for (const [ticker, data] of this.assetBins.entries()) {
+            const points = [];
+            let totalWeight = 0;
+            for (const [price, weight] of data.bins.entries()) {
+                points.push({ value: price, weight: weight });
+                totalWeight += weight;
+            }
+
+            if (points.length < 2) continue; 
+
+            const bandwidth = data.currentPrice * 0.02;
+            
+            // FIX 3: Call the stored function directly
+            const profile = computeKDE(points, bandwidth, 60);
+
+            result[ticker] = {
+                profile: profile,
+                current_price: data.currentPrice,
+                total_inventory_weight: totalWeight
+            };
+        }
+        return result;
+    }
+
+    reset() { 
+        this.assetBins.clear(); 
+        this.tickerMap = null;
+        this.computeKDE_func = null;
+    }
+}
+
+module.exports = AssetCostBasisProfile;

package/calculations/core/asset-pnl-status.js

@@ -1,170 +1,100 @@
 /**
  * @fileoverview Core Metric (Pass 2)
- *
- * This 'standard' calculation streams all user portfolios
- * and, for each asset, buckets users into "Winner" (in-profit)
- * and "Loser" (in-loss) cohorts.
- *
- * It is a dependency for calculations that need to know
- * the full list of users in each cohort (e.g., 'helix-contrarian-signal')
- * but is too large to be a dependency for 'winner-loser-flow'.
+ * REFACTORED: Buckets users by P&L status (Win/Loss).
  */
-// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
-
 class AssetPnlStatus {
     constructor() {
-        // { [ticker]: { winners: [uid1, uid2], losers: [uid1] } }
         this.tickerBuckets = new Map();
-        // { [sector]: { winners: [uid1, uid2], losers: [uid1] } }
         this.sectorBuckets = new Map();
-        
-        // --- STANDARD 0: RENAMED ---
-        this.tickerMap = null;
-        this.sectorMap = null;
-        
     }
 
-    /** Statically defines metadata */
     static getMetadata() {
         return {
             type: 'standard',
             rootDataDependencies: ['portfolio'],
-            isHistorical: false, // Reads today's portfolio
+            isHistorical: false,
             userType: 'all',
             category: 'core'
         };
     }
 
-    /** Statically declare dependencies */
-    static getDependencies() {
-        return []; // This is a Pass 2 calculation
-    }
+    static getDependencies() { return []; }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
         const cohortSchema = {
             "type": "object",
             "properties": {
-                "winners": {
-                    "type": "array",
-                    "items": { "type": "string" },
-                    "description": "List of User IDs in the 'Winner' (in-profit) cohort."
-                },
-                "losers": {
-                    "type": "array",
-                    "items": { "type": "string" },
-                    "description": "List of User IDs in the 'Loser' (in-loss) cohort."
-                }
+                "winners": { "type": "array", "items": { "type": "string" } },
+                "losers": { "type": "array", "items": { "type": "string" } }
             },
             "required": ["winners", "losers"]
         };
-        
         return {
             "type": "object",
-            "description": "Buckets all users into 'Winner' or 'Loser' cohorts per asset and sector.",
             "properties": {
-                "by_ticker": {
-                    "type": "object",
-                    "patternProperties": { "^.*$": cohortSchema },
-                    "additionalProperties": cohortSchema
-                },
-                "by_sector": {
-                    "type": "object",
-                    "patternProperties": { "^.*$": cohortSchema },
-                    "additionalProperties": cohortSchema
-                }
-            },
-            "required": ["by_ticker", "by_sector"]
+                "by_ticker": { "type": "object", "patternProperties": { "^.*$": cohortSchema } },
+                "by_sector": { "type": "object", "patternProperties": { "^.*$": cohortSchema } }
+            }
         };
     }
     
     _init(map, key) {
-        if (!map.has(key)) {
-            map.set(key, { winners: new Set(), losers: new Set() });
-        }
+        if (!map.has(key)) map.set(key, { winners: new Set(), losers: new Set() });
     }
 
-    process(todayPortfolio, yesterdayPortfolio, userId, context) {
-        // --- STANDARD 0: FIXED ---
-        if (!this.tickerMap) {
-             this.tickerMap = context.instrumentToTicker;
-             this.sectorMap = context.sectorMapping;
-        }
-        
-        if (!this.tickerMap || !this.sectorMap) {
-            return; // Failsafe if context is missing maps
-        }
-        
-        const positions = todayPortfolio?.AggregatedPositions || todayPortfolio?.PublicPositions;
-        if (!positions || positions.length === 0) {
-            return;
-        }
+    process(context) {
+        const { extract } = context.math;
+        const { mappings, user } = context;
+
+        const positions = extract.getPositions(user.portfolio.today, user.type);
 
         for (const pos of positions) {
-            if (!pos.InstrumentID) continue;
+            const instId = extract.getInstrumentId(pos);
+            if (!instId) continue;
             
-            const pnl = pos.NetProfit || 0;
-            if (pnl === 0) continue; // Ignore neutral
+            const pnl = extract.getNetProfit(pos);
+            if (pnl === 0) continue;
             
-            // --- STANDARD 0: SIMPLIFIED ---
-            const ticker = this.tickerMap[pos.InstrumentID];
-            const sector = this.sectorMap[pos.InstrumentID];
+            const ticker = mappings.instrumentToTicker[instId];
+            const sector = mappings.sectorMapping[instId];
             const isWinner = pnl > 0;
 
             if (ticker) {
                 this._init(this.tickerBuckets, ticker);
                 const asset = this.tickerBuckets.get(ticker);
-                if (isWinner) asset.winners.add(userId);
-                else asset.losers.add(userId);
+                if (isWinner) asset.winners.add(user.id);
+                else asset.losers.add(user.id);
             }
             
             if (sector) {
                 this._init(this.sectorBuckets, sector);
                 const sec = this.sectorBuckets.get(sector);
-                if (isWinner) sec.winners.add(userId);
-                else sec.losers.add(userId);
+                if (isWinner) sec.winners.add(user.id);
+                else sec.losers.add(user.id);
             }
         }
     }
 
     async getResult() {
-        // --- STANDARD 0: REMOVED forbidden data load ---
-
-        // Failsafe check
-        if (!this.tickerMap) {
-            return { by_ticker: {}, by_sector: {} };
-        }
-
-        const result = {
-            by_ticker: {},
-            by_sector: {}
-        };
-        
-        for (const [ticker, data] of this.tickerBuckets.entries()) {
-            result.by_ticker[ticker] = {
-                winners: Array.from(data.winners),
-                losers: Array.from(data.losers)
-            };
-        }
-        
-        for (const [sector, data] of this.sectorBuckets.entries()) {
-            result.by_sector[sector] = {
-                winners: Array.from(data.winners),
-                losers: Array.from(data.losers)
-            };
-        }
+        const result = { by_ticker: {}, by_sector: {} };
         
+        const buildResult = (map, out) => {
+            for (const [key, data] of map.entries()) {
+                out[key] = {
+                    winners: Array.from(data.winners),
+                    losers: Array.from(data.losers)
+                };
+            }
+        };
+
+        buildResult(this.tickerBuckets, result.by_ticker);
+        buildResult(this.sectorBuckets, result.by_sector);
         return result;
     }
     
     reset() {
         this.tickerBuckets.clear();
         this.sectorBuckets.clear();
-        // --- STANDARD 0: RENAMED ---
-        this.tickerMap = null;
-        this.sectorMap = null;
     }
 }
 module.exports = AssetPnlStatus;