aiden-shared-calculations-unified 1.0.86 → 1.0.87

package/calculations/core/platform-buy-sell-sentiment.js

@@ -1,156 +1,73 @@
 /**
- * @fileoverview Calculation (Pass 1) for daily buy/sell sentiment.
- *
- * REFACTOR: This is now a 'type: "meta"' calculation. It runs ONCE.
- * It reads the pre-aggregated 'insights' data source and sums the
- * 'buy' and 'sell' counts from all instruments.
+ * @fileoverview Calculation (Pass 1) for platform-wide Buy/Sell ratio.
+ * REFACTORED: Uses exposure weights.
  */
-class DailyBuySellSentimentCount {
-
-    // --- STANDARD 2: ADDED ---
+class PlatformBuySellSentiment {
     constructor() {
-        this.result = {};
+        this.longWeight = 0;
+        this.shortWeight = 0;
+        this.longCount = 0;
+        this.shortCount = 0;
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
-            type: 'meta',
-            rootDataDependencies: ['insights'], // Needs insights doc
+            type: 'standard',
+            rootDataDependencies: ['portfolio'],
             isHistorical: false,
-            userType: 'n/a',
+            userType: 'all',
             category: 'core_sentiment'
         };
     }
 
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
         return {
             "type": "object",
-            "description": "Total count of 'buy' (long) vs 'sell' (short) positions and the sentiment ratio.",
             "properties": {
-                "totalBuyPositions": {
-                    "type": "number",
-                    "description": "Total count of all 'buy' (long) positions."
-                },
-                "totalSellPositions": {
-                    "type": "number",
-                    "description": "Total count of all 'sell' (short) positions."
-                },
-                "sentimentRatio": {
-                    "type": ["number", "null"],
-                    "description": "Ratio of buy to sell positions (buy/sell). Null if no sell positions."
-                }
+                "long_exposure_weight": { "type": "number" },
+                "short_exposure_weight": { "type": "number" },
+                "sentiment_ratio_weight": { "type": ["number", "null"] },
+                "sentiment_ratio_count": { "type": ["number", "null"] }
             },
-            "required": ["totalBuyPositions", "totalSellPositions", "sentimentRatio"]
+            "required": ["long_exposure_weight", "short_exposure_weight", "sentiment_ratio_weight", "sentiment_ratio_count"]
         };
     }
 
-    /**
-     * This is a 'meta' calculation. It runs once.
-     */
-    // --- STANDARD 1: UPDATED SIGNATURE (added rootData, config, fetchedDependencies) ---
-    async process(dateStr, rootData, dependencies, config, fetchedDependencies) {
-        let totalBuyPositions = 0;
-        let totalSellPositions = 0;
-
-        // ---
-        // FIX: The test harness injects the rootData object as the *first*
-        // argument (named 'dateStr' here) for 'meta' calcs.
-        // 'rootData' (the 2nd arg) is used for yesterday's data and is null.
-        // ---
-        const rootDataToday = dateStr; 
-        const insightsDoc = rootDataToday.insights;
-
-        if (!insightsDoc || !Array.isArray(insightsDoc.insights)) {
-            dependencies.logger.log('WARN', `[daily-buy-sell-sentiment-count] No 'insights' data found.`);
-            // --- STANDARD 2: SET STATE, DO NOT RETURN ---
-            this.result = {
-                totalBuyPositions: 0,
-                totalSellPositions: 0,
-                sentimentRatio: null
-            };
-            return;
-        }
+    process(context) {
+        const { extract } = context.math;
+        const { user } = context;
+        const positions = extract.getPositions(user.portfolio.today, user.type);
 
-        // Iterate over the pre-aggregated array
-        for (const instrument of insightsDoc.insights) {
-            
-            // ---
-            // FIX: schema.md shows 'buy' and 'sell' are percentages (e.g., 51, 49).
-            // To get the *count*, we must use 'total' and the percentage.
-            // total * (buy / 100)
-            // But 'total' is the *total raw owners count*, not the total positions.
-            // The prompt says "percentage of owners in long/short", so
-            // 'buy' and 'sell' ARE the sentiment, not counts.
-            //
-            // Rereading schema.md:
-            // "buy": 51, ---> percentage of owners in long
-            // "sell": 49, ---> percentage of owners in short
-            // "total": 6149, ---> total raw owners count today
-            //
-            // The description says "Total count of 'buy' (long) vs 'sell' (short) positions".
-            // The old code `totalBuyPositions += instrument.buy;` assumes 'buy' is a count.
-            // Based on the schema, 'buy' is a *percentage*.
-            //
-            // Let's assume the intent is to calculate the weighted average sentiment.
-            // No, the schema *output* says "totalBuyPositions" and "totalSellPositions".
-            //
-            // THIS IS THE REAL BUG.
-            // The schema 'insights' does not provide *counts* of buy/sell, only *percentages*.
-            // The calculation *assumes* 'instrument.buy' is a count.
-            //
-            // Let's look at the schema again:
-            // "buy": 51
-            // "sell": 49
-            // "total": 6149
-            //
-            // The only logical interpretation is:
-            // Buy Count = total * (buy / 100)
-            // Sell Count = total * (sell / 100)
-            // ---
+        for (const pos of positions) {
+            const weight = extract.getPositionWeight(pos, user.type);
+            const direction = extract.getDirection(pos);
 
-            const totalOwners = instrument.total;
-            if (typeof totalOwners === 'number' && totalOwners > 0) {
-                if (typeof instrument.buy === 'number') {
-                    totalBuyPositions += totalOwners * (instrument.buy / 100);
-                }
-                if (typeof instrument.sell === 'number') {
-                    totalSellPositions += totalOwners * (instrument.sell / 100);
-                }
+            if (direction === 'Buy') {
+                this.longWeight += weight;
+                this.longCount++;
+            } else {
+                this.shortWeight += weight;
+                this.shortCount++;
             }
         }
-
-        // --- STANDARD 2: SET STATE, DO NOT RETURN ---
-        this.result = {
-            // Round the counts, as they are now derived from percentages
-            totalBuyPositions: Math.round(totalBuyPositions),
-            totalSellPositions: Math.round(totalSellPositions),
-            // Calculate ratio: Buy / Sell
-            sentimentRatio: (totalSellPositions > 0) ? (totalBuyPositions / totalSellPositions) : null
-        };
     }
 
-    // --- STANDARD 2: ADDED ---
-    async getResult(fetchedDependencies) {
-        return this.result;
+    getResult() {
+        return {
+            long_exposure_weight: this.longWeight,
+            short_exposure_weight: this.shortWeight,
+            sentiment_ratio_weight: this.shortWeight > 0 ? this.longWeight / this.shortWeight : null,
+            sentiment_ratio_count: this.shortCount > 0 ? this.longCount / this.shortCount : null
+        };
     }
 
-    // --- STANDARD 2: ADDED ---
     reset() {
-        this.result = {};
+        this.longWeight = 0;
+        this.shortWeight = 0;
+        this.longCount = 0;
+        this.shortCount = 0;
     }
 }
-
-module.exports = DailyBuySellSentimentCount;
+module.exports = PlatformBuySellSentiment;

package/calculations/core/platform-daily-bought-vs-sold-count.js

@@ -1,148 +1,92 @@
 /**
- * @fileoverview Calculation (Pass 2) for daily bought vs. sold count.
- *
- * This metric tracks the total number of positions 'bought' (new)
- * and 'sold' (closed) today, based on daily ownership change.
- *
- * This is different from 'daily_asset_activity' because it counts
- * *positions*, not *unique users*.
+ * @fileoverview Calculation (Pass 1) for daily bought vs. sold count.
+ * REFACTORED: Uses context.math.extract on today vs yesterday.
  */
-// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
-
-
 class DailyBoughtVsSoldCount {
     constructor() {
-        // We will store { [instrumentId]: { new: 0, closed: 0 } }
         this.assetActivity = new Map();
-        // --- STANDARD 0: RENAMED ---
         this.tickerMap = null;
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'standard',
             rootDataDependencies: ['portfolio'],
-            isHistorical: true, // Needs yesterday's portfolio
+            isHistorical: true,
             userType: 'all',
             category: 'core_metrics'
         };
     }
 
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
         const tickerSchema = {
             "type": "object",
-            "description": "Daily trade activity for a specific asset.",
             "properties": {
-                "positions_bought": {
-                    "type": "number",
-                    "description": "Total new positions opened for this asset."
-                },
-                "positions_sold": {
-                    "type": "number",
-                    "description": "Total positions closed for this asset."
-                },
-                "net_change": {
-                    "type": "number",
-                    "description": "Net change in positions (bought - sold)."
-                }
+                "positions_bought": { "type": "number" },
+                "positions_sold": { "type": "number" },
+                "net_change": { "type": "number" }
             },
             "required": ["positions_bought", "positions_sold", "net_change"]
         };
-
-        return {
-            "type": "object",
-            "description": "Tracks new positions (bought) and closed positions (sold) per asset.",
-            "patternProperties": {
-                "^.*$": tickerSchema // Matches any string key (ticker)
-            },
-            "additionalProperties": tickerSchema
-        };
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
     }
 
     _initAsset(instrumentId) {
         if (!this.assetActivity.has(instrumentId)) {
-            this.assetActivity.set(instrumentId, {
-                new: 0,
-                closed: 0
-            });
+            this.assetActivity.set(instrumentId, { new: 0, closed: 0 });
         }
     }
 
-    _getInstrumentIds(portfolio) {
-        // This MUST use PositionID to be accurate
-        const positions = portfolio?.AggregatedPositions || portfolio?.PublicPositions;
-        if (!positions || !Array.isArray(positions)) {
-            return new Map();
+    _getInstrumentIds(positions, extract) {
+        const map = new Map();
+        for (const pos of positions) {
+            const posId = extract.getPositionId(pos);
+            const instId = extract.getInstrumentId(pos);
+            if (posId && instId) map.set(posId, instId);
         }
-        // Map<PositionID, InstrumentID>
-        return new Map(positions.map(p => [p.PositionID, p.InstrumentID]).filter(p => p[0] && p[1]));
+        return map;
     }
 
-    // --- STANDARD 0: UPDATED SIGNATURE (added context) ---
-    process(todayPortfolio, yesterdayPortfolio, userId, context) {
-        // --- STANDARD 0: ADDED ---
-        if (!this.tickerMap) {
-             this.tickerMap = context.instrumentToTicker;
-        }
+    process(context) {
+        const { extract } = context.math;
+        const { mappings, user } = context;
+        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
 
-        if (!todayPortfolio || !yesterdayPortfolio) {
-            return;
-        }
+        const todayPositions = extract.getPositions(user.portfolio.today, user.type);
+        const yesterdayPositions = extract.getPositions(user.portfolio.yesterday, user.type);
 
-        const yPosMap = this._getInstrumentIds(yesterdayPortfolio); // Map<PosID, InstID>
-        const tPosMap = this._getInstrumentIds(todayPortfolio); // Map<PosID, InstID>
+        const tPosMap = this._getInstrumentIds(todayPositions, extract);
+        const yPosMap = this._getInstrumentIds(yesterdayPositions, extract);
 
-        // Find new positions (in today but not yesterday)
-        for (const [tPosId, tInstId] of tPosMap.entries()) {
-            if (!yPosMap.has(tPosId)) {
-                this._initAsset(tInstId);
-                this.assetActivity.get(tInstId).new++;
+        // New positions (in today, not yesterday)
+        for (const [posId, instId] of tPosMap.entries()) {
+            if (!yPosMap.has(posId)) {
+                this._initAsset(instId);
+                this.assetActivity.get(instId).new++;
             }
         }
 
-        // Find closed positions (in yesterday but not today)
-        for (const [yPosId, yInstId] of yPosMap.entries()) {
-            if (!tPosMap.has(yPosId)) {
-                this._initAsset(yInstId);
-                this.assetActivity.get(yInstId).closed++;
+        // Closed positions (in yesterday, not today)
+        for (const [posId, instId] of yPosMap.entries()) {
+            if (!tPosMap.has(posId)) {
+                this._initAsset(instId);
+                this.assetActivity.get(instId).closed++;
             }
         }
     }
 
     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.assetActivity.entries()) {
-            // --- STANDARD 0: SIMPLIFIED ---
-            const ticker = this.tickerMap[instrumentId] || `id_${instrumentId}`;
-            
-            const openCount = data.new;
-            const closeCount = data.closed;
-            
-            if (openCount > 0 || closeCount > 0) {
+        for (const [instId, data] of this.assetActivity.entries()) {
+            const ticker = this.tickerMap[instId] || `id_${instId}`;
+            if (data.new > 0 || data.closed > 0) {
                 result[ticker] = {
-                    positions_bought: openCount,
-                    positions_sold: closeCount,
-                    net_change: openCount - closeCount 
+                    positions_bought: data.new,
+                    positions_sold: data.closed,
+                    net_change: data.new - data.closed
                 };
             }
         }
@@ -151,9 +95,7 @@ class DailyBoughtVsSoldCount {
 
     reset() {
         this.assetActivity.clear();
-        // --- STANDARD 0: RENAMED ---
         this.tickerMap = null;
     }
 }
-
 module.exports = DailyBoughtVsSoldCount;

package/calculations/core/platform-daily-ownership-delta.js

@@ -1,161 +1,103 @@
 /**
- * @fileoverview Calculation (Pass 1) for daily ownership delta.
- *
- * This metric calculates the daily change in the total number of *owners*
- * (unique users) for each instrument.
- *
- * REFACTOR: This is now a 'type: "meta"' and 'isHistorical: true' calculation.
- * It runs ONCE, loads today's and yesterday's pre-aggregated 'insights' docs,
- * and calculates the delta based on the 'total' field.
+ * @fileoverview Calculation (Pass 1) for ownership delta (users added/lost per asset).
+ * REFACTORED: Tracks net change in number of owners.
  */
-// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
-
-
-class DailyOwnershipDelta {
-    
-    // --- STANDARD 2: ADDED ---
+class PlatformDailyOwnershipDelta {
     constructor() {
-        this.result = {};
+        this.assetChanges = new Map(); // { instId: { added: 0, removed: 0 } }
+        this.tickerMap = null;
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
-            type: 'meta',
-            rootDataDependencies: ['insights'], // Needs insights doc
-            isHistorical: true, // Needs yesterday's insights doc
-            userType: 'n/a',
+            type: 'standard',
+            rootDataDependencies: ['portfolio'],
+            isHistorical: true,
+            userType: 'all',
             category: 'core_metrics'
         };
     }
 
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [];
-    }
+    static getDependencies() { return []; }
 
-    /**
-     * Defines the output schema for this calculation.
-     */
     static getSchema() {
         const tickerSchema = {
             "type": "object",
-            "description": "Daily change in unique owners for a specific asset.",
             "properties": {
-                "owners_today": {
-                    "type": "number",
-                    "description": "Total unique users holding this asset today."
-                },
-                "owners_yesterday": {
-                    "type": "number",
-                    "description": "Total unique users holding this asset yesterday."
-                },
-                "owner_delta": {
-                    "type": "number",
-                    "description": "The net change in unique owners (today - yesterday)."
-                },
-                "owner_delta_percent": {
-                    "type": ["number", "null"],
-                    "description": "Percentage change in unique owners. Null if yesterday had 0 owners."
-                }
+                "owners_added": { "type": "number" },
+                "owners_removed": { "type": "number" },
+                "net_ownership_change": { "type": "number" }
             },
-            "required": ["owners_today", "owners_yesterday", "owner_delta", "owner_delta_percent"]
+            "required": ["owners_added", "owners_removed", "net_ownership_change"]
         };
+        return { "type": "object", "patternProperties": { "^.*$": tickerSchema } };
+    }
 
-        return {
-            "type": "object",
-            "description": "Calculates the daily change in the total number of unique owners for each asset.",
-            "patternProperties": {
-                "^.*$": tickerSchema // Matches any string key (ticker)
-            },
-            "additionalProperties": tickerSchema
-        };
+    _initAsset(instId) {
+        if (!this.assetChanges.has(instId)) {
+            this.assetChanges.set(instId, { added: 0, removed: 0 });
+        }
+    }
+
+    _getOwnedInstruments(positions, extract) {
+        const set = new Set();
+        for (const pos of positions) {
+            const id = extract.getInstrumentId(pos);
+            if (id) set.add(id);
+        }
+        return set;
     }
 
-    /**
-     * This is a 'meta' and 'historical' calculation. It runs once.
-     */
-    // --- STANDARD 1: UPDATED SIGNATURE ---
-    async process(dateStr, rootData, dependencies, config, fetchedDependencies) {
-        
-        // ---
-        // FIX: The test harness ('worker.js') is now our "ground truth".
-        //
-        // 1. Get Ticker Mappings:
-        //    'worker.js' passes the context object as ARGUMENT 4 (named 'config').
-        //    This context *already contains* the ticker map.
-        // ---
-        const { instrumentToTicker } = config; // 'config' is Param 4
-        
-        const todayOwners = new Map();
-        const yesterdayOwners = new Map();
-        const allInstrumentIds = new Set();
-        
-        // ---
-        // 2. Get Data:
-        //    'worker.js' passes the root data object as ARGUMENT 1 (named 'dateStr').
-        // ---
-        const rootDataToday = dateStr; // 'dateStr' is Param 1
-        
-        const todayDoc = rootDataToday?.insights;
-        const yesterdayDoc = rootDataToday?.yesterdayInsights;
-        
-        // 1. Process today's insights doc
-        if (todayDoc && Array.isArray(todayDoc.insights)) {
-            for (const instrument of todayDoc.insights) {
-                const id = instrument.instrumentId;
-                const totalOwners = instrument.total || 0; // 'total' is the owner count
-                todayOwners.set(id, totalOwners);
-                allInstrumentIds.add(id);
+    process(context) {
+        const { extract } = context.math;
+        const { mappings, user } = context;
+        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
+
+        // If either portfolio is missing, we can't calculate delta for this user
+        if (!user.portfolio.today || !user.portfolio.yesterday) return;
+
+        const todayPositions = extract.getPositions(user.portfolio.today, user.type);
+        const yesterdayPositions = extract.getPositions(user.portfolio.yesterday, user.type);
+
+        const tSet = this._getOwnedInstruments(todayPositions, extract);
+        const ySet = this._getOwnedInstruments(yesterdayPositions, extract);
+
+        // Added: In Today, Not Yesterday
+        for (const instId of tSet) {
+            if (!ySet.has(instId)) {
+                this._initAsset(instId);
+                this.assetChanges.get(instId).added++;
             }
         }
-        
-        // 2. Process yesterday's insights doc
-        if (yesterdayDoc && Array.isArray(yesterdayDoc.insights)) {
-            for (const instrument of yesterdayDoc.insights) {
-                const id = instrument.instrumentId;
-                const totalOwners = instrument.total || 0; // 'total' is the owner count
-                yesterdayOwners.set(id, totalOwners);
-                allInstrumentIds.add(id);
+
+        // Removed: In Yesterday, Not Today
+        for (const instId of ySet) {
+            if (!tSet.has(instId)) {
+                this._initAsset(instId);
+                this.assetChanges.get(instId).removed++;
             }
         }
-        
-        // 3. Calculate deltas
+    }
+
+    async getResult() {
+        if (!this.tickerMap) return {};
         const result = {};
-        for (const instrumentId of allInstrumentIds) {
-            // --- Use the map from Param 4 ---
-            const ticker = instrumentToTicker[instrumentId] || `id_${instrumentId}`;
-            
-            const tOwners = todayOwners.get(instrumentId) || 0;
-            const yOwners = yesterdayOwners.get(instrumentId) || 0;
-            
-            if (yOwners > 0 || tOwners > 0) {
+        for (const [instId, data] of this.assetChanges.entries()) {
+            const ticker = this.tickerMap[instId] || `id_${instId}`;
+            if (data.added > 0 || data.removed > 0) {
                 result[ticker] = {
-                    owners_today: tOwners,
-                    owners_yesterday: yOwners,
-                    owner_delta: tOwners - yOwners,
-                    owner_delta_percent: (yOwners > 0) ? ((tOwners - yOwners) / yOwners) * 100 : null
+                    owners_added: data.added,
+                    owners_removed: data.removed,
+                    net_ownership_change: data.added - data.removed
                 };
             }
         }
-        
-        // --- STANDARD 2: SET STATE, DO NOT RETURN ---
-        this.result = result;
+        return result;
     }
 
-    // --- STANDARD 2: ADDED ---
-    async getResult(fetchedDependencies) {
-        return this.result;
-    }
-
-    // --- STANDARD 2: ADDED ---
     reset() {
-        this.result = {};
+        this.assetChanges.clear();
+        this.tickerMap = null;
     }
 }
-
-module.exports = DailyOwnershipDelta;
+module.exports = PlatformDailyOwnershipDelta;