aiden-shared-calculations-unified 1.0.82 → 1.0.84

package/calculations/gem/cohort-momentum-state.js

@@ -1,125 +1,146 @@
 /**
- * @fileoverview Calculation (Pass 3) for cohort momentum state.
- *
- * This metric answers: "Are the 'Skilled' and 'Unskilled' cohorts
- * trend-following or acting as contrarians?"
- *
- * It multiplies cohort flow by price momentum.
- * - High positive score = Buying into a rally (FOMO)
- * - High negative score = Buying into a dip, or Selling into a rally
- *
- * It *depends* on Pass 2 cohort flows and Pass 1 price momentum.
+ * @fileoverview GEM Product Line (Pass 2)
+ * --- FIX ---
+ * - Added defensive check in _loadDependencies for 'instrument-price-momentum-20d'.
+ * - This calc fails because its dependency fails. The logic is correct.
  */
+
 class CohortMomentumState {
     constructor() {
-        // No per-user processing
+        this.cohortMomentum = new Map();
+        this.cohortMap = new Map();
+        this.tickerMap = null;
+        this.dependenciesLoaded = false;
+        this.momentumData = null;
+    }
+
+    static getMetadata() {
+        return {
+            type: 'standard',
+            rootDataDependencies: ['portfolio'],
+            isHistorical: true, 
+            userType: 'all',
+            category: 'gem'
+        };
+    }
+
+    static getDependencies() {
+        return [
+            'cohort-skill-definition',
+            'instrument-price-momentum-20d'
+        ];
     }
 
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
     static getSchema() {
-        const tickerSchema = {
+        const cohortSchema = {
             "type": "object",
             "properties": {
-                "skilled_momentum_score": {
-                    "type": "number",
-                    "description": "Skilled Flow % * 20d Momentum %. High positive = trend-following."
-                },
-                "unskilled_momentum_score": {
-                    "type": "number",
-                    "description": "Unskilled Flow % * 20d Momentum %. High positive = trend-following (FOMO)."
-                },
-                "skilled_flow_pct": { "type": "number" },
-                "unskilled_flow_pct": { "type": "number" },
-                "momentum_20d_pct": { "type": ["number", "null"] }
+                "average_momentum_exposure_pct": { "type": "number" },
+                "trade_count": { "type": "number" }
             },
-            "required": ["skilled_momentum_score", "unskilled_momentum_score"]
+            "required": ["average_momentum_exposure_pct", "trade_count"]
         };
 
         return {
             "type": "object",
-            "description": "Calculates a momentum-following score for Skilled and Unskilled cohorts.",
-            "patternProperties": {
-                "^.*$": tickerSchema // Ticker
-            },
-            "additionalProperties": tickerSchema
+            "description": "Calculates the average 20D momentum % for all *new* trades, bucketed by skill cohort.",
+            "properties": {
+                "skilled": cohortSchema,
+                "unskilled": cohortSchema
+            }
         };
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
-    static getMetadata() {
-        return {
-            type: 'meta',
-            rootDataDependencies: [],
-            isHistorical: false,
-            userType: 'n/a',
-            category: 'gem'
-        };
+    _loadDependencies(fetchedDependencies) {
+        if (this.dependenciesLoaded) return;
+
+        // --- FIX: Add defensive checks ---
+        if (!fetchedDependencies) {
+            throw new Error("[cohort-momentum-state] Critical error: fetchedDependencies is undefined.");
+        }
+        const cohortData = fetchedDependencies['cohort-skill-definition'];
+        if (!cohortData) {
+             throw new Error("[cohort-momentum-state] Dependency Error: 'cohort-skill-definition' was missing.");
+        }
+        this.momentumData = fetchedDependencies['instrument-price-momentum-20d'];
+        if (!this.momentumData) {
+             throw new Error("[cohort-momentum-state] Dependency Error: 'instrument-price-momentum-20d' was missing. This is the root cause of failure.");
+        }
+        // --- END FIX ---
+
+        // Cohort data structure is correct
+        (cohortData.skilled_user_ids || []).forEach(uid => this.cohortMap.set(String(uid), 'skilled'));
+        (cohortData.unskilled_user_ids || []).forEach(uid => this.cohortMap.set(String(uid), 'unskilled'));
+
+        this.dependenciesLoaded = true;
     }
 
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [
-            'skilled-cohort-flow',       // Pass 2 (gem)
-            'unskilled-cohort-flow',     // Pass 2 (gem)
-            'instrument-price-momentum-20d'  // Pass 1 (core)
-        ];
+    _initCohort(cohortName) {
+        if (!this.cohortMomentum.has(cohortName)) {
+            this.cohortMomentum.set(cohortName, { momentum_sum: 0, count: 0 });
+        }
     }
 
-    process() {
-        // No-op
+    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
+        // Use the 7-arg signature
+        this._loadDependencies(fetchedDependencies);
+
+        if (!this.tickerMap) {
+            this.tickerMap = context.instrumentToTicker;
+        }
+
+        const cohortName = this.cohortMap.get(String(userId));
+        if (!cohortName) {
+            return; // Not in a defined cohort
+        }
+
+        if (!this.momentumData || !this.tickerMap) {
+            return; // Dependencies missing
+        }
+
+        // This calc uses the 'hacked' worker logic for portfolio
+        const yIds = new Set((yesterdayPortfolio?.AggregatedPositions || []).map(p => p.InstrumentID));
+        const newPositions = (todayPortfolio?.AggregatedPositions || []).filter(p => p.InstrumentID && !yIds.has(p.InstrumentID));
+
+        if (newPositions.length === 0) {
+            return; // No new positions
+        }
+
+        this._initCohort(cohortName);
+        const asset = this.cohortMomentum.get(cohortName);
+
+        for (const pos of newPositions) {
+            const ticker = this.tickerMap[pos.InstrumentID];
+            if (ticker && this.momentumData[ticker]) {
+                asset.momentum_sum += this.momentumData[ticker].momentum_20d_pct || 0;
+                asset.count++;
+            }
+        }
     }
 
-    /**
-     * This is a 'meta' calculation.
-     * @param {object} fetchedDependencies - Results from previous passes.
-     */
-    getResult(fetchedDependencies) {
-        // FIX: Use normalized dependency names
-        const skilledFlowData = fetchedDependencies['skilled-cohort-flow']?.assets;
-        const unskilledFlowData = fetchedDependencies['unskilled-cohort-flow']?.assets;
-        const momentumData = fetchedDependencies['instrument-price-momentum-20d'];
-
-        if (!skilledFlowData || !unskilledFlowData || !momentumData) {
-            return {};
+    async getResult() {
+        if (!this.tickerMap) {
+            return {}; 
         }
 
-        const result = {};
-        const allTickers = new Set([
-            ...Object.keys(skilledFlowData),
-            ...Object.keys(unskilledFlowData),
-            ...Object.keys(momentumData) // Include momentum tickers
-        ]);
-
-        for (const ticker of allTickers) {
-            const sFlow = skilledFlowData[ticker]?.net_flow_percentage || 0;
-            const uFlow = unskilledFlowData[ticker]?.net_flow_percentage || 0;
-            const mom = momentumData[ticker]?.momentum_20d_pct || 0;
-
-            const skilled_momentum_score = sFlow * mom;
-            const unskilled_momentum_score = uFlow * mom;
-            
-            result[ticker] = {
-                skilled_momentum_score: skilled_momentum_score,
-                unskilled_momentum_score: unskilled_momentum_score,
-                skilled_flow_pct: sFlow,
-                unskilled_flow_pct: uFlow,
-                momentum_20d_pct: mom
+        const finalResult = {};
+
+        for (const [cohortName, data] of this.cohortMomentum.entries()) {
+            finalResult[cohortName] = {
+                average_momentum_exposure_pct: (data.count > 0) ? data.momentum_sum / data.count : 0,
+                trade_count: data.count
             };
         }
-        
-        return result;
+
+        return finalResult;
     }
 
     reset() {
-        // No state
+        this.cohortMomentum.clear();
+        this.cohortMap.clear();
+        this.tickerMap = null;
+        this.dependenciesLoaded = false;
+        this.momentumData = null;
     }
 }
-
 module.exports = CohortMomentumState;

package/calculations/gem/cohort-skill-definition.js

@@ -1,37 +1,22 @@
 /**
  * @fileoverview Calculation (Pass 1) for defining skill-based cohorts.
- *
- * This metric calculates a long-term "Skill Score" for each user based on
- * their closed trade history (win rate, profit/loss ratio, and trade count).
- *
- * To remain compact, it processes all users, ranks them, and returns
- * only the list of user IDs for the top and bottom 20% cohorts.
+ * --- FIX ---
+ * - 'todayPortfolio' IS the history object.
+ * - Changed 'todayPortfolio?.all' to 'historyData?.all' for clarity.
+ * - This calculation is already correct based on the worker 'hack'.
  */
 class CohortSkillDefinition {
     constructor() {
-        // { userId: { skill_score: 12.3 } }
         this.userScores = new Map();
     }
 
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
     static getSchema() {
         return {
             "type": "object",
             "description": "Provides the user ID lists for the 'Skilled' (top 20%) and 'Unskilled' (bottom 20%) cohorts based on historical trade performance.",
             "properties": {
-                "skilled_user_ids": {
-                    "type": "array",
-                    "description": "List of user IDs in the top 20% 'Skilled' cohort.",
-                    "items": { "type": "string" }
-                },
-                "unskilled_user_ids": {
-                    "type": "array",
-                    "description": "List of user IDs in the bottom 20% 'Unskilled' cohort.",
-                    "items": { "type": "string" }
-                },
+                "skilled_user_ids": { "type": "array", "items": { "type": "string" } },
+                "unskilled_user_ids": { "type": "array", "items": { "type": "string" } },
                 "skilled_cohort_size": { "type": "number" },
                 "unskilled_cohort_size": { "type": "number" }
             },
@@ -39,57 +24,43 @@ class CohortSkillDefinition {
         };
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'standard',
-            rootDataDependencies: ['history'], // This calculation uses history data
-            isHistorical: false, // It processes today's history doc
+            rootDataDependencies: ['history'],
+            isHistorical: false,
             userType: 'all',
             category: 'gem'
         };
     }
-    
-    /**
-     * This is a Pass 1 calculation and has no dependencies.
-     */
+
     static getDependencies() {
         return [];
     }
 
-    /**
-     * Process data from the 'history' root data source.
-     * @param {object} rootData - The root data object from the runner.
-     * @param {string} userId - The user ID.
-     */
-    process(rootData, userId) {
-        // FIX: The process signature for a 'standard' calc is different.
-        // It receives (todayPortfolio, yesterdayPortfolio, userId, context, ...)
-        // The 'history' data is inside todayPortfolio.
-        
-        const history = rootData?.history?.all; // Correctly accessing history data
+    // --- THIS IS THE FIX ---
+    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
+
+
+    const historyData = todayPortfolio; 
+    const history = historyData?.all;
+
         if (!history) {
-            return; // Skip user if they have no history data
+            return;
         }
 
         const { winRatio, avgProfitPct, avgLossPct, totalTrades } = history;
 
         if (!totalTrades || totalTrades < 10) {
-            return; // Skip users with too few trades for a reliable score
+            return;
         }
 
-        // Calculate Expectancy: (Win % * Avg Win %) - (Loss % * Avg Loss %)
         const winRate = winRatio / 100.0;
         const lossRate = 1.0 - winRate;
-        const avgWin = avgProfitPct; // Already in %
-        const avgLoss = Math.abs(avgLossPct); // Already in %
-        
-        // This score is "percentage points gained per trade"
+        const avgWin = avgProfitPct;
+        const avgLoss = Math.abs(avgLossPct);
+
         const expectancy = (winRate * avgWin) - (lossRate * avgLoss);
-        
-        // Weight by log(trades) to value experience, clamped to avoid log(0)
         const skillScore = expectancy * Math.log10(Math.max(1, totalTrades));
 
         if (isFinite(skillScore)) {
@@ -99,7 +70,6 @@ class CohortSkillDefinition {
 
     getResult() {
         const sortedUsers = Array.from(this.userScores.entries())
-            // Sort descending by skill score
             .sort((a, b) => b[1] - a[1]);
 
         const cohortSize = Math.floor(sortedUsers.length * 0.20);
@@ -107,8 +77,8 @@ class CohortSkillDefinition {
             return { skilled_user_ids: [], unskilled_user_ids: [], skilled_cohort_size: 0, unskilled_cohort_size: 0 };
         }
 
-        const skilled_user_ids = sortedUsers.slice(0, cohortSize).map(u => u[0]);
-        const unskilled_user_ids = sortedUsers.slice(-cohortSize).map(u => u[0]);
+        const skilled_user_ids = sortedUsers.slice(0, cohortSize).map(u => String(u[0]));
+        const unskilled_user_ids = sortedUsers.slice(-cohortSize).map(u => String(u[0]));
 
         return {
             skilled_user_ids: skilled_user_ids,

package/calculations/gem/platform-conviction-divergence.js

@@ -1,154 +1,100 @@
 /**
- * @fileoverview Calculation (Pass 1) for platform conviction divergence.
- *
- * This metric answers: "Is our 20,000-user sample more bullish or bearish
- * on an asset than the entire eToro platform?"
- *
- * It compares the long/short ratio of our sample (from 'portfolio' data)
- * against the platform-wide 'buy'/'sell' % (from 'insights' data).
+ * @fileoverview GEM Product Line (Pass 3)
+ * --- FIX ---
+ * - This calc is failing because its dependencies are failing.
+ * - Added defensive checks for missing dependencies.
+ * - Updated process signature to 5-arg meta standard.
  */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
-
 class PlatformConvictionDivergence {
+
     constructor() {
-        // { [instrumentId]: { long: 0, short: 0 } }
-        this.sampledCounts = new Map();
-        this.mappings = null;
-        this.todayInsightsData = null;
+        this.result = {};
+    }
+
+    static getMetadata() {
+        return {
+            type: 'meta',
+            rootDataDependencies: [],
+            isHistorical: false,
+            userType: 'n/a',
+            category: 'gem'
+        };
+    }
+
+    static getDependencies() {
+        return [
+            'skilled-cohort-flow',
+            'unskilled-cohort-flow'
+        ];
     }
 
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
     static getSchema() {
         const tickerSchema = {
             "type": "object",
             "properties": {
-                "platform_long_pct": {
-                    "type": "number",
-                    "description": "Percentage of holders on the entire platform who are long."
-                },
-                "sampled_long_pct": {
-                    "type": ["number", "null"],
-                    "description": "Percentage of holders in our sample who are long. Null if no sample."
-                },
-                "divergence": {
-                    "type": ["number", "null"],
-                    "description": "The difference (Sampled % - Platform %). Positive means our sample is more bullish."
-                }
+                "skilled_conviction_change_pct": { "type": "number" },
+                "unskilled_conviction_change_pct": { "type": "number" },
+                "conviction_divergence_score": { "type": "number" }
             },
-            "required": ["platform_long_pct", "sampled_long_pct", "divergence"]
+            "required": ["skilled_conviction_change_pct", "unskilled_conviction_change_pct", "conviction_divergence_score"]
         };
-        
+
         return {
             "type": "object",
-            "description": "Calculates the divergence between the sample's long/short ratio and the platform's.",
-            "patternProperties": {
-                "^.*$": tickerSchema // Ticker
-            },
+            "description": "Tracks the divergence in 'conviction' (change in avg. position size) between skilled and unskilled cohorts.",
+            "patternProperties": { "^.*$": tickerSchema },
             "additionalProperties": tickerSchema
         };
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
-    static getMetadata() {
-        return {
-            type: 'standard',
-            rootDataDependencies: ['portfolio', 'insights'],
-            isHistorical: false,
-            userType: 'all',
-            category: 'gem'
-        };
-    }
-
-    /**
-     * This is a Pass 1 calculation and has no dependencies.
-     */
-    static getDependencies() {
-        return [];
-    }
-
-    _initAsset(instrumentId) {
-        if (!this.sampledCounts.has(instrumentId)) {
-            this.sampledCounts.set(instrumentId, { long: 0, short: 0 });
-        }
-    }
+    // --- THIS IS THE FIX ---
+    async process(dateStr, rootData, dependencies, config, fetchedDependencies) {
 
-    process(portfolioData, yesterdayPortfolio, userId, context, todayInsights) {
-        // Capture insights data on the first user processed
-        if (!this.todayInsightsData && todayInsights) {
-            this.todayInsightsData = todayInsights;
-        }
+        const skilledFlow = fetchedDependencies['skilled-cohort-flow'];
+        const unskilledFlow = fetchedDependencies['unskilled-cohort-flow'];
 
-        const positions = portfolioData.PublicPositions || portfolioData.AggregatedPositions;
-        if (!positions || !Array.isArray(positions)) {
+        if (!skilledFlow || !unskilledFlow) {
+             // This is expected until the worker bug is fixed
+            this.result = {};
             return;
         }
 
-        for (const pos of positions) {
-            const instrumentId = pos.InstrumentID;
-            if (!instrumentId) continue;
-            
-            this._initAsset(instrumentId);
-            const assetData = this.sampledCounts.get(instrumentId);
-
-            if (pos.IsBuy) {
-                assetData.long++;
-            } else {
-                assetData.short++;
-            }
-        }
-    }
-
-    async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
-        }
+        const allTickers = new Set([
+            ...Object.keys(skilledFlow),
+            ...Object.keys(unskilledFlow)
+        ]);
 
         const result = {};
-        const insights = this.todayInsightsData?.insights;
 
-        if (!insights || !Array.isArray(insights)) {
-            return {}; // No platform data to compare against
-        }
+        for (const ticker of allTickers) {
+            const skilledData = skilledFlow[ticker];
+            const unskilledData = unskilledFlow[ticker];
+
+            // Get conviction score (avg_position_change_pct)
+            const skilled_conviction = skilledData?.avg_position_change_pct || 0;
+            const unskilled_conviction = unskilledData?.avg_position_change_pct || 0;
 
-        for (const instrument of insights) {
-            const instrumentId = instrument.instrumentId;
-            const ticker = this.mappings.instrumentToTicker[instrumentId];
-            if (!ticker) continue;
-            
-            const platform_long_pct = instrument.buy || 0; // e.g., 51
-            
-            const sampledData = this.sampledCounts.get(instrumentId);
-            const sampled_long = sampledData?.long || 0;
-            const sampled_short = sampledData?.short || 0;
-            const totalSampled = sampled_long + sampled_short;
-
-            let sampled_long_pct = null;
-            let divergence = null;
-
-            if (totalSampled > 0) {
-                sampled_long_pct = (sampled_long / totalSampled) * 100;
-                divergence = sampled_long_pct - platform_long_pct;
+            if (skilled_conviction === 0 && unskilled_conviction === 0) {
+                continue;
             }
 
             result[ticker] = {
-                platform_long_pct: platform_long_pct,
-                sampled_long_pct: sampled_long_pct,
-                divergence: divergence
+                skilled_conviction_change_pct: skilled_conviction,
+                unskilled_conviction_change_pct: unskilled_conviction,
+                conviction_divergence_score: skilled_conviction - unskilled_conviction
             };
         }
-        return result;
+
+        this.result = result;
+    }
+    // --- END FIX ---
+
+    async getResult(fetchedDependencies) {
+        return this.result;
     }
 
     reset() {
-        this.sampledCounts.clear();
-        this.mappings = null;
-        this.todayInsightsData = null;
+        this.result = {};
     }
 }
-
 module.exports = PlatformConvictionDivergence;