aiden-shared-calculations-unified 1.0.82 → 1.0.84

package/calculations/helix/herd-consensus-score.js

@@ -1,44 +1,42 @@
 /**
- * @fileoverview HELIX Product Line (Pass 3)
+ * @fileoverview HELIX Product Line (Pass 2)
  *
- * This metric answers: "What is the 'Herd Consensus Score' for
- * each asset?"
- *
- * It blends sentiment from three different views of the herd:
- * 1. The entire Platform (from gem/platform-conviction-divergence)
- * 2. Our 20k User Sample (from core/sentiment-per-stock)
- * 3. Social Media (from core/social-sentiment-aggregation)
- *
- * The score is normalized from -10 (Extreme Bearish Consensus)
- * to +10 (Extreme Bullish Consensus).
+ * This metric answers: "For each asset, what is the
+ * net 'conviction' (avg. position change) of the
+ * 'Herd' (in-loss) cohort?"
  */
+// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
+
+
 class HerdConsensusScore {
+    constructor() {
+        // { [instrumentId]: { ... } }
+        this.assetConviction = new Map();
+        
+        // --- STANDARD 0: RENAMED ---
+        this.tickerMap = null; 
+    }
 
     /**
      * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
      */
     static getSchema() {
         const tickerSchema = {
             "type": "object",
             "properties": {
-                "consensus_score": {
+                "herd_conviction_score": {
                     "type": "number",
-                    "description": "Blended score (-10 to +10) of platform, sample, and social sentiment."
+                    "description": "Avg. % change in position size for 'Loser' cohort. Positive = Buying the Dip, Negative = Capitulating."
                 },
-                "platform_sentiment": { "type": "number" },
-                "sample_sentiment": { "type": "number" },
-                "social_sentiment": { "type": "number" }
+                "user_count": { "type": "number" }
             },
-            "required": ["consensus_score"]
+            "required": ["herd_conviction_score", "user_count"]
         };
         
         return {
             "type": "object",
-            "description": "Calculates a blended 'Herd Consensus Score' (-10 to +10) per asset.",
-            "patternProperties": {
-                "^.*$": tickerSchema // Ticker
-            },
+            "description": "Tracks the change in avg. position size for the 'Loser' (in-loss) cohort.",
+            "patternProperties": { "^.*$": tickerSchema },
             "additionalProperties": tickerSchema
         };
     }
@@ -48,10 +46,10 @@ class HerdConsensusScore {
      */
     static getMetadata() {
         return {
-            type: 'meta',
-            rootDataDependencies: [],
-            isHistorical: false,
-            userType: 'n/a',
+            type: 'standard',
+            rootDataDependencies: ['portfolio'],
+            isHistorical: true, // Needs T-1 portfolio
+            userType: 'all',
             category: 'helix'
         };
     }
@@ -60,93 +58,133 @@ class HerdConsensusScore {
      * Statically declare dependencies.
      */
     static getDependencies() {
-        return [
-            // This is the only source of *per-ticker* platform sentiment
-            'platform-conviction-divergence', // from gem
-            'sentiment-per-stock',             // from core
-            'social-sentiment-aggregation'     // from core
-        ];
-    }
-    
-    /**
-     * Normalizes a 0-100 value (like platform_long_pct) to -1.0 to +1.0
-     */
-    _normalizePercent(v) {
-        if (v === null || v === undefined) return 0;
-        const score = (v - 50) / 50; // 50 -> 0, 100 -> 1, 0 -> -1
-        return Math.max(-1, Math.min(1, score));
+        return [];
     }
 
-    /**
-     * Normalizes a net percent value (-100 to 100) to -1.0 to +1.0
-     */
-    _normalizeNetPercent(v) {
-        if (v === null || v === undefined) return 0;
-        const score = v / 100;
-        return Math.max(-1, Math.min(1, score));
+    _getPortfolioPositions(portfolio) {
+        return portfolio?.AggregatedPositions || portfolio?.PublicPositions;
     }
     
-    /**
-     * Normalizes a ratio (0 to Inf) to -1.0 to +1.0
-     * 1.0 -> 0.0 (Neutral)
-     * 0.5 -> -1.0 (Bearish)
-     * 2.0 -> +1.0 (Bullish)
-     */
-    _normalizeRatio(v) {
-        if (v === null || v === undefined || v <= 0) return -1.0;
-        const score = Math.log2(v); // log2(1)=0, log2(0.5)=-1, log2(2)=1
-        return Math.max(-1, Math.min(1, score));
+    _initAsset(instrumentId) {
+        if (!this.assetConviction.has(instrumentId)) {
+            this.assetConviction.set(instrumentId, {
+                total_pos_size_yesterday: 0,
+                total_pos_size_today: 0,
+                user_count_yesterday: 0,
+                user_count_today: 0
+            });
+        }
     }
 
-    /**
-     * This is a 'meta' calculation. It runs once.
-     */
-    async process(dateStr, dependencies, config, fetchedDependencies) {
-        const { logger } = dependencies;
+    process(todayPortfolio, yesterdayPortfolio, userId, context) {
+        if (!todayPortfolio) {
+            return;
+        }
         
-        const platformData = fetchedDependencies['platform-conviction-divergence'];
-        const sampleData = fetchedDependencies['sentiment-per-stock'];
-        const socialData = fetchedDependencies['social-sentiment-aggregation']?.per_ticker;
-
-        if (!platformData || !sampleData || !socialData) {
-            logger.log('WARN', `[helix/herd-consensus-score] Missing dependencies for ${dateStr}. Skipping.`);
-            return {};
+        // --- STANDARD 0: FIXED ---
+        if (!this.tickerMap) {
+             this.tickerMap = context.instrumentToTicker;
         }
 
-        const allTickers = new Set([
-            ...Object.keys(platformData),
-            ...Object.keys(sampleData),
-            ...Object.keys(socialData)
-        ]);
-        
-        const result = {};
+        const tPos = this._getPortfolioPositions(todayPortfolio);
+        if (!tPos) return;
 
-        for (const ticker of allTickers) {
-            // 1. Platform Sentiment (0-100) -> -1 to +1
-            const plat_long_pct = platformData[ticker]?.platform_long_pct;
-            const s_plat = this._normalizePercent(plat_long_pct);
+        // --- Determine Cohort ---
+        // We *only* care about users who are *currently* in the
+        // 'Loser' cohort for any given asset.
+        const tPosMap = new Map(tPos.map(p => [p.InstrumentID, p]));
+        const yPosMap = new Map((this._getPortfolioPositions(yesterdayPortfolio) || []).map(p => [p.InstrumentID, p]));
+        
+        const allInstrumentIds = new Set([...yPosMap.keys(), ...tPosMap.keys()]);
+        if (allInstrumentIds.size === 0) {
+            return;
+        }
+        
+        for (const instrumentId of allInstrumentIds) {
+            const tP = tPosMap.get(instrumentId);
+            const yP = yPosMap.get(instrumentId);
             
-            // 2. Sample Sentiment (Ratio) -> -1 to +1
-            const sample_ratio = sampleData[ticker]?.sentiment_ratio;
-            const s_samp = this._normalizeRatio(sample_ratio);
+            // --- Check Cohort Status (In-Loss) ---
+            const tPnl = tP?.NetProfit || 0;
+            const isLoser = tPnl < 0;
             
-            // 3. Social Sentiment (-100 to 100) -> -1 to +1
-            const social_pct = socialData[ticker]?.net_sentiment_pct;
-            const s_soc = this._normalizeNetPercent(social_pct);
-
-            // Blend scores (equal weight) and scale to -10 to +10
-            const consensus_score = ((s_plat + s_samp + s_soc) / 3) * 10;
+            // We only process conviction for assets this user
+            // is *currently* losing on.
+            if (!isLoser) {
+                continue;
+            }
             
-            result[ticker] = {
-                consensus_score: consensus_score,
-                platform_sentiment: s_plat,
-                sample_sentiment: s_samp,
-                social_sentiment: s_soc
-            };
+            // --- This user is in the 'Herd' for this asset ---
+            this._initAsset(instrumentId);
+            const asset = this.assetConviction.get(instrumentId);
+
+            // ---
+            // FIX: The field 'PositionSizeInUnits' does not exist in schema.md.
+            // For Normal users, the field is 'Invested'.
+            // For Speculator users, the field is 'Amount'.
+            // This line now correctly checks for either.
+            // ---
+            const ySize = yP?.Invested || yP?.Amount || 0;
+            const tSize = tP?.Invested || tP?.Amount || 0;
+
+            if (ySize > 0) {
+                asset.total_pos_size_yesterday += ySize;
+                asset.user_count_yesterday++;
+            }
+            if (tSize > 0) {
+                asset.total_pos_size_today += tSize;
+                asset.user_count_today++;
+            }
+        }
+    }
+
+    async getResult() {
+        // --- STANDARD 0: REMOVED forbidden data load ---
+
+        // Failsafe check
+        if (!this.tickerMap) {
+            return {}; // process() must run first
+        }
+
+        const result = {};
+        for (const [instrumentId, data] of this.assetConviction.entries()) {
+            // --- STANDARD 0: SIMPLIFIED ---
+            const ticker = this.tickerMap[instrumentId];
+            if (!ticker) continue;
+
+            const { 
+                total_pos_size_yesterday, total_pos_size_today,
+                user_count_yesterday, user_count_today
+            } = data;
+
+            let avg_position_change_pct = 0;
+
+            if (user_count_yesterday > 0 && user_count_today > 0) {
+                const avg_pos_y = total_pos_size_yesterday / user_count_yesterday;
+                const avg_pos_t = total_pos_size_today / user_count_today;
+                if (avg_pos_y > 0) {
+                    avg_position_change_pct = ((avg_pos_t - avg_pos_y) / avg_pos_y) * 100;
+                }
+            } else if (user_count_today > 0) {
+                // Pure inflow, conviction is max
+                avg_position_change_pct = Infinity;
+            }
+
+            if (isFinite(avg_position_change_pct) && user_count_today > 0) {
+                result[ticker] = {
+                    herd_conviction_score: avg_position_change_pct,
+                    user_count: user_count_today
+                };
+            }
         }
-        
         return result;
     }
+
+    reset() {
+        this.assetConviction.clear();
+        // --- STANDARD 0: RENAMED ---
+        this.tickerMap = null;
+    }
 }
 
 module.exports = HerdConsensusScore;

package/calculations/helix/winner-loser-flow.js

@@ -10,14 +10,15 @@
  * This calculation now determines "winner/loser" status internally
  * by reading the user's portfolio P&L directly.
  */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
 
 
 class WinnerLoserFlow {
     constructor() {
         // We will store { [ticker]: { winners_joined: 0, ... } }
         this.assetFlows = new Map();
-        this.mappings = null; // Caches mappings
+        // --- STANDARD 0: RENAMED ---
+        this.tickerMap = null; // Caches mappings
     }
 
     /**
@@ -74,15 +75,12 @@ class WinnerLoserFlow {
 
     /**
      * Statically declare dependencies.
-     * --- MODIFIED ---
-     * Removed 'asset-pnl-status' dependency.
      */
     static getDependencies() {
         return [];
     }
 
     /**
-     * --- MODIFIED ---
      * Helper to get a user's holdings (Instrument IDs) AND their P&L.
      * @returns {Map<InstrumentID, {pnl: number}>}
      */
@@ -119,8 +117,13 @@ class WinnerLoserFlow {
             return;
         }
 
-        if (!this.mappings) {
-            this.mappings = context.mappings;
+        // --- STANDARD 0: FIXED ---
+        if (!this.tickerMap) {
+             this.tickerMap = context.instrumentToTicker;
+        }
+        
+        if (!this.tickerMap) {
+            return; // Failsafe if context is missing map
         }
 
         const yHoldings = this._getHoldingsWithPnl(yesterdayPortfolio); // Map<InstID, {pnl}>
@@ -132,17 +135,14 @@ class WinnerLoserFlow {
         }
 
         for (const instrumentId of allInstrumentIds) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId];
+            // --- STANDARD 0: FIXED ---
+            const ticker = this.tickerMap[instrumentId];
             if (!ticker) continue;
             
-            // --- MODIFIED ---
-            // Determine cohort status from today's portfolio.
             const tPnl = tHoldings.get(instrumentId)?.pnl;
             const isWinner = tPnl > 0;
             const isLoser = tPnl < 0;
-            // --- END MODIFIED ---
             
-            // We only care about users who are *currently* in a cohort
             if (!isWinner && !isLoser) {
                 continue;
             }
@@ -150,7 +150,6 @@ class WinnerLoserFlow {
             const heldYesterday = yHoldings.has(instrumentId);
             const holdsToday = tHoldings.has(instrumentId);
 
-            // Skip if no change in holding status
             if (heldYesterday === holdsToday) {
                 continue;
             }
@@ -183,7 +182,8 @@ class WinnerLoserFlow {
 
     reset() {
         this.assetFlows.clear();
-        this.mappings = null;
+        // --- STANDARD 0: RENAMED ---
+        this.tickerMap = null;
     }
 }
 

package/calculations/pyro/risk-appetite-index.js

@@ -1,153 +1,151 @@
 /**
  * @fileoverview PYRO Product Line (Pass 2)
- *
- * This metric answers: "For each asset, what is the 'Risk-On'
- * score from speculators?"
- *
- * It combines the average leverage being used with the
- * average Risk/Reward ratio being set. A high score means
- * speculators are confident: using high leverage *and*
- * setting wide R/R targets.
+ * --- FIX ---
+ * - Updated 'process' signature to the 7-arg standard to get context.
+ * - Logic is already schema-compliant (uses pos.Leverage).
  */
+
 class RiskAppetiteIndex {
+    constructor() {
+        this.tickerLeverage = new Map();
+        this.sectorLeverage = new Map();
+        this.tickerMap = null;
+        this.sectorMap = null;
+    }
+
+    static getMetadata() {
+        return {
+            type: 'standard',
+            rootDataDependencies: ['portfolio'],
+            isHistorical: false, 
+            userType: 'speculator', // Only processes speculators
+            category: 'pyro'
+        };
+    }
+
+    static getDependencies() {
+        return [];
+    }
 
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
     static getSchema() {
-        const tickerSchema = {
+        const schema = {
             "type": "object",
             "properties": {
-                "risk_appetite_score": {
-                    "type": "number",
-                    "description": "Blended score (0-10) of leverage use and R/R conviction."
-                },
-                "avg_leverage": {
-                    "type": "number",
-                    "description": "Weighted average leverage used on this asset."
-                },
-                "avg_rr_ratio": {
-                    "type": "number",
-                    "description": "Average R/R ratio set on this asset."
-                }
+                "avg_leverage": { "type": "number" },
+                "user_count": { "type": "number" }
             },
-            "required": ["risk_appetite_score", "avg_leverage", "avg_rr_ratio"]
+            "required": ["avg_leverage", "user_count"]
         };
-        
+
         return {
             "type": "object",
-            "description": "Calculates a 'Risk-On' score for speculators per asset.",
-            "patternProperties": {
-                "^.*$": tickerSchema // Ticker
+            "description": "Calculates the average leverage used by speculators, aggregated by ticker and sector.",
+            "properties": {
+                "by_ticker": { "type": "object", "patternProperties": { "^.*$": schema }, "additionalProperties": schema },
+                "by_sector": { "type": "object", "patternProperties": { "^.*$": schema }, "additionalProperties": schema }
             },
-            "additionalProperties": tickerSchema
+            "required": ["by_ticker", "by_sector"]
         };
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
-    static getMetadata() {
-        return {
-            type: 'meta',
-            rootDataDependencies: [],
-            isHistorical: false,
-            userType: 'n/a',
-            category: 'pyro'
-        };
+    _init(map, key) {
+        if (!map.has(key)) {
+            map.set(key, { leverage_sum: 0, user_count: 0 });
+        }
     }
 
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [
-            'speculator-leverage-per-asset', // from core
-            'speculator-risk-reward-ratio-per-asset' // from core
-        ];
-    }
-    
-    /**
-     * Helper to calculate weighted average leverage from buckets.
-     * e.g., { "1x": 10, "5x": 5 }
-     */
-    _calculateAvgLeverage(levBuckets) {
-        if (!levBuckets || typeof levBuckets !== 'object') {
-            return 1; // Default to 1x leverage
+    // --- THIS IS THE FIX ---
+    // Updated signature to match the test worker's standard 7-arg call
+    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
+    // --- END FIX ---
+
+        if (!todayPortfolio?.PublicPositions) {
+            return; // Not a speculator or no positions
         }
-        
-        let totalCount = 0;
-        let weightedSum = 0;
-        
-        for (const [key, count] of Object.entries(levBuckets)) {
-            const leverage = parseInt(key, 10); // "5x" -> 5
-            if (!isNaN(leverage) && count > 0) {
-                totalCount += count;
-                weightedSum += (leverage * count);
-            }
+
+        if (!this.tickerMap) {
+             this.tickerMap = context.instrumentToTicker;
+             this.sectorMap = context.sectorMapping;
+        }
+
+        if (!this.tickerMap || !this.sectorMap) {
+            return; 
         }
-        
-        if (totalCount === 0) {
-            return 1; // Default to 1x if no positions
+
+        const positions = todayPortfolio.PublicPositions;
+
+        const seenTickers = new Set();
+        const seenSectors = new Set();
+
+        for (const pos of positions) {
+            if (!pos.InstrumentID || !pos.Leverage) continue;
+
+            const leverage = pos.Leverage;
+            if (leverage <= 1) continue; // Only care about leveraged positions
+
+            const ticker = this.tickerMap[pos.InstrumentID];
+            const sector = this.sectorMap[pos.InstrumentID];
+
+            if (ticker) {
+                this._init(this.tickerLeverage, ticker);
+                const asset = this.tickerLeverage.get(ticker);
+                asset.leverage_sum += leverage;
+
+                if (!seenTickers.has(ticker)) {
+                    asset.user_count++;
+                    seenTickers.add(ticker);
+                }
+            }
+
+            if (sector) {
+                this._init(this.sectorLeverage, sector);
+                const sec = this.sectorLeverage.get(sector);
+                sec.leverage_sum += leverage;
+
+                if (!seenSectors.has(sector)) {
+                    sec.user_count++;
+                    seenSectors.add(sector);
+                }
+            }
         }
-        return weightedSum / totalCount;
-    }
-    
-    /**
-     * Simple min-max normalization, clamped 0-1.
-     */
-    _normalize(value, min, max) {
-        const normalized = (value - min) / (max - min);
-        return Math.max(0, Math.min(1, normalized));
     }
 
-    /**
-     * This is a 'meta' calculation. It runs once.
-     * @param {string} dateStr - The date string 'YYYY-MM-DD'.
-     * @param {object} dependencies - The shared dependencies (e.g., logger).
-     * @param {object} config - The computation system configuration.
-     * @param {object} fetchedDependencies - Results from Pass 1.
-     * @returns {Promise<object>} The calculation result.
-     */
-    async process(dateStr, dependencies, config, fetchedDependencies) {
-        const { logger } = dependencies;
-        
-        const leverageData = fetchedDependencies['speculator-leverage-per-asset'];
-        const rrData = fetchedDependencies['speculator-risk-reward-ratio-per-asset'];
-
-        if (!leverageData || !rrData) {
-            logger.log('WARN', `[pyro/risk-appetite-index] Missing core dependencies for ${dateStr}. Skipping.`);
-            return {};
+    async getResult() {
+        if (!this.tickerMap) {
+            return { by_ticker: {}, by_sector: {} };
+        }
+
+        const result = {
+            by_ticker: {},
+            by_sector: {}
+        };
+
+        for (const [ticker, data] of this.tickerLeverage.entries()) {
+            if (data.user_count > 0) {
+                result.by_ticker[ticker] = {
+                    avg_leverage: data.leverage_sum / data.user_count,
+                    user_count: data.user_count
+                };
+            }
         }
 
-        const allTickers = new Set([
-            ...Object.keys(leverageData),
-            ...Object.keys(rrData)
-        ]);
-        
-        const result = {};
-
-        for (const ticker of allTickers) {
-            const avg_leverage = this._calculateAvgLeverage(leverageData[ticker]);
-            const avg_rr_ratio = rrData[ticker]?.avg_rr_ratio || 0;
-            
-            // Normalize: Leverage from 1x-10x, R/R from 0-5
-            const norm_lev = this._normalize(avg_leverage, 1, 10);
-            const norm_rr = this._normalize(avg_rr_ratio, 0, 5);
-            
-            // Combine scores and scale to 0-10
-            const risk_appetite_score = (norm_lev * 0.6 + norm_rr * 0.4) * 10;
-            
-            result[ticker] = {
-                risk_appetite_score: risk_appetite_score,
-                avg_leverage: avg_leverage,
-                avg_rr_ratio: avg_rr_ratio
-            };
+        for (const [sector, data] of this.sectorLeverage.entries()) {
+            if (data.user_count > 0) {
+                result.by_sector[sector] = {
+                    avg_leverage: data.leverage_sum / data.user_count,
+                    user_count: data.user_count
+                };
+            }
         }
-        
+
         return result;
     }
-}
 
+    reset() {
+        this.tickerLeverage.clear();
+        this.sectorLeverage.clear();
+        this.tickerMap = null;
+        this.sectorMap = null;
+    }
+}
 module.exports = RiskAppetiteIndex;