aiden-shared-calculations-unified 1.0.64 → 1.0.65

package/calculations/short_and_long_stats/sentiment_per_stock.js

@@ -1,29 +1,79 @@
 /**
- * @fileoverview Calculates a crowd sentiment score for each instrument by counting long and short positions.
+ * @fileoverview Calculation (Pass 1) for sentiment per stock.
+ *
+ * This metric answers: "For each stock, what is the count
+ * of long versus short positions?"
  */
 const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
 
 class SentimentPerStock {
     constructor() {
-        this.sentimentData = {};
+        // { [instrumentId]: { long: 0, short: 0 } }
+        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() {
+        const tickerSchema = {
+            "type": "object",
+            "description": "Long/short position counts for a specific asset.",
+            "properties": {
+                "long_count": {
+                    "type": "number",
+                    "description": "Count of long ('buy') positions."
+                },
+                "short_count": {
+                    "type": "number",
+                    "description": "Count of short ('sell') positions."
+                },
+                "sentiment_ratio": {
+                    "type": ["number", "null"],
+                    "description": "Ratio of long to short (Long / Short). Null if no short positions."
+                }
+            },
+            "required": ["long_count", "short_count", "sentiment_ratio"]
+        };
+
+        return {
+            "type": "object",
+            "description": "Calculates the count of long vs. short positions for each asset.",
+            "patternProperties": {
+                "^.*$": tickerSchema // Ticker
+            },
+            "additionalProperties": tickerSchema
+        };
+    }
+
+    _initAsset(instrumentId) {
+        if (!this.assets.has(instrumentId)) {
+            this.assets.set(instrumentId, {
+                long: 0,
+                short: 0
+            });
+        }
+    }
+
+    process(portfolioData) {
+        const positions = portfolioData.PublicPositions || portfolioData.AggregatedPositions;
+        if (!positions || !Array.isArray(positions)) {
             return;
         }
 
-        for (const position of portfolioData.AggregatedPositions) {
-            const instrumentId = position.InstrumentID;
-            if (!this.sentimentData[instrumentId]) {
-                this.sentimentData[instrumentId] = { long_positions: 0, short_positions: 0 };
-            }
+        for (const pos of positions) {
+            const instrumentId = pos.InstrumentID;
+            if (!instrumentId) continue;
+            
+            this._initAsset(instrumentId);
+            const assetData = this.assets.get(instrumentId);
 
-            if (position.Direction === 'Buy') {
-                this.sentimentData[instrumentId].long_positions++;
-            } else if (position.Direction === 'Sell') {
-                this.sentimentData[instrumentId].short_positions++;
+            if (pos.IsBuy) {
+                assetData.long++;
+            } else {
+                assetData.short++;
             }
         }
     }
@@ -32,17 +82,24 @@ class SentimentPerStock {
         if (!this.mappings) {
             this.mappings = await loadInstrumentMappings();
         }
+
         const result = {};
-        for (const instrumentId in this.sentimentData) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
-            result[ticker] = this.sentimentData[instrumentId];
+        for (const [instrumentId, data] of this.assets.entries()) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
+            
+            if (data.long > 0 || data.short > 0) {
+                result[ticker] = {
+                    long_count: data.long,
+                    short_count: data.short,
+                    sentiment_ratio: (data.short > 0) ? (data.long / data.short) : null
+                };
+            }
         }
-        if (Object.keys(result).length === 0) return {};
-        return { sentiment_by_asset: result };
+        return result;
     }
 
     reset() {
-        this.sentimentData = {};
+        this.assets.clear();
         this.mappings = null;
     }
 }

package/calculations/short_and_long_stats/short_position_per_stock.js

@@ -1,23 +1,59 @@
 /**
- * @fileoverview Counts the total number of 'short' (Sell) positions for each instrument.
+ * @fileoverview Calculation (Pass 1) for short positions per stock.
+ *
+ * This metric answers: "How many short ('sell') positions
+ * are there for each stock?"
  */
 const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
 
 class ShortPositionPerStock {
     constructor() {
-        this.shortCountByInstrument = {};
+        // 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 short ('sell') positions for each asset.",
+            "patternProperties": {
+                // Ticker
+                "^.*$": {
+                    "type": "number",
+                    "description": "The total count of short 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 === 'Sell') {
-                const instrumentId = position.InstrumentID;
-                this.shortCountByInstrument[instrumentId] = (this.shortCountByInstrument[instrumentId] || 0) + 1;
+        for (const pos of positions) {
+            // Only count 'sell' (short) positions
+            if (!pos.IsBuy) {
+                const instrumentId = pos.InstrumentID;
+                if (!instrumentId) continue;
+                
+                this._initAsset(instrumentId);
+                this.assets.set(instrumentId, this.assets.get(instrumentId) + 1);
             }
         }
     }
@@ -26,16 +62,17 @@ class ShortPositionPerStock {
         if (!this.mappings) {
             this.mappings = await loadInstrumentMappings();
         }
+
         const result = {};
-        for (const instrumentId in this.shortCountByInstrument) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
-            result[ticker] = this.shortCountByInstrument[instrumentId];
+        for (const [instrumentId, count] of this.assets.entries()) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
+            result[ticker] = count;
         }
-        return { short_positions_by_stock: result };
+        return result;
     }
 
     reset() {
-        this.shortCountByInstrument = {};
+        this.assets.clear();
         this.mappings = null;
     }
 }

package/calculations/short_and_long_stats/total_long_figures.js

@@ -1,33 +1,54 @@
 /**
- * @fileoverview Calculates the total number of 'long' (Buy) positions across all users and instruments.
+ * @fileoverview Calculation (Pass 1) for total long figures.
+ *
+ * This metric answers: "What is the total number of long
+ * ('buy') positions across all users and instruments?"
  */
-
 class TotalLongFigures {
     constructor() {
-        this.totalLongPositions = 0;
+        this.longCount = 0;
     }
 
-    process(portfolioData, yesterdayPortfolio, userId, context) {
-        if (portfolioData && portfolioData.AggregatedPositions) {
-            for (const position of portfolioData.AggregatedPositions) {
-                if (position.Direction === 'Buy') {
-                    this.totalLongPositions++;
+    /**
+     * Defines the output schema for this calculation.
+     * @returns {object} JSON Schema object
+     */
+    static getSchema() {
+        return {
+            "type": "object",
+            "description": "Calculates the total count of all long ('buy') positions.",
+            "properties": {
+                "total_long_positions": {
+                    "type": "number",
+                    "description": "The aggregated count of all long positions."
                 }
+            },
+            "required": ["total_long_positions"]
+        };
+    }
+
+    process(portfolioData) {
+        const positions = portfolioData.PublicPositions || portfolioData.AggregatedPositions;
+        if (!positions || !Array.isArray(positions)) {
+            return;
+        }
+
+        for (const pos of positions) {
+            if (pos.IsBuy) {
+                this.longCount++;
             }
         }
     }
 
-    // Change getResult() (lines 20-22) to:
     getResult() {
-        if (this.totalLongPositions === 0) return {};
         return {
-            rawTotalLongPositions: this.totalLongPositions
+            total_long_positions: this.longCount
         };
     }
 
     reset() {
-        this.totalLongPositions = 0;
+        this.longCount = 0;
     }
 }
 
-module.exports = TotalLongFigures;
+module.exports = TotalLongFigures;

package/calculations/short_and_long_stats/total_short_figures.js

@@ -1,34 +1,54 @@
 /**
- * @fileoverview Calculates the total number of 'short' (Sell) positions across all users and instruments.
+ * @fileoverview Calculation (Pass 1) for total short figures.
+ *
+ * This metric answers: "What is the total number of short
+ * ('sell') positions across all users and instruments?"
  */
-
 class TotalShortFigures {
     constructor() {
-        this.totalShortPositions = 0;
+        this.shortCount = 0;
     }
 
-    process(portfolioData, yesterdayPortfolio, userId, context) {
-        if (portfolioData && portfolioData.AggregatedPositions) {
-            for (const position of portfolioData.AggregatedPositions) {
-                // Note: Short positions are indicated by Direction: 'Sell' in this data model
-                if (position.Direction === 'Sell') {
-                    this.totalShortPositions++;
+    /**
+     * Defines the output schema for this calculation.
+     * @returns {object} JSON Schema object
+     */
+    static getSchema() {
+        return {
+            "type": "object",
+            "description": "Calculates the total count of all short ('sell') positions.",
+            "properties": {
+                "total_short_positions": {
+                    "type": "number",
+                    "description": "The aggregated count of all short positions."
                 }
+            },
+            "required": ["total_short_positions"]
+        };
+    }
+
+    process(portfolioData) {
+        const positions = portfolioData.PublicPositions || portfolioData.AggregatedPositions;
+        if (!positions || !Array.isArray(positions)) {
+            return;
+        }
+
+        for (const pos of positions) {
+            if (!pos.IsBuy) {
+                this.shortCount++;
             }
         }
     }
 
-    // Change getResult() (lines 20-22) to:
     getResult() {
-        if (this.totalShortPositions === 0) return {};
         return {
-            rawTotalShortPositions: this.totalShortPositions
+            total_short_positions: this.shortCount
         };
     }
 
     reset() {
-        this.totalShortPositions = 0;
+        this.shortCount = 0;
     }
 }
 
-module.exports = TotalShortFigures;
+module.exports = TotalShortFigures;

package/calculations/socialPosts/social-asset-posts-trend.js

@@ -1,52 +1,119 @@
 /**
- * @fileoverview Aggregates the total number of posts per asset (ticker).
- * This data can be used for a time-series trend (AssetPostsTrend) or
- * for a "Top Tickers" card.
- * This calculation ONLY uses the social post insights context.
+ * @fileoverview Social Calculation (Pass 1)
+ *
+ * This metric answers: "How many social media posts
+ * were made today for each asset (ticker)?"
+ *
+ * This is a stateful calculation that needs to read its
+ * own 30-day history from Firestore to calculate trend.
  */
-
 class SocialAssetPostsTrend {
     constructor() {
-        this.postsByTicker = {};
-        this.processed = false; // Flag to ensure this runs only once
+        // { [ticker]: { count: 0, history: [] } }
+        this.assetData = new Map();
     }
 
     /**
-     * @param {null} todayPortfolio - Not used.
-     * ... (other params not used) ...
-     * @param {object} todaySocialPostInsights - Map of { [postId]: postData } for today.
-     * @param {object} yesterdaySocialPostInsights - Not used.
+     * Defines the output schema for this calculation.
+     * @returns {object} JSON Schema object
      */
-    async process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, todaySocialPostInsights, yesterdaySocialPostInsights) {
-        
-        if (this.processed || !todaySocialPostInsights) {
-            return;
-        }
-        this.processed = true;
+    static getSchema() {
+        const tickerSchema = {
+            "type": "object",
+            "description": "Daily and trended post count for a specific asset.",
+            "properties": {
+                "count": {
+                    "type": "number",
+                    "description": "Today's raw post count."
+                },
+                "trend_30d_pct": {
+                    "type": "number",
+                    "description": "Percentage change from the 30-day average post count."
+                },
+                "history_30d": {
+                    "type": "array",
+                    "description": "30-day history of post counts (today first).",
+                    "items": { "type": "number" }
+                }
+            },
+            "required": ["count", "trend_30d_pct", "history_30d"]
+        };
 
-        const posts = Object.values(todaySocialPostInsights);
+        return {
+            "type": "object",
+            "description": "Tracks the daily post count and 30-day trend for each asset ticker.",
+            "patternProperties": {
+                "^.*$": tickerSchema // Ticker
+            },
+            "additionalProperties": tickerSchema
+        };
+    }
 
-        for (const post of posts) {
-            if (!post.tickers || !Array.isArray(post.tickers)) continue;
+    /**
+     * @param {string} dateStr - Today's date.
+     * @param {object} dependencies - db, logger.
+     * @param {object} config - Computation config.
+     * @param {object} fetchedDependencies - (UNUSED) In-memory results.
+     */
+    async process(dateStr, dependencies, config, fetchedDependencies) {
+        const { db, logger, calculationUtils } = dependencies;
+        
+        // 1. Load this metric's history from yesterday
+        const yHistoryData = await calculationUtils.loadYesterdayData('social-asset-posts-trend');
 
-            for (const ticker of post.tickers) {
-                // Ensure ticker is a string and valid
-                const validTicker = String(ticker).trim();
-                if (validTicker) {
-                    this.postsByTicker[validTicker] = (this.postsByTicker[validTicker] || 0) + 1;
+        // 2. Initialize state with history
+        if (yHistoryData) {
+            for (const [ticker, data] of Object.entries(yHistoryData)) {
+                this.assetData.set(ticker, {
+                    count: 0, // Today's count starts at 0
+                    history: data.history_30d || []
+                });
+            }
+        }
+        
+        // 3. Process today's raw social data
+        // This relies on the social data loader (not shown here)
+        const todaySocialPosts = await calculationUtils.loadSocialData(dateStr); 
+
+        for (const post of todaySocialPosts) {
+            const tickers = post.tickers || [];
+            for (const ticker of tickers) {
+                if (!this.assetData.has(ticker)) {
+                    this.assetData.set(ticker, { count: 0, history: [] });
                 }
+                const data = this.assetData.get(ticker);
+                data.count++;
             }
         }
     }
 
     async getResult() {
-        // Returns an object like: { "AAPL": 15, "TSLA": 22 }
-        return this.postsByTicker;
+        const result = {};
+        for (const [ticker, data] of this.assetData.entries()) {
+            const history = data.history;
+            const todayCount = data.count;
+
+            const newHistory = [todayCount, ...history].slice(0, 30);
+            
+            let trend_30d_pct = 0;
+            if (history.length > 0) {
+                const avg_30d = history.reduce((a, b) => a + b, 0) / history.length;
+                if (avg_30d > 0) {
+                    trend_30d_pct = ((todayCount - avg_30d) / avg_30d) * 100;
+                }
+            }
+
+            result[ticker] = {
+                count: todayCount,
+                trend_30d_pct: trend_30d_pct,
+                history_30d: newHistory
+            };
+        }
+        return result;
     }
 
     reset() {
-        this.postsByTicker = {};
-        this.processed = false;
+        this.assetData.clear();
     }
 }