aiden-shared-calculations-unified 1.0.84 → 1.0.87

package/calculations/gem/skilled-cohort-flow.js

@@ -1,20 +1,13 @@
 /**
  * @fileoverview GEM Product Line (Pass 2)
- * --- FIX ---
- * - Added defensive checks in '_loadDependencies' to prevent crash
- * when dependencies fail to load (e.g., due to worker bug).
- * - **FIXED:** Restored logic to calculate 'avg_position_change_pct'
- * to resolve the hardcoded '0' value. This involves
- * re-adding fields to '_initFlowData' and 'process'.
+ * REFACTORED: Uses context.computed and context.math.extract.
  */
-
 class SkilledCohortFlow {
     constructor() {
         this.assetFlows = new Map();
         this.cohortMap = new Map();
-        this.tickerMap = null;
         this.dependenciesLoaded = false;
-        this.priceChangeMap = null; 
+        this.tickerMap = null;
     }
 
     static getMetadata() {
@@ -28,10 +21,7 @@ class SkilledCohortFlow {
     }
 
     static getDependencies() {
-        return [
-            'cohort-skill-definition',     // from gem (Pass 1)
-            'instrument-price-change-1d' // from core (Pass 1)
-        ];
+        return ['cohort-skill-definition', 'instrument-price-change-1d'];
     }
 
     static getSchema() {
@@ -45,208 +35,110 @@ class SkilledCohortFlow {
             },
             "required": ["net_flow_pct", "net_flow_contribution", "avg_position_change_pct", "user_count"]
         };
-
-        return {
-            "type": "object",
-            "description": "Calculates capital flow and conviction change for the 'Skilled' cohort.",
-            "patternProperties": { "^.*$": tickerSchema },
-            "additionalProperties": tickerSchema
-        };
-    }
-
-    _getPortfolioPositions(portfolio) {
-        // --- FIX: Support both Normal (Aggregated) and Speculator (Public) ---
-        return portfolio?.AggregatedPositions || portfolio?.PublicPositions;
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
 
-    // --- THIS IS THE FIX (Part 1) ---
     _initFlowData(instrumentId) {
         if (!this.assetFlows.has(instrumentId)) {
             this.assetFlows.set(instrumentId, {
-                total_invested_yesterday: 0,
-                total_invested_today: 0,
-                price_change_yesterday: 0,
-                // Restore fields needed for avg_position_change_pct
-                total_pos_size_yesterday: 0, 
-                total_pos_size_today: 0, 
-                user_count_yesterday: 0, 
-                user_count_today: 0
+                total_invested_yesterday: 0, total_invested_today: 0, price_change_yesterday: 0,
+                total_pos_size_yesterday: 0, total_pos_size_today: 0, user_count_yesterday: 0, user_count_today: 0
             });
         }
     }
-    // --- END FIX (Part 1) ---
 
-    _loadDependencies(fetchedDependencies) {
+    _loadDependencies(computed) {
         if (this.dependenciesLoaded) return;
-
-        if (!fetchedDependencies) {
-            // This will stop the test and explain the root cause.
-            throw new Error(
-                `[skilled-cohort-flow] CRITICAL ERROR: fetchedDependencies object was UNDEFINED. 
-                This means a dependency test (like 'cohort-skill-definition' or 'instrument-price-change-1d') 
-                failed to run or produced an invalid result.`
-            );
-        }
-
-        const cohortData = fetchedDependencies['cohort-skill-definition'];
-        if (!cohortData) {
-             throw new Error(
-                `[skilled-cohort-flow] DEPENDENCY ERROR: 'cohort-skill-definition' was missing. 
-                Check logs for errors in that calculation.`
-             );
-        }
-
-        // This logic is correct for 'cohort-skill-definition' output
-        if (cohortData && cohortData.skilled_user_ids) {
+        const cohortData = computed['cohort-skill-definition'];
+        if (cohortData) {
             (cohortData.skilled_user_ids || []).forEach(uid => this.cohortMap.set(String(uid), 'skilled'));
         }
-
-        this.priceChangeMap = fetchedDependencies['instrument-price-change-1d'];
-        if (!this.priceChangeMap) {
-             throw new Error(
-                `[skilled-cohort-flow] DEPENDENCY ERROR: 'instrument-price-change-1d' was missing. 
-                This is likely due to the worker bug for 'price' dependencies.`
-             );
-        }
-
         this.dependenciesLoaded = true;
     }
 
-    // --- THIS IS THE FIX (Part 2) ---
-    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
-        // Load dependencies *before* checking cohort
-        this._loadDependencies(fetchedDependencies);
-
-        if (!this.tickerMap) {
-            this.tickerMap = context.instrumentToTicker;
-        }
-
-        const cohortName = this.cohortMap.get(String(userId)); // Ensure string ID
-        if (cohortName !== 'skilled') {
-            return; // Not in skilled cohort
-        }
+    process(context) {
+        const { user, computed, mappings, math } = context;
+        const { extract } = math;
+        
+        this._loadDependencies(computed);
+        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
 
-        if (!todayPortfolio || !yesterdayPortfolio || !this.priceChangeMap || !this.tickerMap) {
-            return;
-        }
+        if (this.cohortMap.get(user.id) !== 'skilled') return;
+        
+        const priceChangeMap = computed['instrument-price-change-1d'];
+        if (!priceChangeMap) return;
 
-        const yPos = this._getPortfolioPositions(yesterdayPortfolio);
-        const tPos = this._getPortfolioPositions(todayPortfolio);
-        if (!yPos || !tPos) return;
+        const yPos = extract.getPositions(user.portfolio.yesterday, user.type);
+        const tPos = extract.getPositions(user.portfolio.today, user.type);
 
-        const yPosMap = new Map(yPos.map(p => [p.InstrumentID, p]));
-        const tPosMap = new Map(tPos.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()]);
 
-        for (const instrumentId of allInstrumentIds) {
-            if (!instrumentId) continue;
-
-            this._initFlowData(instrumentId);
-            const asset = this.assetFlows.get(instrumentId);
-
-            const yP = yPosMap.get(instrumentId);
-            const tP = tPosMap.get(instrumentId);
-
-            // Get $ flow
-            const yInvested = yP?.Invested || yP?.Amount || 0; 
-            const tInvested = tP?.Invested || tP?.Amount || 0;
-            
-            // Get position size (same as $ flow for these schemas)
-            const ySize = yP?.Invested || yP?.Amount || 0;
-            const tSize = tP?.Invested || tP?.Amount || 0;
-
-            if (yInvested > 0) {
-                asset.total_invested_yesterday += yInvested;
+        for (const instId of allInstrumentIds) {
+            if (!instId) continue;
+            this._initFlowData(instId);
+            const asset = this.assetFlows.get(instId);
 
-                const ticker = this.tickerMap[instrumentId];
-                const yPriceChange_pct = (ticker && this.priceChangeMap[ticker]) 
-                                            ? this.priceChangeMap[ticker].price_change_1d_pct 
-                                            : 0;
+            const yWeight = extract.getPositionWeight(yPosMap.get(instId), user.type);
+            const tWeight = extract.getPositionWeight(tPosMap.get(instId), user.type);
 
-                const yPriceChange_decimal = (yPriceChange_pct || 0) / 100.0;
-                asset.price_change_yesterday += yPriceChange_decimal * yInvested;
-                
-                // Track yesterday's size and user count
-                asset.total_pos_size_yesterday += ySize;
+            if (yWeight > 0) {
+                asset.total_invested_yesterday += yWeight;
+                const ticker = mappings.instrumentToTicker[instId];
+                const priceChange = (ticker && priceChangeMap[ticker]) ? priceChangeMap[ticker].change_1d_pct : 0;
+                asset.price_change_yesterday += (priceChange / 100.0) * yWeight;
+                asset.total_pos_size_yesterday += yWeight;
                 asset.user_count_yesterday++;
             }
-            if (tInvested > 0) {
-                asset.total_invested_today += tInvested;
-                asset.user_count_today++; // Count users holding today
-                
-                // Track today's size
-                asset.total_pos_size_today += tSize;
+            if (tWeight > 0) {
+                asset.total_invested_today += tWeight;
+                asset.user_count_today++;
+                asset.total_pos_size_today += tWeight;
             }
         }
     }
-    // --- END FIX (Part 2) ---
 
-    // --- THIS IS THE FIX (Part 3) ---
     async getResult() {
-        if (!this.tickerMap) {
-            return {}; 
-        }
-
+        if (!this.tickerMap) return {};
         const finalResult = {};
-
-        for (const [instrumentId, data] of this.assetFlows.entries()) {
-            const ticker = this.tickerMap[instrumentId];
+        for (const [instId, data] of this.assetFlows.entries()) {
+            const ticker = this.tickerMap[instId];
             if (!ticker) continue;
-
-            const { 
-                total_invested_yesterday, total_invested_today, price_change_yesterday,
-                // Destructure the restored fields
-                total_pos_size_yesterday, total_pos_size_today,
-                user_count_yesterday, user_count_today
-            } = data;
-
-            let net_flow_percentage = 0;
-            let flow_contribution = 0;
-
-            if (total_invested_yesterday > 0) {
-                const avg_price_change_decimal = (price_change_yesterday === 0) ? 0 : (price_change_yesterday / total_invested_yesterday);
-                const price_adjusted_yesterday_value = total_invested_yesterday * (1 + avg_price_change_decimal);
-
-                flow_contribution = total_invested_today - price_adjusted_yesterday_value;
-                net_flow_percentage = (flow_contribution / total_invested_yesterday) * 100;
-            } else if (total_invested_today > 0) {
-                flow_contribution = total_invested_today;
-                net_flow_percentage = Infinity;
-            }
-
-            // Restore the calculation logic for conviction
-            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(net_flow_percentage) && isFinite(flow_contribution)) {
-                finalResult[ticker] = {
-                    net_flow_pct: net_flow_percentage,
-                    net_flow_contribution: flow_contribution,
-                    avg_position_change_pct: avg_position_change_pct, // Now correctly calculated
-                    user_count: user_count_today
-                };
+            // ... (Same calculation logic as before, just boilerplate math)
+            let net_flow = 0, flow_contrib = 0;
+            if (data.total_invested_yesterday > 0) {
+                const avg_change = data.price_change_yesterday / data.total_invested_yesterday;
+                const adjusted_y = data.total_invested_yesterday * (1 + avg_change);
+                flow_contrib = data.total_invested_today - adjusted_y;
+                net_flow = (flow_contrib / data.total_invested_yesterday) * 100;
+            } else if (data.total_invested_today > 0) {
+                flow_contrib = data.total_invested_today;
+                net_flow = Infinity;
             }
+            
+            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;
+
+            finalResult[ticker] = {
+                net_flow_pct: isFinite(net_flow) ? net_flow : 0,
+                net_flow_contribution: isFinite(flow_contrib) ? flow_contrib : 0,
+                avg_position_change_pct: isFinite(avg_pos_change) ? avg_pos_change : 0,
+                user_count: data.user_count_today
+            };
         }
-
         return finalResult;
     }
-    // --- END FIX (Part 3) ---
 
     reset() {
         this.assetFlows.clear();
         this.cohortMap.clear();
-        this.tickerMap = null;
         this.dependenciesLoaded = false;
-        this.priceChangeMap = null;
+        this.tickerMap = null;
     }
 }
 module.exports = SkilledCohortFlow;

package/calculations/gem/skilled-unskilled-divergence.js

@@ -1,17 +1,10 @@
 /**
  * @fileoverview GEM Product Line (Pass 3)
- *
- * This 'meta' calculation answers: "What is the net flow
- * divergence between Skilled and Unskilled cohorts?"
+ * REFACTORED: Uses context.math.signals and process(context).
  */
 class SkilledUnskilledDivergence {
+    constructor() { this.result = {}; }
 
-    // --- STANDARD 2: ADDED ---
-    constructor() {
-        this.result = {};
-    }
-
-    /** Statically defines metadata */
     static getMetadata() {
         return {
             type: 'meta',
@@ -22,17 +15,8 @@ class SkilledUnskilledDivergence {
         };
     }
 
-    /** Statically declare dependencies */
-    static getDependencies() {
-        return [
-            'skilled-cohort-flow',    // from gem (Pass 2)
-            'unskilled-cohort-flow'   // from gem (Pass 2)
-        ];
-    }
-    
-    /**
-     * Defines the output schema for this calculation.
-     */
+    static getDependencies() { return ['skilled-cohort-flow', 'unskilled-cohort-flow']; }
+
     static getSchema() {
         const tickerSchema = {
             "type": "object",
@@ -43,71 +27,32 @@ class SkilledUnskilledDivergence {
             },
             "required": ["skilled_flow_pct", "unskilled_flow_pct", "flow_divergence_score"]
         };
-        
-        return {
-            "type": "object",
-            "description": "Tracks the net % flow divergence between skilled and unskilled cohorts.",
-            "patternProperties": { "^.*$": tickerSchema },
-            "additionalProperties": tickerSchema
-        };
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
 
-    /**
-     * This is a 'meta' calculation. It runs once.
-     */
-    // --- STANDARD 1: UPDATED SIGNATURE (added rootData) ---
-    async process(dateStr, rootData, dependencies, config, fetchedDependencies) {
-        const { logger } = dependencies;
-        
-        const skilledFlow = fetchedDependencies['skilled-cohort-flow'];
-        const unskilledFlow = fetchedDependencies['unskilled-cohort-flow'];
-
-        if (!skilledFlow || !unskilledFlow) {
-            logger.log('WARN', `[gem/skilled-unskilled-divergence] Missing dependencies for ${dateStr}.`);
-            // --- STANDARD 2: DO NOT RETURN ---
-            this.result = {};
-            return;
-        }
-
-        const allTickers = new Set([
-            ...Object.keys(skilledFlow),
-            ...Object.keys(unskilledFlow)
-        ]);
+    process(context) {
+        const { computed, math } = context;
+        const { signals } = math;
 
+        const tickers = signals.getUnionKeys(computed, ['skilled-cohort-flow', 'unskilled-cohort-flow']);
         const result = {};
 
-        for (const ticker of allTickers) {
-            const skilledData = skilledFlow[ticker];
-            const unskilledData = unskilledFlow[ticker];
-            
-            // Get net_flow_pct
-            const skilled_flow_pct = skilledData?.net_flow_pct || 0;
-            const unskilled_flow_pct = unskilledData?.net_flow_pct || 0;
+        for (const ticker of tickers) {
+            const skilled = signals.getMetric(computed, 'skilled-cohort-flow', ticker, 'net_flow_pct');
+            const unskilled = signals.getMetric(computed, 'unskilled-cohort-flow', ticker, 'net_flow_pct');
             
-            // Only include assets that are actively being traded
-            if (skilled_flow_pct === 0 && unskilled_flow_pct === 0) {
-                continue;
-            }
+            if (skilled === 0 && unskilled === 0) continue;
 
             result[ticker] = {
-                skilled_flow_pct: skilled_flow_pct,
-                unskilled_flow_pct: unskilled_flow_pct,
-                flow_divergence_score: skilled_flow_pct - unskilled_flow_pct
+                skilled_flow_pct: skilled,
+                unskilled_flow_pct: unskilled,
+                flow_divergence_score: signals.divergence(skilled, unskilled)
             };
         }
-        
-        // --- STANDARD 2: SET STATE, DO NOT RETURN ---
         this.result = result;
     }
 
-    // --- STANDARD 2: ADDED ---
-    async getResult(fetchedDependencies) {
-        return this.result;
-    }
-
-    // --- STANDARD 2: ADDED ---
-    reset() {
-        this.result = {};
-    }
+    async getResult() { return this.result; }
+    reset() { this.result = {}; }
 }
 module.exports = SkilledUnskilledDivergence;