aiden-shared-calculations-unified 1.0.7 → 1.0.9

package/calculations/socialPosts/social-top-mentioned-words.js

@@ -0,0 +1,103 @@
+/**
+ * @fileoverview Finds the top mentioned words in all posts for the day,
+ * filtering out common stop words, and calculates the trend from yesterday.
+ * This calculation ONLY uses the social post insights context.
+ */
+
+class SocialTopMentionedWords {
+    constructor() {
+        this.todayWordCounts = {};
+        this.yesterdayWordCounts = {};
+        this.processed = false;
+
+        // A small, representative list of stop words.
+        // In a real implementation, this list would be much larger.
+        this.stopWords = new Set([
+            'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+            'have', 'has', 'had', 'do', 'does', 'did', 'but', 'if', 'or', 'and',
+            'of', 'at', 'by', 'for', 'with', 'about', 'to', 'from', 'in', 'on',
+            'it', 'i', 'me', 'my', 'you', 'your', 'he', 'she', 'we', 'they', 'them',
+            'this', 'that', 'these', 'those', 'what', 'which', 'who', 'whom',
+            'not', 'will', 'just', 'so', 'up', 'out', 'no', 'yes', 'all', 'any'
+        ]);
+    }
+
+    /**
+     * Helper to process posts and populate a word count map.
+     * @param {object} socialPostInsights - Map of { [postId]: postData }
+     * @param {object} targetCountMap - The object to store word counts.
+     */
+    _countWords(socialPostInsights, targetCountMap) {
+        if (!socialPostInsights) return;
+        const posts = Object.values(socialPostInsights);
+
+        for (const post of posts) {
+            const text = post.fullText?.toLowerCase() || '';
+            if (!text) continue;
+
+            // Get all words 3+ chars long
+            const words = text.match(/\b[a-z]{3,}\b/g) || [];
+
+            for (const word of words) {
+                if (!this.stopWords.has(word)) {
+                    targetCountMap[word] = (targetCountMap[word] || 0) + 1;
+                }
+            }
+        }
+    }
+
+    /**
+     * @param {object} todaySocialPostInsights - Map of { [postId]: postData } for today.
+     * @param {object} yesterdaySocialPostInsights - Map of { [postId]: postData } for yesterday.
+     */
+    async process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, todaySocialPostInsights, yesterdaySocialPostInsights) {
+        
+        if (this.processed) {
+            return;
+        }
+        this.processed = true;
+
+        // Process today's posts
+        this._countWords(todaySocialPostInsights, this.todayWordCounts);
+        
+        // Process yesterday's posts for trend calculation
+        this._countWords(yesterdaySocialPostInsights, this.yesterdayWordCounts);
+    }
+
+    async getResult() {
+        if (Object.keys(this.todayWordCounts).length === 0) {
+            return {};
+        }
+
+        const totalTodayWords = Object.values(this.todayWordCounts).reduce((a, b) => a + b, 0);
+
+        const topWords = Object.entries(this.todayWordCounts)
+            .sort(([, countA], [, countB]) => countB - countA)
+            .slice(0, 50); // Return the Top 50
+
+        const result = topWords.map(([term, count]) => {
+            const yesterdayCount = this.yesterdayWordCounts[term] || 0;
+            const trend = count - yesterdayCount;
+            const percent = (count / totalTodayWords) * 100;
+            
+            return {
+                term,
+                count,
+                percent: parseFloat(percent.toFixed(2)),
+                trend 
+            };
+        });
+
+        // Returns an array like:
+        // [ { term: "btc", count: 150, percent: 5.2, trend: 25 }, ... ]
+        return { top_words: result };
+    }
+
+    reset() {
+        this.todayWordCounts = {};
+        this.yesterdayWordCounts = {};
+        this.processed = false;
+    }
+}
+
+module.exports = SocialTopMentionedWords;

package/calculations/socialPosts/social-topic-interest-evolution.js

@@ -0,0 +1,54 @@
+/**
+ * @fileoverview Aggregates counts of all topics extracted by the AI
+ * from social posts for the day. Used to build a "Topic Interest Area" chart.
+ * This calculation ONLY uses the social post insights context.
+ */
+
+class SocialTopicInterestEvolution {
+    constructor() {
+        this.topicCounts = {};
+        this.processed = false;
+    }
+
+    /**
+     * @param {null} todayPortfolio - Not used.
+     * ... (other params not used) ...
+     * @param {object} todaySocialPostInsights - Map of { [postId]: postData } for today.
+     * @param {object} yesterdaySocialPostInsights - Not used.
+     */
+    async process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, todaySocialPostInsights, yesterdaySocialPostInsights) {
+        
+        if (this.processed || !todaySocialPostInsights) {
+            return;
+        }
+        this.processed = true;
+
+        const posts = Object.values(todaySocialPostInsights);
+
+        for (const post of posts) {
+            // Topics are in post.sentiment.topics
+            const topics = post.sentiment?.topics;
+            if (!topics || !Array.isArray(topics)) continue;
+
+            for (const topic of topics) {
+                // Normalize topic for consistent aggregation
+                const normalizedTopic = String(topic).toLowerCase().trim();
+                if (normalizedTopic) {
+                    this.topicCounts[normalizedTopic] = (this.topicCounts[normalizedTopic] || 0) + 1;
+                }
+            }
+        }
+    }
+
+    async getResult() {
+        // Returns an object like: { "earnings": 45, "cpi": 12, "fed": 22 }
+        return this.topicCounts;
+    }
+
+    reset() {
+        this.topicCounts = {};
+        this.processed = false;
+    }
+}
+
+module.exports = SocialTopicInterestEvolution;

package/calculations/socialPosts/social-word-mentions-trend.js

@@ -0,0 +1,63 @@
+/**
+ * @fileoverview Tracks daily mentions of a pre-defined list of keywords.
+ * This calculation ONLY uses the social post insights context.
+ */
+
+class SocialWordMentionsTrend {
+    constructor() {
+        // A pre-defined list of keywords to track
+        this.KEYWORDS = [
+            'inflation', 'fed', 'fomc', 'cpi', 'earnings',
+            'recession', 'bullish', 'bearish', 'buy', 'sell',
+            'war', 'acquisition', 'ai'
+        ];
+        this.mentions = {};
+        this.processed = false;
+    }
+
+    /**
+     * @param {null} todayPortfolio - Not used.
+     * ... (other params not used) ...
+     * @param {object} todaySocialPostInsights - Map of { [postId]: postData } for today.
+     * @param {object} yesterdaySocialPostInsights - Not used.
+     */
+    async process(todayPortfolio, yesterdayPortfolio, userId, context, todayInsights, yesterdayInsights, todaySocialPostInsights, yesterdaySocialPostInsights) {
+        
+        if (this.processed || !todaySocialPostInsights) {
+            return;
+        }
+        this.processed = true;
+
+        // Initialize all keywords with 0 counts
+        this.mentions = this.KEYWORDS.reduce((acc, key) => {
+            acc[key] = 0;
+            return acc;
+        }, {});
+
+        const posts = Object.values(todaySocialPostInsights);
+
+        for (const post of posts) {
+            const text = post.fullText?.toLowerCase() || '';
+            if (!text) continue;
+
+            for (const keyword of this.KEYWORDS) {
+                // Count once per post, even if mentioned multiple times
+                if (text.includes(keyword)) {
+                    this.mentions[keyword]++;
+                }
+            }
+        }
+    }
+
+    async getResult() {
+        // Returns an object like: { "inflation": 5, "fed": 12, "ai": 30 }
+        return this.mentions;
+    }
+
+    reset() {
+        this.mentions = {};
+        this.processed = false;
+    }
+}
+
+module.exports = SocialWordMentionsTrend;

package/calculations/speculators/distance_to_stop_loss_per_leverage.js

@@ -1,78 +1,78 @@
-/**
- * @fileoverview Calculates the average distance to the stop loss from the current price for
- * both long and short positions, grouped by asset and leverage level.
- * It ignores near-zero stop loss values.
- */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
-
-class DistanceToStopLossPerLeverage {
-    constructor() {
-        this.stopLossData = {};
-        this.mappings = null;
-    }
-
-    process(portfolioData, userId) {
-        if (portfolioData && portfolioData.PublicPositions) {
-            for (const position of portfolioData.PublicPositions) {
-                const instrumentId = position.InstrumentID;
-                const leverage = position.Leverage;
-                const stopLossRate = position.StopLossRate;
-                const currentRate = position.CurrentRate;
-                const isBuy = position.IsBuy;
-
-                if (stopLossRate > 0.0001 && currentRate > 0) {
-                    let distance;
-
-                    if (isBuy) {
-                        distance = currentRate - stopLossRate;
-                    } else {
-                        distance = stopLossRate - currentRate;
-                    }
-                    
-                    const distancePercent = (distance / currentRate) * 100;
-
-                    if (distancePercent > 0) {
-                        if (!this.stopLossData[instrumentId]) {
-                            this.stopLossData[instrumentId] = {};
-                        }
-                        if (!this.stopLossData[instrumentId][leverage]) {
-                            this.stopLossData[instrumentId][leverage] = { distance_sum_percent: 0, count: 0 };
-                        }
-                        this.stopLossData[instrumentId][leverage].distance_sum_percent += distancePercent;
-                        this.stopLossData[instrumentId][leverage].count++;
-                    }
-                }
-            }
-        }
-    }
-
-    async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
-        }
-
-        const result = {};
-        for (const instrumentId in this.stopLossData) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
-            result[ticker] = {};
-            for (const leverage in this.stopLossData[instrumentId]) {
-                const data = this.stopLossData[instrumentId][leverage];
-                // REFACTOR: Perform final calculation directly.
-                if (data.count > 0) {
-                    result[ticker][leverage] = {
-                        average_distance_percent: data.distance_sum_percent / data.count,
-                        count: data.count
-                    };
-                }
-            }
-        }
-        return result;
-    }
-
-    reset() {
-        this.stopLossData = {};
-        this.mappings = null;
-    }
-}
-
-module.exports = DistanceToStopLossPerLeverage;
+/**
+ * @fileoverview Calculates the average distance to the stop loss from the current price for
+ * both long and short positions, grouped by asset and leverage level.
+ * It ignores near-zero stop loss values.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class DistanceToStopLossPerLeverage {
+    constructor() {
+        this.stopLossData = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, yesterdayPortfolio, userId, context) {
+        if (portfolioData && portfolioData.PublicPositions) {
+            for (const position of portfolioData.PublicPositions) {
+                const instrumentId = position.InstrumentID;
+                const leverage = position.Leverage;
+                const stopLossRate = position.StopLossRate;
+                const currentRate = position.CurrentRate;
+                const isBuy = position.IsBuy;
+
+                if (stopLossRate > 0.0001 && currentRate > 0) {
+                    let distance;
+
+                    if (isBuy) {
+                        distance = currentRate - stopLossRate;
+                    } else {
+                        distance = stopLossRate - currentRate;
+                    }
+                    
+                    const distancePercent = (distance / currentRate) * 100;
+
+                    if (distancePercent > 0) {
+                        if (!this.stopLossData[instrumentId]) {
+                            this.stopLossData[instrumentId] = {};
+                        }
+                        if (!this.stopLossData[instrumentId][leverage]) {
+                            this.stopLossData[instrumentId][leverage] = { distance_sum_percent: 0, count: 0 };
+                        }
+                        this.stopLossData[instrumentId][leverage].distance_sum_percent += distancePercent;
+                        this.stopLossData[instrumentId][leverage].count++;
+                    }
+                }
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+
+        const result = {};
+        for (const instrumentId in this.stopLossData) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            result[ticker] = {};
+            for (const leverage in this.stopLossData[instrumentId]) {
+                const data = this.stopLossData[instrumentId][leverage];
+                // REFACTOR: Perform final calculation directly.
+                if (data.count > 0) {
+                    result[ticker][leverage] = {
+                        average_distance_percent: data.distance_sum_percent / data.count,
+                        count: data.count
+                    };
+                }
+            }
+        }
+        return result;
+    }
+
+    reset() {
+        this.stopLossData = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = DistanceToStopLossPerLeverage;

package/calculations/speculators/distance_to_tp_per_leverage.js

@@ -1,76 +1,76 @@
-/**
- * @fileoverview Calculates the average distance to the take profit from the current price for
- * both long and short positions, grouped by asset and leverage level.
- * It ignores positions where take profit is not set.
- */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
-
-class DistanceToTakeProfitPerLeverage {
-    constructor() {
-        this.takeProfitData = {};
-        this.mappings = null;
-    }
-
-    process(portfolioData, userId) {
-        if (portfolioData && portfolioData.PublicPositions) {
-            for (const position of portfolioData.PublicPositions) {
-                const instrumentId = position.InstrumentID;
-                const leverage = position.Leverage;
-                const takeProfitRate = position.TakeProfitRate;
-                const currentRate = position.CurrentRate;
-                const isBuy = position.IsBuy;
-
-                if (takeProfitRate > 0.0001 && currentRate > 0) {
-                    let distance;
-                    if (isBuy) {
-                        distance = takeProfitRate - currentRate;
-                    } else {
-                        distance = currentRate - takeProfitRate;
-                    }
-
-                    const distancePercent = (distance / currentRate) * 100;
-
-                    if (distancePercent > 0) {
-                        if (!this.takeProfitData[instrumentId]) {
-                            this.takeProfitData[instrumentId] = {};
-                        }
-                        if (!this.takeProfitData[instrumentId][leverage]) {
-                            this.takeProfitData[instrumentId][leverage] = { distance_sum_percent: 0, count: 0 };
-                        }
-                        this.takeProfitData[instrumentId][leverage].distance_sum_percent += distancePercent;
-                        this.takeProfitData[instrumentId][leverage].count++;
-                    }
-                }
-            }
-        }
-    }
-
-    async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
-        }
-        const result = {};
-        for (const instrumentId in this.takeProfitData) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
-            result[ticker] = {};
-            for (const leverage in this.takeProfitData[instrumentId]) {
-                const data = this.takeProfitData[instrumentId][leverage];
-                // REFACTOR: Perform final calculation directly.
-                if (data.count > 0) {
-                    result[ticker][leverage] = {
-                        average_distance_percent: data.distance_sum_percent / data.count,
-                        count: data.count
-                    };
-                }
-            }
-        }
-        return result;
-    }
-
-    reset() {
-        this.takeProfitData = {};
-        this.mappings = null;
-    }
-}
-
-module.exports = DistanceToTakeProfitPerLeverage;
+/**
+ * @fileoverview Calculates the average distance to the take profit from the current price for
+ * both long and short positions, grouped by asset and leverage level.
+ * It ignores positions where take profit is not set.
+ */
+const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+
+class DistanceToTakeProfitPerLeverage {
+    constructor() {
+        this.takeProfitData = {};
+        this.mappings = null;
+    }
+
+    process(portfolioData, yesterdayPortfolio, userId, context) {
+        if (portfolioData && portfolioData.PublicPositions) {
+            for (const position of portfolioData.PublicPositions) {
+                const instrumentId = position.InstrumentID;
+                const leverage = position.Leverage;
+                const takeProfitRate = position.TakeProfitRate;
+                const currentRate = position.CurrentRate;
+                const isBuy = position.IsBuy;
+
+                if (takeProfitRate > 0.0001 && currentRate > 0) {
+                    let distance;
+                    if (isBuy) {
+                        distance = takeProfitRate - currentRate;
+                    } else {
+                        distance = currentRate - takeProfitRate;
+                    }
+
+                    const distancePercent = (distance / currentRate) * 100;
+
+                    if (distancePercent > 0) {
+                        if (!this.takeProfitData[instrumentId]) {
+                            this.takeProfitData[instrumentId] = {};
+                        }
+                        if (!this.takeProfitData[instrumentId][leverage]) {
+                            this.takeProfitData[instrumentId][leverage] = { distance_sum_percent: 0, count: 0 };
+                        }
+                        this.takeProfitData[instrumentId][leverage].distance_sum_percent += distancePercent;
+                        this.takeProfitData[instrumentId][leverage].count++;
+                    }
+                }
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.mappings) {
+            this.mappings = await loadInstrumentMappings();
+        }
+        const result = {};
+        for (const instrumentId in this.takeProfitData) {
+            const ticker = this.mappings.instrumentToTicker[instrumentId] || instrumentId.toString();
+            result[ticker] = {};
+            for (const leverage in this.takeProfitData[instrumentId]) {
+                const data = this.takeProfitData[instrumentId][leverage];
+                // REFACTOR: Perform final calculation directly.
+                if (data.count > 0) {
+                    result[ticker][leverage] = {
+                        average_distance_percent: data.distance_sum_percent / data.count,
+                        count: data.count
+                    };
+                }
+            }
+        }
+        return result;
+    }
+
+    reset() {
+        this.takeProfitData = {};
+        this.mappings = null;
+    }
+}
+
+module.exports = DistanceToTakeProfitPerLeverage;