aiden-shared-calculations-unified 1.0.84 → 1.0.87

package/calculations/gem/unskilled-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 UnskilledCohortFlow {
     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 UnskilledCohortFlow {
     }
 
     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,206 +35,108 @@ class UnskilledCohortFlow {
             },
             "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 'Unskilled' cohort.",
-            "patternProperties": { "^.*$": tickerSchema },
-            "additionalProperties": tickerSchema
-        };
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
 
-    _getPortfolioPositions(portfolio) {
-        // --- FIX: Support both Normal (Aggregated) and Speculator (Public) ---
-        return portfolio?.AggregatedPositions || portfolio?.PublicPositions;
-    }
-
-    // --- 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) {
-            throw new Error(
-                `[unskilled-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(
-                `[unskilled-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.unskilled_user_ids) {
+        const cohortData = computed['cohort-skill-definition'];
+        if (cohortData) {
             (cohortData.unskilled_user_ids || []).forEach(uid => this.cohortMap.set(String(uid), 'unskilled'));
         }
-
-        this.priceChangeMap = fetchedDependencies['instrument-price-change-1d'];
-        if (!this.priceChangeMap) {
-             throw new Error(
-                `[unskilled-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) {
-        this._loadDependencies(fetchedDependencies);
-
-        if (!this.tickerMap) {
-            this.tickerMap = context.instrumentToTicker;
-        }
-
-        const cohortName = this.cohortMap.get(String(userId));
-        if (cohortName !== 'unskilled') {
-            return; // Not in unskilled 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) !== 'unskilled') 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;
+        for (const instId of allInstrumentIds) {
+            if (!instId) continue;
+            this._initFlowData(instId);
+            const asset = this.assetFlows.get(instId);
 
-            if (yInvested > 0) {
-                asset.total_invested_yesterday += yInvested;
+            const yWeight = extract.getPositionWeight(yPosMap.get(instId), user.type);
+            const tWeight = extract.getPositionWeight(tPosMap.get(instId), user.type);
 
-                const ticker = this.tickerMap[instrumentId];
-                const yPriceChange_pct = (ticker && this.priceChangeMap[ticker]) 
-                                            ? this.priceChangeMap[ticker].price_change_1d_pct 
-                                            : 0;
-
-                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;
+            if (tWeight > 0) {
+                asset.total_invested_today += tWeight;
                 asset.user_count_today++;
-                
-                // Track today's size
-                asset.total_pos_size_today += tSize;
+                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
-                };
+            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 = UnskilledCohortFlow;

package/calculations/helix/helix-contrarian-signal.js

@@ -1,49 +1,24 @@
 /**
  * @fileoverview HELIX Product Line (Pass 4)
- *
- * This is the final, stateless signal generator for the HELIX line.
- * It answers: "Are 'Winners' (in-profit) and 'Losers'
- * (in-loss) cohorts flowing in opposite directions?"
+ * REFACTORED: Uses context.math.signals and process(context).
  */
 class HelixContrarianSignal {
+    constructor() { this.result = {}; }
 
-    // --- STANDARD 2: ADDED ---
-    constructor() {
-        this.result = {};
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
         const tickerSchema = {
             "type": "object",
             "properties": {
-                "signal": {
-                    "type": "string",
-                    "enum": ["Strong Contrarian", "Contrarian", "Neutral", "Consensus"]
-                },
-                "helix_score": {
-                    "type": "number",
-                    "description": "Divergence score (-10 to +10). Positive = Contrarian (Winners sell, Losers buy), Negative = Consensus (Both buy/sell)."
-                },
+                "signal": { "type": "string" },
+                "helix_score": { "type": "number" },
                 "winner_net_flow": { "type": "number" },
                 "loser_net_flow": { "type": "number" }
             },
-            "required": ["signal", "helix_score", "winner_net_flow", "loser_net_flow"]
-        };
-        
-        return {
-            "type": "object",
-            "description": "Generates a final contrarian signal based on Winner vs. Loser flow.",
-            "patternProperties": { "^.*$": tickerSchema },
-            "additionalProperties": tickerSchema
+            "required": ["signal", "helix_score"]
         };
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'meta',
@@ -54,109 +29,40 @@ class HelixContrarianSignal {
         };
     }
 
-    /**
-     * Statically declare dependencies.
-     */
     static getDependencies() {
-        return [
-            'winner-loser-flow',     // from helix (Pass 2)
-            'herd-consensus-score'   // from helix (Pass 2)
-        ];
+        return ['winner-loser-flow', 'herd-consensus-score'];
     }
     
-    /**
-     * Simple tanh normalization. Scales any number to a -10 to +10 range.
-     */
-    _normalize(score) {
-        // Scale input score to tune sensitivity
-        // A score of 50 will be ~9.9 (strong signal)
-        // A score of 20 will be ~9.6
-        // A score of 10 will be ~7.6
-        return Math.tanh(score / 10.0) * 10;
-    }
-
-    /**
-     * This is a 'meta' calculation. It runs once.
-     */
-    // --- STANDARD 1: UPDATED SIGNATURE (added rootData) ---
-    async process(dateStr, rootData, dependencies, config, fetchedDependencies) {
-        const { logger } = dependencies;
+    process(context) {
+        const { computed, math } = context;
+        const { signals } = math;
         
-        const cohortFlows = fetchedDependencies['winner-loser-flow'];
-        const herdConviction = fetchedDependencies['herd-consensus-score'];
-
-        if (!cohortFlows || !herdConviction) {
-            logger.log('WARN', `[helix/helix-contrarian-signal] Missing dependencies for ${dateStr}.`);
-            // --- STANDARD 2: DO NOT RETURN ---
-            this.result = {};
-            return;
-        }
-
-        const allTickers = new Set([
-            ...Object.keys(cohortFlows),
-            ...Object.keys(herdConviction)
-        ]);
-
+        const tickers = signals.getUnionKeys(computed, ['winner-loser-flow', 'herd-consensus-score']);
         const result = {};
 
-        for (const ticker of allTickers) {
-            const flow = cohortFlows[ticker];
-            const conviction = herdConviction[ticker];
+        for (const ticker of tickers) {
+            const winner_flow = signals.getMetric(computed, 'winner-loser-flow', ticker, 'net_winner_flow');
+            const loser_flow = signals.getMetric(computed, 'herd-consensus-score', ticker, 'herd_conviction_score');
 
-            // 1. Get Winner Flow (using net_winner_flow)
-            const winner_flow = flow?.net_winner_flow || 0;
-            
-            // 2. Get Loser Flow (using herd_conviction_score)
-            // This is a proxy for "Loser Flow".
-            // If conviction > 0, losers are buying.
-            // If conviction < 0, losers are selling.
-            const loser_flow = conviction?.herd_conviction_score || 0;
-
-            // --- Signal Logic ---
-            // A contrarian signal (positive score) happens when:
-            // 1. Winners SELL (flow < 0) and Losers BUY (flow > 0)
-            //
-            // A consensus signal (negative score) happens when:
-            // 2. Winners BUY (flow > 0) and Losers BUY (flow > 0)
-            // 3. Winners SELL (flow < 0) and Losers SELL (flow < 0)
-            
-            // We can simplify this:
-            // Score = Loser Flow - Winner Flow
-            //
-            // Case 1: Loser (Buy, +50) - Winner (Sell, -20) = +70 (Strong Contrarian)
-            // Case 2: Loser (Buy, +50) - Winner (Buy, +20)  = +30 (Weak Contrarian)
-            // Case 3: Loser (Sell, -50) - Winner (Sell, -20) = -30 (Consensus)
-            // Case 4: Loser (Sell, -50) - Winner (Buy, +20)  = -70 (Strong Consensus)
-            
             const divergence = loser_flow - winner_flow;
-            const helix_score = this._normalize(divergence);
+            const helix_score = signals.normalizeTanh(divergence, 10, 10.0);
 
             let signal = "Neutral";
-            if (helix_score > 7.5) signal = "Strong Contrarian"; // Losers buying, Winners selling
+            if (helix_score > 7.5) signal = "Strong Contrarian";
             else if (helix_score > 2.5) signal = "Contrarian";
-            else if (helix_score < -2.5) signal = "Consensus"; // Both moving same way
+            else if (helix_score < -2.5) signal = "Consensus";
 
             result[ticker] = {
                 signal: signal,
                 helix_score: helix_score,
                 winner_net_flow: winner_flow,
-                loser_net_flow: loser_flow // Using conviction as flow proxy
+                loser_net_flow: loser_flow
             };
         }
-        
-        // --- 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 = HelixContrarianSignal;