aiden-shared-calculations-unified 1.0.64 → 1.0.65

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

@@ -1,62 +1,120 @@
 /**
- * @fileoverview Tracks daily mentions of a pre-defined list of keywords.
- * This calculation ONLY uses the social post insights context.
+ * @fileoverview Social Calculation (Pass 1)
+ *
+ * This metric answers: "How many times was each
+ * predefined keyword mentioned in posts today?"
+ *
+ * This is a stateful calculation.
  */
-
 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;
+        // { [keyword]: { count: 0, history: [] } }
+        this.keywordData = new Map();
+        // Keywords are loaded from config
+        this.keywords = []; 
     }
 
     /**
-     * @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 keywordSchema = {
+            "type": "object",
+            "description": "Daily and trended post count for a specific keyword.",
+            "properties": {
+                "count": {
+                    "type": "number",
+                    "description": "Today's raw mention count."
+                },
+                "trend_30d_pct": {
+                    "type": "number",
+                    "description": "Percentage change from the 30-day average count."
+                },
+                "history_30d": {
+                    "type": "array",
+                    "description": "30-day history of mention counts (today first).",
+                    "items": { "type": "number" }
+                }
+            },
+            "required": ["count", "trend_30d_pct", "history_30d"]
+        };
 
-        // Initialize all keywords with 0 counts
-        this.mentions = this.KEYWORDS.reduce((acc, key) => {
-            acc[key] = 0;
-            return acc;
-        }, {});
+        return {
+            "type": "object",
+            "description": "Tracks the daily mention count and 30-day trend for predefined keywords.",
+            "patternProperties": {
+                "^.*$": keywordSchema // Keyword
+            },
+            "additionalProperties": keywordSchema
+        };
+    }
+
+    /**
+     * @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 keywords from config (or another source)
+        this.keywords = config.trackedKeywords || ['inflation', 'fed', 'AI', 'crypto', 'recession'];
 
-        const posts = Object.values(todaySocialPostInsights);
+        // 2. Load this metric's history from yesterday
+        const yHistoryData = await calculationUtils.loadYesterdayData('social-word-mentions-trend');
 
-        for (const post of posts) {
-            const text = post.fullText?.toLowerCase() || '';
-            if (!text) continue;
+        // 3. Initialize state for all keywords
+        for (const keyword of this.keywords) {
+            this.keywordData.set(keyword, {
+                count: 0,
+                history: yHistoryData?.[keyword]?.history_30d || []
+            });
+        }
+        
+        // 4. Process today's raw social data
+        const todaySocialPosts = await calculationUtils.loadSocialData(dateStr); 
 
-            for (const keyword of this.KEYWORDS) {
-                // Count once per post, even if mentioned multiple times
-                if (text.includes(keyword)) {
-                    this.mentions[keyword]++;
+        for (const post of todaySocialPosts) {
+            const text = (post.content || '').toLowerCase();
+            
+            for (const keyword of this.keywords) {
+                if (text.includes(keyword.toLowerCase())) {
+                    this.keywordData.get(keyword).count++;
                 }
             }
         }
     }
 
     async getResult() {
-        // Returns an object like: { "inflation": 5, "fed": 12, "ai": 30 }
-        return this.mentions;
+        const result = {};
+        for (const [keyword, data] of this.keywordData.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[keyword] = {
+                count: todayCount,
+                trend_30d_pct: trend_30d_pct,
+                history_30d: newHistory
+            };
+        }
+        return result;
     }
 
     reset() {
-        this.mentions = {};
-        this.processed = false;
+        this.keywordData.clear();
+        this.keywords = [];
     }
 }
 

package/calculations/socialPosts/social_activity_aggregation.js

@@ -1,103 +1,132 @@
 /**
- * @fileoverview Aggregates activity data (likes, comments) from social posts.
- * This calculation ONLY uses the social post insights context, not portfolio data.
+ * @fileoverview Social Calculation (Pass 1)
+ *
+ * This metric answers: "What is the total and average number
+ * of likes and comments on social media posts, both globally
+ * and per ticker?"
  */
-
 class SocialActivityAggregation {
     constructor() {
-        this.tickerActivity = {};
-        this.totalLikes = 0;
-        this.totalComments = 0;
-        this.totalPosts = 0; // <-- ADD THIS LINE
-        this.processed = false; // Flag to ensure this runs only once
+        this.global = {
+            total_posts: 0,
+            total_likes: 0,
+            total_comments: 0
+        };
+        // { [ticker]: { total_posts: 0, total_likes: 0, total_comments: 0 } }
+        this.perTicker = new Map();
     }
 
     /**
-     * @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.
+     * Defines the output schema for this calculation.
+     * @returns {object} JSON Schema object
      */
-    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;
-        this.totalPosts = Object.keys(todaySocialPostInsights).length;
+    static getSchema() {
+        const statsSchema = {
+            "type": "object",
+            "properties": {
+                "total_posts": { "type": "number" },
+                "total_likes": { "type": "number" },
+                "total_comments": { "type": "number" },
+                "avg_likes_per_post": { "type": "number" },
+                "avg_comments_per_post": { "type": "number" }
+            },
+            "required": ["total_posts", "total_likes", "total_comments", "avg_likes_per_post", "avg_comments_per_post"]
+        };
 
-        const posts = Object.values(todaySocialPostInsights);
+        return {
+            "type": "object",
+            "description": "Aggregates social activity (posts, likes, comments) globally and per ticker.",
+            "properties": {
+                "global_activity": {
+                    ...statsSchema,
+                    "description": "Aggregated activity across all posts."
+                },
+                "per_ticker": {
+                    "type": "object",
+                    "description": "Aggregated activity broken down by asset ticker.",
+                    "patternProperties": {
+                        "^.*$": {
+                            ...statsSchema,
+                            "description": "Aggregated activity for a specific ticker."
+                        } // Ticker
+                    },
+                    "additionalProperties": statsSchema
+                }
+            },
+            "required": ["global_activity", "per_ticker"]
+        };
+    }
 
-        for (const post of posts) {
-            const likeCount = post.likeCount || 0;
-            const commentCount = post.commentCount || 0;
+    _initTicker(ticker) {
+        if (!this.perTicker.has(ticker)) {
+            this.perTicker.set(ticker, {
+                total_posts: 0,
+                total_likes: 0,
+                total_comments: 0
+            });
+        }
+    }
 
-            // 1. Aggregate global counts
-            this.totalLikes += likeCount;
-            this.totalComments += commentCount;
+    /**
+     * @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 { calculationUtils } = dependencies;
+        const todaySocialPosts = await calculationUtils.loadSocialData(dateStr); 
 
-            // 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++;
-                }
+        for (const post of todaySocialPosts) {
+            const likes = post.likes || 0;
+            const comments = post.comments || 0;
+            
+            // 1. Aggregate global stats
+            this.global.total_posts++;
+            this.global.total_likes += likes;
+            this.global.total_comments += comments;
+            
+            // 2. Aggregate per-ticker stats
+            const tickers = post.tickers || [];
+            for (const ticker of tickers) {
+                this._initTicker(ticker);
+                const data = this.perTicker.get(ticker);
+                data.total_posts++;
+                data.total_likes += likes;
+                data.total_comments += comments;
             }
         }
     }
+    
+    _calculateAverages(data) {
+        const posts = data.total_posts;
+        return {
+            ...data,
+            avg_likes_per_post: (posts > 0) ? (data.total_likes / posts) : 0,
+            avg_comments_per_post: (posts > 0) ? (data.total_comments / posts) : 0
+        };
+    }
 
     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
-                };
-            }
+        // Calculate averages for global
+        const global_activity = this._calculateAverages(this.global);
+        
+        // Calculate averages for per-ticker
+        const per_ticker = {};
+        for (const [ticker, data] of this.perTicker.entries()) {
+            per_ticker[ticker] = this._calculateAverages(data);
         }
-
+        
         return {
-            globalActivity: {
-                totalLikes: this.totalLikes,
-                totalComments: this.totalComments,
-                totalPosts: this.totalPosts
-                // --- END FIX ---
-            },
-            tickerActivity: tickerAverageActivity
+            global_activity,
+            per_ticker
         };
     }
 
     reset() {
-        this.tickerActivity = {};
-        this.totalLikes = 0;
-        this.totalComments = 0;
-        this.totalPosts = 0; 
-        this.processed = false;
+        this.global = { total_posts: 0, total_likes: 0, total_comments: 0 };
+        this.perTicker.clear();
     }
 }
 
-module.exports = SocialActivityAggregation;
+module.exports = SocialActivityAggregation;

package/calculations/socialPosts/social_sentiment_aggregation.js

@@ -1,114 +1,143 @@
 /**
- * @fileoverview Aggregates sentiment data from social posts.
- * This calculation ONLY uses the social post insights context, not portfolio data.
- * UPDATED: To read sentiment from the `sentiment.overallSentiment` property.
+ * @fileoverview Social Calculation (Pass 1)
+ *
+ * This metric answers: "What is the aggregated social media
+ * sentiment (bullish, bearish, neutral) globally and
+ * for each ticker?"
  */
-
 class SocialSentimentAggregation {
     constructor() {
-        this.tickerSentiments = {};
-        this.totalPosts = 0;
-        this.sentimentCounts = {
-            Bullish: 0,
-            Bearish: 0,
-            Neutral: 0
+        this.global = {
+            bullish: 0,
+            bearish: 0,
+            neutral: 0
         };
-        this.processed = false; // Flag to ensure this runs only once
+        // { [ticker]: { bullish: 0, bearish: 0, neutral: 0 } }
+        this.perTicker = new Map();
     }
 
     /**
-     * @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.
+     * Defines the output schema for this calculation.
+     * @returns {object} JSON Schema object
      */
-    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;
+    static getSchema() {
+        const sentimentSchema = {
+            "type": "object",
+            "properties": {
+                "bullish": { "type": "number" },
+                "bearish": { "type": "number" },
+                "neutral": { "type": "number" },
+                "total_posts": { "type": "number" },
+                "net_sentiment": { "type": "number" },
+                "net_sentiment_pct": { "type": "number" }
+            },
+            "required": ["bullish", "bearish", "neutral", "total_posts", "net_sentiment", "net_sentiment_pct"]
+        };
 
-        const posts = Object.values(todaySocialPostInsights);
-        this.totalPosts = posts.length;
+        return {
+            "type": "object",
+            "description": "Aggregates social sentiment (bullish, bearish) globally and per ticker.",
+            "properties": {
+                "global_sentiment": {
+                    ...sentimentSchema,
+                    "description": "Aggregated sentiment across all posts."
+                },
+                "per_ticker": {
+                    "type": "object",
+                    "description": "Aggregated sentiment broken down by asset ticker.",
+                    "patternProperties": {
+                        "^.*$": {
+                            ...sentimentSchema,
+                            "description": "Aggregated sentiment for a specific ticker."
+                        } // Ticker
+                    },
+                    "additionalProperties": sentimentSchema
+                }
+            },
+            "required": ["global_sentiment", "per_ticker"]
+        };
+    }
 
-        for (const post of posts) {
-            // --- FIX: Read from the nested overallSentiment property ---
-            const sentiment = post.sentiment?.overallSentiment || 'Neutral';
-            // --- END FIX ---
+    _initTicker(ticker) {
+        if (!this.perTicker.has(ticker)) {
+            this.perTicker.set(ticker, {
+                bullish: 0,
+                bearish: 0,
+                neutral: 0
+            });
+        }
+    }
 
-            // 1. Aggregate global sentiment counts
-            if (this.sentimentCounts.hasOwnProperty(sentiment)) {
-                this.sentimentCounts[sentiment]++;
-            }
+    /**
+     * @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 { calculationUtils } = dependencies;
+        const todaySocialPosts = await calculationUtils.loadSocialData(dateStr); 
 
-            // 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++;
+        for (const post of todaySocialPosts) {
+            const sentiment = post.sentiment || 'neutral'; // 'bullish', 'bearish', 'neutral'
+            
+            // 1. Aggregate global sentiment
+            if (sentiment === 'bullish') {
+                this.global.bullish++;
+            } else if (sentiment === 'bearish') {
+                this.global.bearish++;
+            } else {
+                this.global.neutral++;
+            }
+            
+            // 2. Aggregate per-ticker sentiment
+            const tickers = post.tickers || [];
+            for (const ticker of tickers) {
+                this._initTicker(ticker);
+                const data = this.perTicker.get(ticker);
+                
+                if (sentiment === 'bullish') {
+                    data.bullish++;
+                } else if (sentiment === 'bearish') {
+                    data.bearish++;
+                } else {
+                    data.neutral++;
                 }
             }
         }
     }
+    
+    _calculateSentiment(data) {
+        const total = data.bullish + data.bearish + data.neutral;
+        const net = data.bullish - data.bearish;
+        return {
+            ...data,
+            total_posts: total,
+            net_sentiment: net,
+            // Net sentiment as a percentage of *all* posts (bullish, bearish, neutral)
+            net_sentiment_pct: (total > 0) ? (net / total) * 100 : 0
+        };
+    }
 
     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 stats for global
+        const global_sentiment = this._calculateSentiment(this.global);
+        
+        // Calculate stats for per-ticker
+        const per_ticker = {};
+        for (const [ticker, data] of this.perTicker.entries()) {
+            per_ticker[ticker] = this._calculateSentiment(data);
         }
-
-        // 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
+            global_sentiment,
+            per_ticker
         };
     }
 
     reset() {
-        this.tickerSentiments = {};
-        this.totalPosts = 0;
-        this.sentimentCounts = { Bullish: 0, Bearish: 0, Neutral: 0 };
-        this.processed = false;
+        this.global = { bullish: 0, bearish: 0, neutral: 0 };
+        this.perTicker.clear();
     }
 }