aiden-shared-calculations-unified 1.0.84 → 1.0.87

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

@@ -1,179 +1,99 @@
 /**
  * @fileoverview HELIX Product Line (Pass 2)
- *
- * This metric answers: "For each asset, what is the
- * net 'conviction' (avg. position change) of the
- * 'Herd' (in-loss) cohort?"
+ * REFACTORED: Uses context.math.extract.
  */
-// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
-
-
 class HerdConsensusScore {
     constructor() {
-        // { [instrumentId]: { ... } }
         this.assetConviction = new Map();
-        
-        // --- STANDARD 0: RENAMED ---
-        this.tickerMap = null; 
+        this.tickerMap = null;
     }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
         const tickerSchema = {
             "type": "object",
             "properties": {
-                "herd_conviction_score": {
-                    "type": "number",
-                    "description": "Avg. % change in position size for 'Loser' cohort. Positive = Buying the Dip, Negative = Capitulating."
-                },
+                "herd_conviction_score": { "type": "number" },
                 "user_count": { "type": "number" }
             },
             "required": ["herd_conviction_score", "user_count"]
         };
-        
-        return {
-            "type": "object",
-            "description": "Tracks the change in avg. position size for the 'Loser' (in-loss) cohort.",
-            "patternProperties": { "^.*$": tickerSchema },
-            "additionalProperties": tickerSchema
-        };
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'standard',
             rootDataDependencies: ['portfolio'],
-            isHistorical: true, // Needs T-1 portfolio
+            isHistorical: true, 
             userType: 'all',
             category: 'helix'
         };
     }
 
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
-    _getPortfolioPositions(portfolio) {
-        return portfolio?.AggregatedPositions || portfolio?.PublicPositions;
-    }
-    
     _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
+                total_pos_size_yesterday: 0, total_pos_size_today: 0,
+                user_count_yesterday: 0, user_count_today: 0
             });
         }
     }
 
-    process(todayPortfolio, yesterdayPortfolio, userId, context) {
-        if (!todayPortfolio) {
-            return;
-        }
-        
-        // --- STANDARD 0: FIXED ---
-        if (!this.tickerMap) {
-             this.tickerMap = context.instrumentToTicker;
-        }
+    process(context) {
+        const { user, mappings, math } = context;
+        const { extract } = math;
+        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
 
-        const tPos = this._getPortfolioPositions(todayPortfolio);
-        if (!tPos) return;
+        const yPos = extract.getPositions(user.portfolio.yesterday, user.type);
+        const tPos = extract.getPositions(user.portfolio.today, user.type);
 
-        // --- 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 yPosMap = new Map(yPos.map(p => [extract.getInstrumentId(p), p]));
+        const tPosMap = new Map(tPos.map(p => [extract.getInstrumentId(p), 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);
+        const allIds = new Set([...yPosMap.keys(), ...tPosMap.keys()]);
+
+        for (const instId of allIds) {
+            const tP = tPosMap.get(instId);
+            const yP = yPosMap.get(instId);
             
-            // --- Check Cohort Status (In-Loss) ---
-            const tPnl = tP?.NetProfit || 0;
-            const isLoser = tPnl < 0;
+            if (extract.getNetProfit(tP) >= 0) continue; // Only Losers (Herd)
             
-            // We only process conviction for assets this user
-            // is *currently* losing on.
-            if (!isLoser) {
-                continue;
-            }
-            
-            // --- 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;
+            this._initAsset(instId);
+            const asset = this.assetConviction.get(instId);
+            const yWeight = extract.getPositionWeight(yP, user.type);
+            const tWeight = extract.getPositionWeight(tP, user.type);
 
-            if (ySize > 0) {
-                asset.total_pos_size_yesterday += ySize;
+            if (yWeight > 0) {
+                asset.total_pos_size_yesterday += yWeight;
                 asset.user_count_yesterday++;
             }
-            if (tSize > 0) {
-                asset.total_pos_size_today += tSize;
+            if (tWeight > 0) {
+                asset.total_pos_size_today += tWeight;
                 asset.user_count_today++;
             }
         }
     }
 
     async getResult() {
-        // --- STANDARD 0: REMOVED forbidden data load ---
-
-        // Failsafe check
-        if (!this.tickerMap) {
-            return {}; // process() must run first
-        }
-
+        if (!this.tickerMap) return {};
         const result = {};
-        for (const [instrumentId, data] of this.assetConviction.entries()) {
-            // --- STANDARD 0: SIMPLIFIED ---
-            const ticker = this.tickerMap[instrumentId];
+        for (const [instId, data] of this.assetConviction.entries()) {
+            const ticker = this.tickerMap[instId];
             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;
+            let avg_pos_change = 0;
+            if (data.user_count_yesterday > 0 && data.user_count_today > 0) {
+                const avg_y = data.total_pos_size_yesterday / data.user_count_yesterday;
+                const avg_t = data.total_pos_size_today / data.user_count_today;
+                if (avg_y > 0) avg_pos_change = ((avg_t - avg_y) / avg_y) * 100;
+            } else if (data.user_count_today > 0) avg_pos_change = Infinity;
 
-            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) {
+            if (isFinite(avg_pos_change) && data.user_count_today > 0) {
                 result[ticker] = {
-                    herd_conviction_score: avg_position_change_pct,
-                    user_count: user_count_today
+                    herd_conviction_score: avg_pos_change,
+                    user_count: data.user_count_today
                 };
             }
         }
@@ -182,9 +102,7 @@ class HerdConsensusScore {
 
     reset() {
         this.assetConviction.clear();
-        // --- STANDARD 0: RENAMED ---
         this.tickerMap = null;
     }
 }
-
 module.exports = HerdConsensusScore;

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

@@ -1,158 +1,78 @@
 /**
  * @fileoverview HELIX Product Line (Pass 2)
- *
- * This metric answers: "For each asset, what is the net flow
- * of *unique users* into the 'Winner' (in-profit) and 'Loser'
- * (in-loss) cohorts?"
- *
- * --- MODIFIED ---
- * Removed dependency on 'asset-pnl-status' to fix 1MiB limit.
- * This calculation now determines "winner/loser" status internally
- * by reading the user's portfolio P&L directly.
+ * REFACTORED: Uses context.math.extract.
  */
-// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
-
-
 class WinnerLoserFlow {
     constructor() {
-        // We will store { [ticker]: { winners_joined: 0, ... } }
         this.assetFlows = new Map();
-        // --- STANDARD 0: RENAMED ---
-        this.tickerMap = null; // Caches mappings
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        const tickerSchema = {
-            "type": "object",
-            "properties": {
-                "net_winner_flow": {
-                    "type": "number",
-                    "description": "Net users joining the 'Winner' cohort (Joined - Left)."
-                },
-                "net_loser_flow": {
-                    "type": "number",
-                    "description": "Net users joining the 'Loser' cohort (Joined - Left)."
-                },
-                "raw_counts": {
-                    "type": "object",
-                    "properties": {
-                        "winners_joined": { "type": "number" },
-                        "winners_left": { "type": "number" },
-                        "losers_joined": { "type": "number" },
-                        "losers_left": { "type": "number" }
-                    }
-                }
-            },
-            "required": ["net_winner_flow", "net_loser_flow", "raw_counts"]
-        };
-        
-        return {
-            "type": "object",
-            "description": "Tracks the net flow of unique users into/out of the Winner (in-profit) and Loser (in-loss) cohorts per asset.",
-            "patternProperties": {
-                "^.*$": tickerSchema // Ticker
-            },
-            "additionalProperties": tickerSchema
-        };
+        this.tickerMap = null;
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'standard',
             rootDataDependencies: ['portfolio'],
-            isHistorical: true, // Needs T-1 portfolio
+            isHistorical: true,
             userType: 'all',
             category: 'helix'
         };
     }
 
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [];
+    static getDependencies() { return []; }
+
+    static getSchema() {
+        const tickerSchema = {
+            "type": "object",
+            "properties": {
+                "net_winner_flow": { "type": "number" },
+                "net_loser_flow": { "type": "number" },
+                "raw_counts": { "type": "object" }
+            },
+            "required": ["net_winner_flow", "net_loser_flow", "raw_counts"]
+        };
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
 
-    /**
-     * Helper to get a user's holdings (Instrument IDs) AND their P&L.
-     * @returns {Map<InstrumentID, {pnl: number}>}
-     */
-    _getHoldingsWithPnl(portfolio) {
-        const positions = portfolio?.AggregatedPositions || portfolio?.PublicPositions;
-        if (!positions || !Array.isArray(positions)) {
-            return new Map();
-        }
+    _getHoldings(positions, extract) {
         const map = new Map();
         for (const pos of positions) {
-            if (pos.InstrumentID) {
-                map.set(pos.InstrumentID, { pnl: pos.NetProfit || 0 });
-            }
+            const id = extract.getInstrumentId(pos);
+            if (id) map.set(id, { pnl: extract.getNetProfit(pos) });
         }
         return map;
     }
     
-    /**
-     * Initialize asset flow counters
-     */
     _initAsset(ticker) {
         if (!this.assetFlows.has(ticker)) {
-            this.assetFlows.set(ticker, {
-                winners_joined: 0,
-                winners_left: 0,
-                losers_joined: 0,
-                losers_left: 0
-            });
+            this.assetFlows.set(ticker, { winners_joined: 0, winners_left: 0, losers_joined: 0, losers_left: 0 });
         }
     }
 
-    process(todayPortfolio, yesterdayPortfolio, userId, context) {
-        if (!todayPortfolio || !yesterdayPortfolio) {
-            return;
-        }
+    process(context) {
+        const { user, mappings, math } = context;
+        const { extract } = math;
+        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
 
-        // --- STANDARD 0: FIXED ---
-        if (!this.tickerMap) {
-             this.tickerMap = context.instrumentToTicker;
-        }
+        const yPos = extract.getPositions(user.portfolio.yesterday, user.type);
+        const tPos = extract.getPositions(user.portfolio.today, user.type);
         
-        if (!this.tickerMap) {
-            return; // Failsafe if context is missing map
-        }
+        const yHoldings = this._getHoldings(yPos, extract);
+        const tHoldings = this._getHoldings(tPos, extract);
 
-        const yHoldings = this._getHoldingsWithPnl(yesterdayPortfolio); // Map<InstID, {pnl}>
-        const tHoldings = this._getHoldingsWithPnl(todayPortfolio); // Map<InstID, {pnl}>
+        const allIds = new Set([...yHoldings.keys(), ...tHoldings.keys()]);
 
-        const allInstrumentIds = new Set([...yHoldings.keys(), ...tHoldings.keys()]);
-        if (allInstrumentIds.size === 0) {
-            return;
-        }
-
-        for (const instrumentId of allInstrumentIds) {
-            // --- STANDARD 0: FIXED ---
-            const ticker = this.tickerMap[instrumentId];
+        for (const instId of allIds) {
+            const ticker = this.tickerMap[instId];
             if (!ticker) continue;
             
-            const tPnl = tHoldings.get(instrumentId)?.pnl;
+            const tPnl = tHoldings.get(instId)?.pnl || 0;
             const isWinner = tPnl > 0;
             const isLoser = tPnl < 0;
-            
-            if (!isWinner && !isLoser) {
-                continue;
-            }
-
-            const heldYesterday = yHoldings.has(instrumentId);
-            const holdsToday = tHoldings.has(instrumentId);
+            if (!isWinner && !isLoser) continue;
 
-            if (heldYesterday === holdsToday) {
-                continue;
-            }
+            const heldYesterday = yHoldings.has(instId);
+            const holdsToday = tHoldings.has(instId);
+            if (heldYesterday === holdsToday) continue;
 
             this._initAsset(ticker);
             const stats = this.assetFlows.get(ticker);
@@ -182,9 +102,7 @@ class WinnerLoserFlow {
 
     reset() {
         this.assetFlows.clear();
-        // --- STANDARD 0: RENAMED ---
         this.tickerMap = null;
     }
 }
-
 module.exports = WinnerLoserFlow;

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

@@ -1,10 +1,7 @@
 /**
  * @fileoverview PYRO Product Line (Pass 2)
- * --- FIX ---
- * - Updated 'process' signature to the 7-arg standard to get context.
- * - Logic is already schema-compliant (uses pos.Leverage).
+ * REFACTORED: Uses context.math.extract.
  */
-
 class RiskAppetiteIndex {
     constructor() {
         this.tickerLeverage = new Map();
@@ -18,14 +15,12 @@ class RiskAppetiteIndex {
             type: 'standard',
             rootDataDependencies: ['portfolio'],
             isHistorical: false, 
-            userType: 'speculator', // Only processes speculators
+            userType: 'speculator',
             category: 'pyro'
         };
     }
 
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
     static getSchema() {
         const schema = {
@@ -36,108 +31,72 @@ class RiskAppetiteIndex {
             },
             "required": ["avg_leverage", "user_count"]
         };
-
         return {
             "type": "object",
-            "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 }
-            },
-            "required": ["by_ticker", "by_sector"]
+                "by_ticker": { "type": "object", "patternProperties": { "^.*$": schema } },
+                "by_sector": { "type": "object", "patternProperties": { "^.*$": schema } }
+            }
         };
     }
 
     _init(map, key) {
-        if (!map.has(key)) {
-            map.set(key, { leverage_sum: 0, user_count: 0 });
-        }
+        if (!map.has(key)) map.set(key, { leverage_sum: 0, user_count: 0 });
     }
 
-    // --- 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
-        }
+    process(context) {
+        const { user, mappings, math } = context;
+        const { extract } = math;
 
         if (!this.tickerMap) {
-             this.tickerMap = context.instrumentToTicker;
-             this.sectorMap = context.sectorMapping;
-        }
-
-        if (!this.tickerMap || !this.sectorMap) {
-            return; 
+             this.tickerMap = mappings.instrumentToTicker;
+             this.sectorMap = mappings.sectorMapping;
         }
 
-        const positions = todayPortfolio.PublicPositions;
-
+        const positions = extract.getPositions(user.portfolio.today, user.type);
         const seenTickers = new Set();
         const seenSectors = new Set();
 
         for (const pos of positions) {
-            if (!pos.InstrumentID || !pos.Leverage) continue;
+            const instId = extract.getInstrumentId(pos);
+            if (!instId) continue;
 
-            const leverage = pos.Leverage;
-            if (leverage <= 1) continue; // Only care about leveraged positions
+            const leverage = extract.getLeverage(pos);
+            if (leverage <= 1) continue;
 
-            const ticker = this.tickerMap[pos.InstrumentID];
-            const sector = this.sectorMap[pos.InstrumentID];
+            const ticker = this.tickerMap[instId];
+            const sector = this.sectorMap[instId];
 
             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 (!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);
-                }
+                if (!seenSectors.has(sector)) { sec.user_count++; seenSectors.add(sector); }
             }
         }
     }
 
     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
-                };
-            }
-        }
-
-        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
-                };
+        const result = { by_ticker: {}, by_sector: {} };
+        const build = (map, out) => {
+            for (const [key, data] of map.entries()) {
+                if (data.user_count > 0) {
+                    out[key] = {
+                        avg_leverage: data.leverage_sum / data.user_count,
+                        user_count: data.user_count
+                    };
+                }
             }
-        }
-
+        };
+        build(this.tickerLeverage, result.by_ticker);
+        build(this.sectorLeverage, result.by_sector);
         return result;
     }