aiden-shared-calculations-unified 1.0.84 → 1.0.87

package/calculations/core/users-processed.js

@@ -1,42 +1,26 @@
 /**
  * @fileoverview Calculation (Pass 1) for total users processed.
- *
- * This metric is a simple counter that tracks the total number
- * of users processed and the breakdown by user type (Normal/Speculator).
- *
- * It is a fundamental metric for sanity-checking the data stream.
+ * REFACTORED: Uses context.user.type.
  */
 class UsersProcessed {
     constructor() {
         this.totalUsers = 0;
         this.normalUsers = 0;
         this.speculatorUsers = 0;
-        this.totalValue = 0;
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'standard',
-            rootDataDependencies: ['portfolio'], // Needs summary
+            rootDataDependencies: ['portfolio'],
             isHistorical: false,
             userType: 'all',
-            category: 'core_metrics' // A fundamental metric
+            category: 'core_metrics'
         };
     }
 
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
         return {
             "type": "object",
@@ -44,47 +28,29 @@ class UsersProcessed {
             "properties": {
                 "total_users": { "type": "number" },
                 "normal_users": { "type": "number" },
-                "speculator_users": { "type": "number" },
-                "total_portfolio_value": { "type": "number" }
+                "speculator_users": { "type": "number" }
             },
-            "required": ["total_users", "normal_users", "speculator_users", "total_portfolio_value"]
+            "required": ["total_users", "normal_users", "speculator_users"]
         };
     }
 
-    // --- UPDATED SIGNATURE ---
-    process(
-        todayPortfolio, 
-        yesterdayPortfolio, 
-        userId, 
-        context, 
-        todayInsights, 
-        yesterdayInsights, 
-        todaySocialPostInsights, 
-        yesterdaySocialPostInsights,
-        todayHistory
-    ) {
+    process(context) {
+        const { user } = context;
+        
         this.totalUsers++;
         
-        // Use the userType from the context, which is set by the orchestrator
-        if (context.userType === 'speculator') {
+        if (user.type === 'speculator') {
             this.speculatorUsers++;
         } else {
             this.normalUsers++;
         }
-
-        // --- UPDATED ---
-        const portfolioValue = todayPortfolio?.Summary?.PortfolioValue;
-        if (typeof portfolioValue === 'number') {
-            this.totalValue += portfolioValue;
-        }
     }
 
     getResult() {
         return {
             total_users: this.totalUsers,
             normal_users: this.normalUsers,
-            speculator_users: this.speculatorUsers,
-            total_portfolio_value: this.totalValue
+            speculator_users: this.speculatorUsers
         };
     }
 
@@ -92,7 +58,6 @@ class UsersProcessed {
         this.totalUsers = 0;
         this.normalUsers = 0;
         this.speculatorUsers = 0;
-        this.totalValue = 0;
     }
 }
 

package/calculations/gauss/cohort-capital-flow.js

@@ -1,42 +1,15 @@
 /**
  * @fileoverview GAUSS Product Line (Pass 3)
- *
- * This 'standard' calculation streams all user portfolios, tags
- * each user with their "Gauss" cohort (from Pass 2), and calculates
- * the price-adjusted capital flow for each cohort, per asset.
- *
- * This is the primary input for the final Pass 4 signal.
- *
- * --- REVISED 11/12/2025 ---
- * - Removed dependency on 'insights' data.
- * - Added dependency on 'instrument-price-change-1d' (Pass 1 meta calc).
- * - Price adjustment logic now uses the reliable 1-day price change
- * from the new dependency.
- * - **FIXED:** getResult() was wrapping the ticker map in an "assets" object,
- * causing a schema validation failure in the test harness.
- * --------------------------
+ * REFACTORED: Implemented getResult logic and mapping caching.
  */
-// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
-
-
 class CohortCapitalFlow {
     constructor() {
-        // { [cohortName]: Map<instrumentId, { flow_data... }> }
         this.cohortFlows = new Map();
-        // { [userId]: "cohortName" }
         this.cohortMap = new Map();
-        // --- STANDARD 0: RENAMED ---
-        this.tickerMap = null;
+        this.tickerMap = null; // Cache mappings
         this.dependenciesLoaded = false;
-        
-        // --- NEW ---
-        // This will store the { [ticker]: { price_change_1d_pct: 5.5 } } map
-        this.priceChangeMap = null; 
     }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
         const flowSchema = {
             "type": "object",
@@ -46,156 +19,84 @@ class CohortCapitalFlow {
             },
             "required": ["net_flow_percentage", "net_flow_contribution"]
         };
-        
-        const cohortSchema = {
-            "type": "object",
-            "description": "Price-adjusted capital flow for all assets for a specific cohort.",
-            "patternProperties": { "^.*$": flowSchema }, // Ticker
-            "additionalProperties": flowSchema
-        };
-
         return {
             "type": "object",
-            "description": "Contains a map of cohort names to their asset flow data.",
-            "patternProperties": {
-                "^.*$": cohortSchema // Cohort Name
-            },
-            "additionalProperties": cohortSchema
+            "patternProperties": { "^.*$": { "type": "object", "patternProperties": { "^.*$": flowSchema } } }
         };
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'standard',
             rootDataDependencies: ['portfolio', 'history'],
-            isHistorical: true, // Needs T-1 portfolio for flow
+            isHistorical: true,
             userType: 'all',
             category: 'gauss'
         };
     }
 
-    /**
-     * Statically declare dependencies.
-     */
     static getDependencies() {
-        return [
-            'cohort-definer', // from gauss (Pass 2)
-            'instrument-price-change-1d' // from core (Pass 1)
-        ];
-    }
-
-   _getPortfolioPositions(portfolio) {
-        // FIX: Check for Normal User (AggregatedPositions) OR Speculator (PublicPositions)
-        if (portfolio?.AggregatedPositions) {
-            return portfolio.AggregatedPositions; // Normal User
-        }
-        if (portfolio?.PublicPositions) {
-            return portfolio.PublicPositions; // Speculator User
-        }
-        return [];
+        return ['cohort-definer', 'instrument-price-change-1d'];
     }
 
     _initFlowData(cohortName, instrumentId) {
-        if (!this.cohortFlows.has(cohortName)) {
-            this.cohortFlows.set(cohortName, new Map());
-        }
+        if (!this.cohortFlows.has(cohortName)) this.cohortFlows.set(cohortName, new Map());
         if (!this.cohortFlows.get(cohortName).has(instrumentId)) {
             this.cohortFlows.get(cohortName).set(instrumentId, {
-                total_invested_yesterday: 0,
-                total_invested_today: 0,
-                price_change_yesterday: 0, // Weighted sum
+                total_invested_yesterday: 0, total_invested_today: 0, price_change_yesterday: 0
             });
         }
     }
     
-    /**
-     * Loads dependencies into memory on the first process() call.
-     */
-    _loadDependencies(fetchedDependencies) {
+    _loadDependencies(computed) {
         if (this.dependenciesLoaded) return;
-        
-        // 1. Load Cohort Definitions
-        const cohortData = fetchedDependencies['cohort-definer'];
+        const cohortData = computed['cohort-definer'];
         if (cohortData) {
             for (const [cohortName, userIds] of Object.entries(cohortData)) {
-                if (Array.isArray(userIds)) {
-                    for (const userId of userIds) {
-                        this.cohortMap.set(userId, cohortName);
-                    }
-                }
+                if (Array.isArray(userIds)) userIds.forEach(uid => this.cohortMap.set(uid, cohortName));
             }
         }
-        
-        // 2. Load Price Change Data
-        this.priceChangeMap = fetchedDependencies['instrument-price-change-1d'] || {};
-
         this.dependenciesLoaded = true;
     }
 
-    process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, fetchedDependencies) {
-        this._loadDependencies(fetchedDependencies);
-        
-        // --- STANDARD 0: FIXED ---
-        if (!this.tickerMap) {
-            this.tickerMap = context.instrumentToTicker;
-        }
+    process(context) {
+        const { user, computed, mappings, math } = context;
+        const { extract } = math;
 
-        const cohortName = this.cohortMap.get(userId);
-        if (!cohortName) {
-            return; // Not in a defined cohort, skip.
-        }
-        
-        if (!todayPortfolio || !yesterdayPortfolio) {
-            return;
-        }
+        // Cache mapping for getResult phase
+        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
 
-        const yPos = this._getPortfolioPositions(yesterdayPortfolio);
-        const tPos = this._getPortfolioPositions(todayPortfolio);
-
-        if (!yPos || !tPos) {
-            return; // Must have AggregatedPositions for both days
-        }
+        this._loadDependencies(computed);
         
-        if (!this.priceChangeMap) {
-            return; // Cannot calculate price-adjusted flow
-        }
+        const cohortName = this.cohortMap.get(user.id);
+        if (!cohortName) return;
         
-        // --- STANDARD 0: Check must be done before use ---
-        if (!this.tickerMap) {
-            return; // Cannot map instruments to tickers
-        }
+        const priceChangeMap = computed['instrument-price-change-1d'];
+        if (!priceChangeMap) return;
 
-        const yPosMap = new Map(yPos.map(p => [p.InstrumentID, p]));
-        const tPosMap = new Map(tPos.map(p => [p.InstrumentID, p]));
+        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 => [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(cohortName, instrumentId);
-            const asset = this.cohortFlows.get(cohortName).get(instrumentId);
+        for (const instId of allInstrumentIds) {
+            if (!instId) continue;
             
-            const yP = yPosMap.get(instrumentId);
-            const tP = tPosMap.get(instrumentId);
+            this._initFlowData(cohortName, instId);
+            const asset = this.cohortFlows.get(cohortName).get(instId);
             
-            const yInvested = yP?.Invested || 0; 
-            const tInvested = tP?.Invested || 0;
+            const yInvested = extract.getPositionWeight(yPosMap.get(instId), user.type);
+            const tInvested = extract.getPositionWeight(tPosMap.get(instId), user.type);
 
             if (yInvested > 0) {
                 asset.total_invested_yesterday += yInvested;
                 
-                // --- STANDARD 0: SIMPLIFIED ---
-                const ticker = this.tickerMap[instrumentId];
-                const yPriceChange_pct = (ticker && this.priceChangeMap[ticker]) 
-                                            ? this.priceChangeMap[ticker].price_change_1d_pct 
-                                            : 0;
+                const ticker = this.tickerMap[instId];
+                const yPriceChange_pct = (ticker && priceChangeMap[ticker]) ? priceChangeMap[ticker].change_1d_pct : 0;
                 
-                const yPriceChange_decimal = (yPriceChange_pct || 0) / 100.0;
-                
-                asset.price_change_yesterday += yPriceChange_decimal * yInvested; // Weighted sum
+                asset.price_change_yesterday += (yPriceChange_pct / 100.0) * yInvested;
             }
             if (tInvested > 0) {
                 asset.total_invested_today += tInvested;
@@ -203,62 +104,42 @@ class CohortCapitalFlow {
         }
     }
 
-    // --- THIS IS THE FIX ---
     async getResult() {
-        // --- STANDARD 0: REMOVED forbidden data load ---
-
-        // Failsafe check
-        if (!this.tickerMap) {
-            return {}; // process() must run first to set mappings
-        }
-
         const finalResult = {};
+        
+        if (!this.tickerMap) return {}; // Should be populated by process()
 
-        for (const [cohortName, assetMap] of this.cohortFlows.entries()) {
-            const cohortAssets = {};
-            for (const [instrumentId, data] of assetMap.entries()) {
-                // --- STANDARD 0: SIMPLIFIED ---
-                const ticker = this.tickerMap[instrumentId];
-                if (!ticker) continue;
+        for (const [cohortName, assetsMap] of this.cohortFlows.entries()) {
+            finalResult[cohortName] = {};
+            
+            for (const [instId, data] of assetsMap.entries()) {
+                const ticker = this.tickerMap[instId] || `id_${instId}`;
                 
-                const { total_invested_yesterday, total_invested_today, price_change_yesterday } = data;
+                // Logic: Flow = Today - (Yesterday * (1 + PriceChange))
+                // This isolates the capital movement from the price action.
+                const expectedToday = data.total_invested_yesterday + data.price_change_yesterday;
+                const netFlow = data.total_invested_today - expectedToday;
                 
-                if (total_invested_yesterday > 0) {
-                    const avg_price_change_decimal = price_change_yesterday / total_invested_yesterday;
-                    const price_adjusted_yesterday_value = total_invested_yesterday * (1 + avg_price_change_decimal);
-                    const flow_contribution = total_invested_today - price_adjusted_yesterday_value;
-                    const net_flow_percentage = (flow_contribution / total_invested_yesterday) * 100;
-                    
-                    if (isFinite(net_flow_percentage) && isFinite(flow_contribution)) {
-                        cohortAssets[ticker] = {
-                            net_flow_percentage: net_flow_percentage,
-                            net_flow_contribution: flow_contribution
-                        };
-                    }
-                } else if (total_invested_today > 0) {
-                    cohortAssets[ticker] = {
-                        net_flow_percentage: Infinity, // Represents pure inflow
-                        net_flow_contribution: total_invested_today
-                    };
-                }
+                // Avoid divide by zero or noise for very small numbers
+                const denominator = Math.max(1, (data.total_invested_yesterday + data.total_invested_today) / 2);
+                const netFlowPct = (netFlow / denominator) * 100;
+
+                finalResult[cohortName][ticker] = {
+                    net_flow_percentage: netFlowPct,
+                    net_flow_contribution: netFlow
+                };
             }
-            // Was: finalResult[cohortName] = { assets: cohortAssets };
-            // Is:
-            finalResult[cohortName] = cohortAssets;
         }
         
         return finalResult;
     }
-    // --- END FIX ---
 
     reset() {
         this.cohortFlows.clear();
         this.cohortMap.clear();
-        // --- STANDARD 0: RENAMED ---
         this.tickerMap = null;
         this.dependenciesLoaded = false;
-        this.priceChangeMap = null;
     }
 }
 
-module.exports = CohortCapitalFlow;
+module.exports = CohortCapitalFlow;