aiden-shared-calculations-unified 1.0.4 → 1.0.6

package/calculations/socialPosts/social_activity_aggregation.js

@@ -0,0 +1,99 @@
+/**
+ * @fileoverview Aggregates activity data (likes, comments) from social posts.
+ * This calculation ONLY uses the social post insights context, not portfolio data.
+ */
+
+class SocialActivityAggregation {
+    constructor() {
+        this.tickerActivity = {};
+        this.totalLikes = 0;
+        this.totalComments = 0;
+        this.processed = false; // Flag to ensure this runs only once
+    }
+
+    /**
+     * @param {null} todayPortfolio - Not used.
+     * @param {null} yesterdayPortfolio - Not used.
+     * @param {null} userId - Not used.
+     * @param {object} context - Shared context (e.g., mappings).
+     * @param {object} todayInsights - Daily instrument insights.
+     * @param {object} yesterdayInsights - Yesterday's instrument insights.
+     * @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) {
+        // This process should only run once per day
+        if (this.processed || !todaySocialPostInsights) {
+            return;
+        }
+        this.processed = true;
+
+        const posts = Object.values(todaySocialPostInsights);
+
+        for (const post of posts) {
+            const likeCount = post.likeCount || 0;
+            const commentCount = post.commentCount || 0;
+
+            // 1. Aggregate global counts
+            this.totalLikes += likeCount;
+            this.totalComments += commentCount;
+
+            // 2. Aggregate counts per ticker
+            if (post.tickers && Array.isArray(post.tickers)) {
+                for (const ticker of post.tickers) {
+                    if (!this.tickerActivity[ticker]) {
+                        this.tickerActivity[ticker] = {
+                            totalLikes: 0,
+                            totalComments: 0,
+                            totalPosts: 0
+                        };
+                    }
+                    this.tickerActivity[ticker].totalLikes += likeCount;
+                    this.tickerActivity[ticker].totalComments += commentCount;
+                    this.tickerActivity[ticker].totalPosts++;
+                }
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.processed) return {};
+
+        // Calculate average activity per ticker
+        const tickerAverageActivity = {};
+        for (const ticker in this.tickerActivity) {
+            const data = this.tickerActivity[ticker];
+            if (data.totalPosts > 0) {
+                tickerAverageActivity[ticker] = {
+                    avgLikesPerPost: data.totalLikes / data.totalPosts,
+                    avgCommentsPerPost: data.totalComments / data.totalPosts,
+                    ...data // Include total counts
+                };
+            } else {
+                tickerAverageActivity[ticker] = {
+                    avgLikesPerPost: 0,
+                    avgCommentsPerPost: 0,
+                    ...data
+                };
+            }
+        }
+
+        return {
+            globalActivity: {
+                totalLikes: this.totalLikes,
+                totalComments: this.totalComments,
+                totalPosts: Object.keys(todaySocialPostInsights || {}).length
+            },
+            tickerActivity: tickerAverageActivity
+        };
+    }
+
+    reset() {
+        this.tickerActivity = {};
+        this.totalLikes = 0;
+        this.totalComments = 0;
+        this.processed = false;
+    }
+}
+
+module.exports = SocialActivityAggregation;

package/calculations/socialPosts/social_event_correlation.js

@@ -0,0 +1,122 @@
+/**
+ * @fileoverview Correlates social post volume spikes with topics from Gemini analysis.
+ * This calculation ONLY uses the social post insights context.
+ */
+
+class SocialEventCorrelation {
+    constructor() {
+        this.todayTickerVolume = {};
+        this.yesterdayTickerVolume = {};
+        this.todayTopicCounts = {}; // { "TICKER": { "topic": count } }
+        this.processed = false;
+    }
+
+    /**
+     * Helper to process a set of posts and populate volume/topic counts.
+     * @param {object} socialPostInsights - Map of { [postId]: postData }
+     * @param {object} volumeTarget - The object to store volume counts.
+     * @param {object} [topicTarget] - Optional. The object to store topic counts.
+     */
+    _processPosts(socialPostInsights, volumeTarget, topicTarget = null) {
+        if (!socialPostInsights) return;
+        const posts = Object.values(socialPostInsights);
+
+        for (const post of posts) {
+            if (!post.tickers || !Array.isArray(post.tickers)) continue;
+
+            for (const ticker of post.tickers) {
+                // 1. Aggregate Volume
+                volumeTarget[ticker] = (volumeTarget[ticker] || 0) + 1;
+
+                // 2. Aggregate Topics (if target provided)
+                if (topicTarget) {
+                    if (!topicTarget[ticker]) {
+                        topicTarget[ticker] = {};
+                    }
+                    // New structure: post.sentiment is { overallSentiment: "...", topics: [...] }
+                    const topics = post.sentiment?.topics;
+                    if (topics && Array.isArray(topics)) {
+                        for (const topic of topics) {
+                            // Normalize topic to lowercase for consistent counting
+                            const normalizedTopic = topic.toLowerCase();
+                            topicTarget[ticker][normalizedTopic] = (topicTarget[ticker][normalizedTopic] || 0) + 1;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * @param {null} todayPortfolio - Not used.
+     * @param {null} yesterdayPortfolio - Not used.
+     * @param {null} userId - Not used.
+     * @param {object} context - Shared context (e.g., mappings).
+     * @param {object} todayInsights - Daily instrument insights.
+     * @param {object} yesterdayInsights - Yesterday's instrument insights.
+     * @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; // Run only once
+        }
+        this.processed = true;
+
+        // 1. Process yesterday's posts for baseline volume
+        this._processPosts(yesterdaySocialPostInsights, this.yesterdayTickerVolume);
+
+        // 2. Process today's posts for volume AND topic correlation
+        this._processPosts(todaySocialPostInsights, this.todayTickerVolume, this.todayTopicCounts);
+    }
+
+    async getResult() {
+        if (!this.processed) return {};
+
+        const results = {};
+        const allTickers = new Set([
+            ...Object.keys(this.todayTickerVolume),
+            ...Object.keys(this.yesterdayTickerVolume)
+        ]);
+
+        for (const ticker of allTickers) {
+            const todayVolume = this.todayTickerVolume[ticker] || 0;
+            // Use 1 as baseline if yesterday was 0 to avoid -100% change, but 0 for spike calc
+            const yesterdayVolumeForCalc = this.yesterdayTickerVolume[ticker] || 0;
+            
+            let volumeSpikePercent = 0;
+            if (yesterdayVolumeForCalc > 0) {
+                 volumeSpikePercent = ((todayVolume - yesterdayVolumeForCalc) / yesterdayVolumeForCalc) * 100;
+            } else if (todayVolume > 0) {
+                volumeSpikePercent = todayVolume * 100.0; // e.g., 0 to 5 posts is a 500% increase
+            }
+
+            // Only report tickers with activity today
+            if (todayVolume === 0) continue;
+
+            // Correlate topics
+            const topics = this.todayTopicCounts[ticker] || {};
+            const correlatedEvents = Object.entries(topics)
+                .map(([topic, postCount]) => ({ topic, postCount }))
+                .sort((a, b) => b.postCount - a.postCount); // Sort by count descending
+
+            results[ticker] = {
+                volume: todayVolume,
+                volumeSpikePercent: volumeSpikePercent,
+                correlatedEvents: correlatedEvents
+            };
+        }
+
+        return results;
+    }
+
+    reset() {
+        this.todayTickerVolume = {};
+        this.yesterdayTickerVolume = {};
+        this.todayTopicCounts = {};
+        this.processed = false;
+    }
+}
+
+module.exports = SocialEventCorrelation;

package/calculations/socialPosts/social_sentiment_aggregation.js

@@ -0,0 +1,112 @@
+/**
+ * @fileoverview Aggregates sentiment data from social posts.
+ * This calculation ONLY uses the social post insights context, not portfolio data.
+ */
+
+class SocialSentimentAggregation {
+    constructor() {
+        this.tickerSentiments = {};
+        this.totalPosts = 0;
+        this.sentimentCounts = {
+            Bullish: 0,
+            Bearish: 0,
+            Neutral: 0
+        };
+        this.processed = false; // Flag to ensure this runs only once
+    }
+
+    /**
+     * @param {null} todayPortfolio - Not used.
+     * @param {null} yesterdayPortfolio - Not used.
+     * @param {null} userId - Not used.
+     * @param {object} context - Shared context (e.g., mappings).
+     * @param {object} todayInsights - Daily instrument insights.
+     * @param {object} yesterdayInsights - Yesterday's instrument insights.
+     * @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) {
+        // This process should only run once per day, triggered by the first "user" (which is just a trigger).
+        if (this.processed || !todaySocialPostInsights) {
+            return;
+        }
+        this.processed = true;
+
+        const posts = Object.values(todaySocialPostInsights);
+        this.totalPosts = posts.length;
+
+        for (const post of posts) {
+            const sentiment = post.sentiment || 'Neutral';
+
+            // 1. Aggregate global sentiment counts
+            if (this.sentimentCounts.hasOwnProperty(sentiment)) {
+                this.sentimentCounts[sentiment]++;
+            }
+
+            // 2. Aggregate sentiment per ticker
+            if (post.tickers && Array.isArray(post.tickers)) {
+                for (const ticker of post.tickers) {
+                    if (!this.tickerSentiments[ticker]) {
+                        this.tickerSentiments[ticker] = {
+                            Bullish: 0,
+                            Bearish: 0,
+                            Neutral: 0,
+                            totalPosts: 0
+                        };
+                    }
+                    if (this.tickerSentiments[ticker].hasOwnProperty(sentiment)) {
+                        this.tickerSentiments[ticker][sentiment]++;
+                    }
+                    this.tickerSentiments[ticker].totalPosts++;
+                }
+            }
+        }
+    }
+
+    async getResult() {
+        if (!this.processed) return {};
+
+        // Calculate global sentiment ratio
+        let globalSentimentRatio = 0;
+        const totalSentiments = this.sentimentCounts.Bullish + this.sentimentCounts.Bearish;
+        if (totalSentiments > 0) {
+            globalSentimentRatio = (this.sentimentCounts.Bullish / totalSentiments) * 100;
+        }
+
+        // Calculate per-ticker sentiment ratios
+        const tickerSentimentRatios = {};
+        for (const ticker in this.tickerSentiments) {
+            const data = this.tickerSentiments[ticker];
+            const totalTickerSentiments = data.Bullish + data.Bearish;
+            if (totalTickerSentiments > 0) {
+                tickerSentimentRatios[ticker] = {
+                    sentimentRatio: (data.Bullish / totalTickerSentiments) * 100,
+                    ...data // Include counts
+                };
+            } else {
+                 tickerSentimentRatios[ticker] = {
+                    sentimentRatio: 50, // Default to neutral if no clear sentiment
+                    ...data // Include counts
+                };
+            }
+        }
+
+        return {
+            globalSentiment: {
+                ...this.sentimentCounts,
+                totalPosts: this.totalPosts,
+                sentimentRatio: globalSentimentRatio
+            },
+            tickerSentiment: tickerSentimentRatios
+        };
+    }
+
+    reset() {
+        this.tickerSentiments = {};
+        this.totalPosts = 0;
+        this.sentimentCounts = { Bullish: 0, Bearish: 0, Neutral: 0 };
+        this.processed = false;
+    }
+}
+
+module.exports = SocialSentimentAggregation;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiden-shared-calculations-unified",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "Shared calculation modules for the BullTrackers Computation System.",
   "main": "index.js",
   "files": [