aiden-shared-calculations-unified 1.0.64 → 1.0.65

package/calculations/sectors/total_long_per_sector.js

@@ -1,43 +1,78 @@
 /**
- * @fileoverview Counts the total number of 'long' (Buy) positions for each sector.
+ * @fileoverview Calculation (Pass 1) for total long positions per sector.
+ *
+ * This metric answers: "What is the total number of long ('buy')
+ * positions for each sector?"
  */
-const { getInstrumentSectorMap } = require('../../utils/sector_mapping_provider'); // Correctly import the new function
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
 
 class TotalLongPerSector {
     constructor() {
-        this.longPositions = [];
+        // We will store { [sector]: count }
+        this.sectors = new Map();
+        this.mappings = null;
     }
 
-    process(portfolioData, yesterdayPortfolio, userId, context) {
-        if (portfolioData && portfolioData.AggregatedPositions) {
-            for (const position of portfolioData.AggregatedPositions) {
-                if (position.Direction === 'Buy') {
-                    this.longPositions.push(position);
+    /**
+     * Defines the output schema for this calculation.
+     * @returns {object} JSON Schema object
+     */
+    static getSchema() {
+        return {
+            "type": "object",
+            "description": "Calculates the total count of long ('buy') positions per sector.",
+            "patternProperties": {
+                // Sector name
+                "^.*$": {
+                    "type": "number",
+                    "description": "The total count of long positions for this sector."
                 }
+            },
+            "additionalProperties": {
+                "type": "number"
             }
+        };
+    }
+
+    _initSector(sector) {
+        if (!this.sectors.has(sector)) {
+            this.sectors.set(sector, 0);
         }
     }
 
-    async getResult() {
-        const longCountBySector = {};
-        const sectorMap = await getInstrumentSectorMap(); // Use the new function
+    process(portfolioData, yesterdayPortfolio, userId, context) {
+        // This calculation needs the sector mappings from Pass 1 context
+        if (!this.mappings) {
+            this.mappings = context.mappings;
+        }
 
-        for (const position of this.longPositions) {
-            const instrumentId = position.InstrumentID;
-            const sector = sectorMap[instrumentId] || 'N/A';
-            longCountBySector[sector] = (longCountBySector[sector] || 0) + 1;
+        const positions = portfolioData.PublicPositions || portfolioData.AggregatedPositions;
+        if (!positions || !Array.isArray(positions) || !this.mappings) {
+            return;
         }
 
-        const result = {};
-        for (const sector in longCountBySector) {
-            result[`raw_${sector}_long_count`] = longCountBySector[sector];
+        for (const pos of positions) {
+            // Only count 'buy' (long) positions
+            if (pos.IsBuy) {
+                const instrumentId = pos.InstrumentID;
+                if (!instrumentId) continue;
+                
+                const sector = this.mappings.instrumentToSector[instrumentId] || 'Other';
+                this._initSector(sector);
+                
+                this.sectors.set(sector, this.sectors.get(sector) + 1);
+            }
         }
+    }
 
-        return result;
+    getResult() {
+        // Convert Map to plain object
+        return Object.fromEntries(this.sectors);
     }
 
     reset() {
-        this.longPositions = [];
+        this.sectors.clear();
+        this.mappings = null;
     }
 }
 

package/calculations/sectors/total_short_per_sector.js

@@ -1,43 +1,78 @@
 /**
- * @fileoverview Counts the total number of 'short' (Sell) positions for each sector.
+ * @fileoverview Calculation (Pass 1) for total short positions per sector.
+ *
+ * This metric answers: "What is the total number of short ('sell')
+ * positions for each sector?"
  */
-const { getInstrumentSectorMap } = require('../../utils/sector_mapping_provider'); // Correctly import the new function
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
 
 class TotalShortPerSector {
     constructor() {
-        this.shortPositions = [];
+        // We will store { [sector]: count }
+        this.sectors = new Map();
+        this.mappings = null;
     }
 
-    process(portfolioData, yesterdayPortfolio, userId, context) {
-        if (portfolioData && portfolioData.AggregatedPositions) {
-            for (const position of portfolioData.AggregatedPositions) {
-                if (position.Direction === 'Sell') {
-                    this.shortPositions.push(position);
+    /**
+     * Defines the output schema for this calculation.
+     * @returns {object} JSON Schema object
+     */
+    static getSchema() {
+        return {
+            "type": "object",
+            "description": "Calculates the total count of short ('sell') positions per sector.",
+            "patternProperties": {
+                // Sector name
+                "^.*$": {
+                    "type": "number",
+                    "description": "The total count of short positions for this sector."
                 }
+            },
+            "additionalProperties": {
+                "type": "number"
             }
+        };
+    }
+
+    _initSector(sector) {
+        if (!this.sectors.has(sector)) {
+            this.sectors.set(sector, 0);
         }
     }
 
-    async getResult() {
-        const shortCountBySector = {};
-        const sectorMap = await getInstrumentSectorMap(); // Use the new function
+    process(portfolioData, yesterdayPortfolio, userId, context) {
+        // This calculation needs the sector mappings from Pass 1 context
+        if (!this.mappings) {
+            this.mappings = context.mappings;
+        }
 
-        for (const position of this.shortPositions) {
-            const instrumentId = position.InstrumentID;
-            const sector = sectorMap[instrumentId] || 'N/A';
-            shortCountBySector[sector] = (shortCountBySector[sector] || 0) + 1;
+        const positions = portfolioData.PublicPositions || portfolioData.AggregatedPositions;
+        if (!positions || !Array.isArray(positions) || !this.mappings) {
+            return;
         }
 
-        const result = {};
-        for (const sector in shortCountBySector) {
-            result[`raw_${sector}_short_count`] = shortCountBySector[sector];
+        for (const pos of positions) {
+            // Only count 'sell' (short) positions
+            if (!pos.IsBuy) {
+                const instrumentId = pos.InstrumentID;
+                if (!instrumentId) continue;
+                
+                const sector = this.mappings.instrumentToSector[instrumentId] || 'Other';
+                this._initSector(sector);
+                
+                this.sectors.set(sector, this.sectors.get(sector) + 1);
+            }
         }
+    }
 
-        return result;
+    getResult() {
+        // Convert Map to plain object
+        return Object.fromEntries(this.sectors);
     }
 
     reset() {
-        this.shortPositions = [];
+        this.sectors.clear();
+        this.mappings = null;
     }
 }
 

package/calculations/sentiment/historical/crowd_conviction_score.js

@@ -1,80 +1,260 @@
 /**
- * @fileoverview Calculates a "Crowd Conviction" score for each instrument.
+ * @fileoverview Calculation (Pass 2) for crowd conviction.
+ *
+ * This metric answers: "What is the 'Crowd Conviction Score'
+ * for each instrument?"
+ *
+ * It's based on factors like:
+ * 1. Holding Duration (longer = more conviction)
+ * 2. P&L % (positive = more conviction)
+ * 3. Risk/Reward Ratio (higher = more conviction)
+ * 4. Leverage (lower = more conviction)
+ *
+ * This is a *stateful* calculation that computes a 30-day
+ * rolling average of these metrics to build the score.
  */
-// CORRECTED PATH: ../utils/ instead of ../../utils/
 const { loadInstrumentMappings } = require('../../../utils/sector_mapping_provider');
 
-
 class CrowdConvictionScore {
-    // ... (rest of the code is unchanged) ...
     constructor() {
-        this.convictionData = {};
+        // { [instrumentId]: { metrics: [], history: [] } }
+        this.assetData = new Map();
         this.mappings = null;
     }
 
-    async process(todayPortfolio, yesterdayPortfolio, userId) {
-        if (!todayPortfolio) return;
+    /**
+     * Defines the output schema for this calculation.
+     * @returns {object} JSON Schema object
+     */
+    static getSchema() {
+        const historyItemSchema = {
+            "type": "object",
+            "properties": {
+                "avg_holding_duration": { "type": "number" },
+                "avg_pnl": { "type": "number" },
+                "avg_rr": { "type": "number" },
+                "avg_leverage": { "type": "number" }
+            },
+            "required": ["avg_holding_duration", "avg_pnl", "avg_rr", "avg_leverage"]
+        };
 
-        if(!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
+        const tickerSchema = {
+            "type": "object",
+            "description": "Crowd conviction score and its components for a specific asset.",
+            "properties": {
+                "conviction_score": {
+                    "type": "number",
+                    "description": "Final conviction score (0-100), based on 30-day rolling averages."
+                },
+                "roll_avg_holding_duration": {
+                    "type": "number",
+                    "description": "30-day rolling average of holding duration (hours)."
+                },
+                "roll_avg_pnl": {
+                    "type": "number",
+                    "description": "30-day rolling average of P&L percentage."
+                },
+                "roll_avg_rr": {
+                    "type": "number",
+                    "description": "30-day rolling average of risk/reward ratio."
+                },
+                "roll_avg_leverage": {
+                    "type": "number",
+                    "description": "30-day rolling average of leverage."
+                },
+                "avg_holding_duration": {
+                    "type": "number",
+                    "description": "Today's average holding duration."
+                },
+                "avg_pnl": {
+                    "type": "number",
+                    "description": "Today's average P&L percentage."
+                },
+                "avg_rr": {
+                    "type": "number",
+                    "description": "Today's average risk/reward ratio."
+                },
+                "avg_leverage": {
+                    "type": "number",
+                    "description": "Today's average leverage."
+                },
+                "history": {
+                    "type": "array",
+                    "description": "30-day history of daily average metrics.",
+                    "items": historyItemSchema
+                }
+            },
+            "required": [
+                "conviction_score", "roll_avg_holding_duration", "roll_avg_pnl", 
+                "roll_avg_rr", "roll_avg_leverage", "avg_holding_duration", 
+                "avg_pnl", "avg_rr", "avg_leverage", "history"
+            ]
+        };
+
+        return {
+            "type": "object",
+            "description": "Calculates a 30-day rolling 'Crowd Conviction Score' (0-100) for each asset.",
+            "patternProperties": {
+                "^.*$": tickerSchema // Ticker
+            },
+            "additionalProperties": tickerSchema
+        };
+    }
+
+    _initAsset(instrumentId) {
+        if (!this.assetData.has(instrumentId)) {
+            // metrics: Stores *today's* raw values before averaging
+            // history: Stores *yesterday's* 30-day history
+            this.assetData.set(instrumentId, {
+                metrics: [],
+                history: []
+            });
+        }
+    }
+    
+    _getHoldingDurationHours(openDateStr) {
+        if (!openDateStr) return 0;
+        try {
+            const openDate = new Date(openDateStr);
+            const diffMs = new Date().getTime() - openDate.getTime();
+            return diffMs / (1000 * 60 * 60);
+        } catch (e) {
+            return 0;
+        }
+    }
+    
+    // Simple min-max normalization helper
+    _normalize(value, min, max) {
+        if (max === min) return 0.5; // Avoid division by zero
+        const normalized = (value - min) / (max - min);
+        return Math.max(0, Math.min(1, normalized)); // Clamp between 0 and 1
+    }
+
+    process(portfolioData, yesterdayPortfolio, userId, context) {
+        // This score is based on speculator actions
+        if (portfolioData?.context?.userType !== 'speculator') {
+            return;
+        }
+        
+        // 1. Get this metric's history from yesterday (pre-loaded)
+        if (this.assetData.size === 0) { // Only run once
+             const yHistoryData = context.yesterdaysDependencyData['crowd_conviction_score'];
+             if (yHistoryData) {
+                 if (!this.mappings) {
+                     // We need mappings to convert *yesterday's* tickers back to IDs
+                     this.mappings = context.mappings;
+                 }
+                 for (const [ticker, data] of Object.entries(yHistoryData)) {
+                     const instrumentId = this.mappings.tickerToInstrument[ticker];
+                     if (instrumentId) {
+                         this._initAsset(instrumentId);
+                         this.assetData.get(instrumentId).history = data.history || [];
+                     }
+                 }
+             }
         }
 
-        const positions = todayPortfolio.PublicPositions || todayPortfolio.AggregatedPositions;
-        if (!positions) return;
+        const positions = portfolioData.PublicPositions;
+        if (!positions || !Array.isArray(positions)) {
+            return;
+        }
 
         for (const pos of positions) {
             const instrumentId = pos.InstrumentID;
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
-
-            if (!this.convictionData[ticker]) {
-                this.convictionData[ticker] = {
-                    totalScore: 0,
-                    count: 0,
-                };
+            if (!instrumentId) continue;
+            
+            this._initAsset(instrumentId);
+            
+            const pnl_percent = (pos.NetProfit || 0) / (pos.Amount || 1);
+            const holding_duration = this._getHoldingDurationHours(pos.OpenDateTime);
+            const leverage = pos.Leverage || 1;
+            
+            const sl_rate = pos.StopLossRate || 0;
+            const tp_rate = pos.TakeProfitRate || 0;
+            const open_rate = pos.OpenRate || 1;
+            
+            let rr_ratio = 0;
+            if (sl_rate > 0 && tp_rate > 0) {
+                const risk = Math.abs(open_rate - sl_rate);
+                const reward = Math.abs(tp_rate - open_rate);
+                if (risk > 0) {
+                    rr_ratio = reward / risk;
+                }
             }
+            
+            this.assetData.get(instrumentId).metrics.push({
+                holding_duration,
+                pnl_percent,
+                rr_ratio,
+                leverage
+            });
+        }
+    }
 
-            let score = 0;
-            let weights = 0;
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
 
-            if (pos.OpenDateTime) {
-                const openTime = new Date(pos.OpenDateTime);
-                const holdingHours = (new Date() - openTime) / (1000 * 60 * 60);
-                score += Math.log(holdingHours + 1);
-                weights += 1;
-            }
+        const result = {};
+        for (const [instrumentId, data] of this.assetData.entries()) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
+            const metrics = data.metrics;
+            const yHistory = data.history; // Yesterday's 30-day history
 
-            if (pos.StopLossRate > 0 && pos.TakeProfitRate > 0) {
-                const risk = Math.abs(pos.OpenRate - pos.StopLossRate);
-                const reward = Math.abs(pos.TakeProfitRate - pos.OpenRate);
-                if (risk > 0) {
-                    const ratio = reward / risk;
-                    score += ratio * 0.5;
-                    weights += 0.5;
-                }
-            }
+            if (metrics.length === 0) continue;
 
-            if (pos.Leverage > 1) {
-                score += Math.log(pos.Leverage) * 1.5;
-                weights += 1.5;
-            }
+            // 1. Calculate today's averages
+            const count = metrics.length;
+            const avg_holding_duration = metrics.reduce((s, m) => s + m.holding_duration, 0) / count;
+            const avg_pnl = metrics.reduce((s, m) => s + m.pnl_percent, 0) / count;
+            const avg_rr = metrics.reduce((s, m) => s + m.rr_ratio, 0) / count;
+            const avg_leverage = metrics.reduce((s, m) => s + m.leverage, 0) / count;
+            
+            const todayMetrics = { avg_holding_duration, avg_pnl, avg_rr, avg_leverage };
 
-            if (weights > 0) {
-                const finalScore = (score / weights) * 100;
-                this.convictionData[ticker].totalScore += finalScore;
-                this.convictionData[ticker].count++;
-            }
+            // 2. Create new 30-day history
+            const newHistory = [todayMetrics, ...yHistory].slice(0, 30);
+            
+            // 3. Calculate 30-day rolling averages
+            const historyCount = newHistory.length;
+            const roll_avg_duration = newHistory.reduce((s, m) => s + m.avg_holding_duration, 0) / historyCount;
+            const roll_avg_pnl = newHistory.reduce((s, m) => s + m.avg_pnl, 0) / historyCount;
+            const roll_avg_rr = newHistory.reduce((s, m) => s + m.avg_rr, 0) / historyCount;
+            const roll_avg_leverage = newHistory.reduce((s, m) => s + m.avg_leverage, 0) / historyCount;
+            
+            // 4. Calculate Conviction Score (example normalization)
+            // (Assumes a 0-1 range for normalization, then scales to 0-100)
+            const norm_duration = this._normalize(roll_avg_duration, 0, 240); // 0-10 days
+            const norm_pnl = this._normalize(roll_avg_pnl, -0.5, 0.5);       // -50% to +50%
+            const norm_rr = this._normalize(roll_avg_rr, 0, 3);            // 0 to 3 R:R
+            const norm_leverage = 1 - this._normalize(roll_avg_leverage, 1, 10); // 1x to 10x (inverted)
+
+            // Combine scores (equal weight for this example)
+            const score_pct = (norm_duration + norm_pnl + norm_rr + norm_leverage) / 4;
+            
+            result[ticker] = {
+                conviction_score: score_pct * 100, // Final score 0-100
+                roll_avg_holding_duration,
+                roll_avg_pnl,
+                roll_avg_rr,
+                roll_avg_leverage,
+                
+                // Also include today's raw averages
+                avg_holding_duration,
+                avg_pnl,
+                avg_rr,
+                avg_leverage,
+                
+                history: newHistory
+            };
         }
+        return result;
     }
 
-    getResult() {
-        const result = {};
-        for (const ticker in this.convictionData) {
-            const data = this.convictionData[ticker];
-            if (data.count > 0) {
-                result[ticker] = data.totalScore / data.count;
-            }
-        }
-        return { crowd_conviction_score: result };
+    reset() {
+        this.assetData.clear();
+        this.mappings = null;
     }
 }
 

package/calculations/short_and_long_stats/long_position_per_stock.js

@@ -1,24 +1,59 @@
 /**
- * @fileoverview Counts the total number of 'long' (Buy) positions for each instrument.
- * This provides a simple measure of how many users are holding a long position in a given stock.
+ * @fileoverview Calculation (Pass 1) for long positions per stock.
+ *
+ * This metric answers: "How many long ('buy') positions
+ * are there for each stock?"
  */
 const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
 
 class LongPositionPerStock {
     constructor() {
-        this.longCountByInstrument = {};
+        // We will store { [instrumentId]: count }
+        this.assets = new Map();
         this.mappings = null;
     }
 
-    process(portfolioData, yesterdayPortfolio, userId, context) {
-        if (!portfolioData || !portfolioData.AggregatedPositions) {
+    /**
+     * Defines the output schema for this calculation.
+     * @returns {object} JSON Schema object
+     */
+    static getSchema() {
+        return {
+            "type": "object",
+            "description": "Calculates the total count of long ('buy') positions for each asset.",
+            "patternProperties": {
+                // Ticker
+                "^.*$": {
+                    "type": "number",
+                    "description": "The total count of long positions for this asset."
+                }
+            },
+            "additionalProperties": {
+                "type": "number"
+            }
+        };
+    }
+
+    _initAsset(instrumentId) {
+        if (!this.assets.has(instrumentId)) {
+            this.assets.set(instrumentId, 0);
+        }
+    }
+
+    process(portfolioData) {
+        const positions = portfolioData.PublicPositions || portfolioData.AggregatedPositions;
+        if (!positions || !Array.isArray(positions)) {
             return;
         }
 
-        for (const position of portfolioData.AggregatedPositions) {
-            if (position.Direction === 'Buy') {
-                const instrumentId = position.InstrumentID;
-                this.longCountByInstrument[instrumentId] = (this.longCountByInstrument[instrumentId] || 0) + 1;
+        for (const pos of positions) {
+            // Only count 'buy' (long) positions
+            if (pos.IsBuy) {
+                const instrumentId = pos.InstrumentID;
+                if (!instrumentId) continue;
+                
+                this._initAsset(instrumentId);
+                this.assets.set(instrumentId, this.assets.get(instrumentId) + 1);
             }
         }
     }
@@ -27,16 +62,17 @@ class LongPositionPerStock {
         if (!this.mappings) {
             this.mappings = await loadInstrumentMappings();
         }
+
         const result = {};
-        for (const instrumentId in this.longCountByInstrument) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
-            result[ticker] = this.longCountByInstrument[instrumentId];
+        for (const [instrumentId, count] of this.assets.entries()) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
+            result[ticker] = count;
         }
-        return { long_positions_by_stock: result };
+        return result;
     }
 
     reset() {
-        this.longCountByInstrument = {};
+        this.assets.clear();
         this.mappings = null;
     }
 }