aiden-shared-calculations-unified 1.0.82 → 1.0.84

package/calculations/core/social-sentiment-aggregation.js

@@ -1,172 +1,90 @@
 /**
- * @fileoverview Social Calculation (Pass 1)
- *
- * This metric answers: "What is the aggregated social media
- * sentiment (bullish, bearish, neutral) globally and
- * for each ticker?"
- *
- * --- MODIFIED ---
- * Changed `process` method to read from `dependencies.rootData.todaySocialPostInsights`
- * instead of a non-existent `calculationUtils.loadSocialData`.
+ * @fileoverview Calculation (Pass 2 - Meta) for social sentiment.
+ * --- FIX ---
+ * 1. Changed 'process' signature to 5-arg 'meta' standard.
+ * 2. Changed data access to read 'dateStr.social' (Arg 1).
+ * 3. Changed 'socialDoc.posts' (Object) to 'socialDoc' (Object).
+ * 4. Changed 'post.sentiment.label' to 'post.sentiment.overallSentiment'.
  */
 class SocialSentimentAggregation {
+
     constructor() {
-        this.global = {
-            bullish: 0,
-            bearish: 0,
-            neutral: 0
+        this.result = {};
+    }
+
+    static getMetadata() {
+        return {
+            type: 'meta',
+            rootDataDependencies: ['social'],
+            isHistorical: false,
+            userType: 'n/a',
+            category: 'core_social'
         };
-        // { [ticker]: { bullish: 0, bearish: 0, neutral: 0 } }
-        this.perTicker = new Map();
     }
 
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
+    static getDependencies() {
+        return [];
+    }
+
     static getSchema() {
-        const sentimentSchema = {
+        return {
             "type": "object",
+            "description": "Aggregates the overall social sentiment for the day.",
             "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"]
-        };
-
-        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
-                }
+                "sentiment_score": { "type": "number", "description": "Net score (bullish-bearish) / total" }
             },
-            "required": ["global_sentiment", "per_ticker"]
+            "required": ["bullish", "bearish", "neutral", "total_posts", "sentiment_score"]
         };
     }
 
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
-    static getMetadata() {
-        return {
-            type: 'meta',
-            rootDataDependencies: ['social'],
-            isHistorical: false,
-            userType: 'n/a',
-            category: 'core_metrics'
-        };
-    }
+    // --- THIS IS THE FIX ---
+    async process(dateStr, rootData, dependencies, config, fetchedDependencies) {
+        const counts = { bullish: 0, bearish: 0, neutral: 0 };
+        let totalPosts = 0;
 
-    /**
-     * Statically declare dependencies.
-     */
-    static getDependencies() {
-        return [];
-    }
+        // Get social data from Arg 1 (metaPayload)
+        const socialDoc = dateStr.social; // This IS the map of posts
 
-    _initTicker(ticker) {
-        if (!this.perTicker.has(ticker)) {
-            this.perTicker.set(ticker, {
-                bullish: 0,
-                bearish: 0,
-                neutral: 0
-            });
+        if (!socialDoc || typeof socialDoc !== 'object') {
+            this.result = { bullish: 0, bearish: 0, neutral: 0, total_posts: 0, sentiment_score: 0 };
+            return;
         }
-    }
 
-    /**
-     * @param {string} dateStr - Today's date.
-     * @param {object} dependencies - db, logger, calculationUtils, AND rootData.
-     * @param {object} config - Computation config.
-     * @param {object} fetchedDependencies - (UNUSED) In-memory results.
-     */
-    async process(dateStr, dependencies, config, fetchedDependencies) {
-        // --- MODIFIED ---
-        // 'meta' calcs get rootData injected into the dependencies object.
-        const todaySocialPosts = dependencies.rootData?.todaySocialPostInsights || {}; 
-        // --- END MODIFIED ---
+        const postsArray = Object.values(socialDoc);
+        totalPosts = postsArray.length;
 
-        for (const post of Object.values(todaySocialPosts)) {
-            // This logic assumes 'sentiment' is a simple string,
-            // not the object from gemini. This is correct for this calc.
-            // --- MODIFIED: Read from structured sentiment object ---
-            const sentiment = post.sentiment?.overallSentiment?.toLowerCase() || '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++;
-                }
+        for (const post of postsArray) {
+            // Use 'overallSentiment' and convert to lowercase
+            const sentiment = (post.sentiment?.overallSentiment || 'neutral').toLowerCase();
+            if (counts.hasOwnProperty(sentiment)) {
+                counts[sentiment]++;
             }
         }
-    }
-    
-    _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
+
+        const score = (totalPosts > 0) 
+            ? ((counts.bullish - counts.bearish) / totalPosts) 
+            : 0;
+
+        this.result = {
+            bullish: counts.bullish,
+            bearish: counts.bearish,
+            neutral: counts.neutral,
+            total_posts: totalPosts,
+            sentiment_score: score
         };
     }
+    // --- END FIX ---
 
-    async getResult() {
-        // 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);
-        }
-        
-        return {
-            global_sentiment,
-            per_ticker
-        };
+    async getResult(fetchedDependencies) {
+        return this.result;
     }
 
     reset() {
-        this.global = { bullish: 0, bearish: 0, neutral: 0 };
-        this.perTicker.clear();
+        this.result = {};
     }
 }
 

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

@@ -1,146 +1,114 @@
 /**
- * @fileoverview Social Calculation (Pass 1)
- *
- * This metric answers: "What are the top 50 most mentioned
- * words in social media posts today, and what is their
- * trend since yesterday?"
- *
- * This is a stateful calculation.
+ * @fileoverview Calculation (Pass 2 - Meta) for social top words.
+ * --- FIX ---
+ * 1. Changed logic to read from 'socialDoc' directly, not 'socialDoc.posts'.
+ * 2. Changed tokenizer to read from 'post.textSnippet' to match schema.md.
  */
+const STOPWORDS = new Set([
+    'a', 'an', 'the', 'is', 'are', 'was', 'were', 'be', 'being', 'been',
+    'it', 'its', 'it\'s', 'i', 'me', 'my', 'mine', 'you', 'your', 'yours',
+    'he', 'him', 'his', 'she', 'her', 'hers', 'they', 'them', 'their', 'theirs',
+    'we', 'us', 'our', 'ours', 'what', 'which', 'who', 'whom', 'this', 'that',
+    'these', 'those', 'am', 'and', 'but', 'if', 'or', 'because', 'as', 'until',
+    'while', 'of', 'at', 'by', 'for', 'with', 'about', 'against', 'between',
+    'into', 'through', 'during', 'before', 'after', 'above', 'below', 'to',
+    'from', 'up', 'down', 'in', 'out', 'on', 'off', 'over', 'under', 'again',
+    'further', 'then', 'once', 'here', 'there', 'when', 'where', 'why', 'how',
+    'all', 'any', 'both', 'each', 'few', 'more', 'most', 'other', 'some',
+    'such', 'no', 'nor', 'not', 'only', 'own', 'same', 'so', 'than', 'too',
+    'very', 's', 't', 'can', 'will', 'just', 'don', 'should', 'now',
+    'stock', 'stocks', 'market', 'price', 'trade', 'trading', 'buy', 'sell',
+    'long', 'short', 'chart', 'week', 'day', 'today', 'going', 'think'
+]);
+
 class SocialTopMentionedWords {
+
     constructor() {
-        // { [word]: { count: 0, history: [] } }
-        this.wordCounts = new Map();
-        // A set of common words to ignore
-        this.stopWords = new Set(['the', 'a', 'is', 'in', 'to', 'for', 'of', 'and', 'it', 'on', 'with', 'that', 'this', 'buy', 'sell']);
+        this.result = {};
     }
 
-    // --- NEW ---
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'meta',
             rootDataDependencies: ['social'],
-            isHistorical: false, // Stateful
-            userType: 'n/a',
+            isHistorical: false,
+            userType: 'n'/'a',
             category: 'core_social'
         };
     }
 
-    // --- NEW ---
-    /**
-     * Statically declare dependencies.
-     */
     static getDependencies() {
         return [];
     }
 
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
     static getSchema() {
         const wordSchema = {
             "type": "object",
-            "properties": {
-                "word": { "type": "string" },
-                "count": { "type": "number" },
-                "trend_30d_pct": { "type": "number" },
-                "history_30d": { "type": "array", "items": { "type": "number" } }
-            },
-            "required": ["word", "count", "trend_30d_pct", "history_30d"]
+            "properties": { "count": { "type": "number" } }
         };
 
         return {
-            "type": "array",
-            "description": "Top 50 most mentioned words (non-stop words) with their 30-day trend.",
-            "items": wordSchema
+            "type": "object",
+            "description": "Calculates the top 50 most mentioned words in social posts.",
+            "patternProperties": { "^.*$": wordSchema },
+            "additionalProperties": wordSchema
         };
     }
 
-    // --- REFACTORED ---
-    /**
-     * @param {string} dateStr - Today's date.
-     * @param {object} rootData - The root data object.
-     * @param {object} dependencies - db, logger, calculationUtils
-     */
-    async process(dateStr, rootData, dependencies) {
-        const { calculationUtils } = dependencies;
-        
-        // 1. Load this metric's history from yesterday
-        // Note: History is stored by word
-        const yHistoryData = await calculationUtils.loadYesterdayData('social-top-mentioned-words-history'); // Fictional helper
-        
-        if (yHistoryData) {
-            for (const [word, data] of Object.entries(yHistoryData)) {
-                this.wordCounts.set(word, {
-                    count: 0,
-                    history: data.history_30d || []
-                });
-            }
+    _tokenize(text) {
+        if (!text) return [];
+        return text.toLowerCase()
+            .replace(/[^\w\s$]/g, '') 
+            .split(/\s+/) 
+            .filter(word => 
+                word.length > 2 &&      
+                !STOPWORDS.has(word) &&    
+                !/^\d+$/.test(word)        
+            );
+    }
+
+    async process(dateStr, rootData, dependencies, config, fetchedDependencies) {
+        const wordCounts = new Map();
+
+        // 'dateStr' (Arg 1) is the metaPayload from the worker
+        const socialDoc = dateStr.social; // This IS the map of posts
+
+        // --- THIS IS THE FIX (Part 1) ---
+        // 'socialDoc' is the map of posts, not an object containing .posts
+        if (!socialDoc || typeof socialDoc !== 'object') {
+        // --- END FIX (Part 1) ---
+            this.result = {};
+            return;
         }
-        
-        // 2. Process today's raw social data
-        const todaySocialPosts = rootData.todaySocialPostInsights || {}; 
-
-        for (const post of Object.values(todaySocialPosts)) {
-            // Use `fullText` for complete analysis
-            const text = (post.fullText || '').toLowerCase().replace(/[^a-z\s]/g, '');
-            const words = text.split(/\s+/);
-            
+
+        for (const post of Object.values(socialDoc)) {
+            // --- THIS IS THE FIX (Part 2) ---
+            // schema.md provides 'textSnippet', not 'fullText'
+            const words = this._tokenize(post.textSnippet); 
+            // --- END FIX (Part 2) ---
             for (const word of words) {
-                if (word.length > 2 && !this.stopWords.has(word)) {
-                    if (!this.wordCounts.has(word)) {
-                        this.wordCounts.set(word, { count: 0, history: [] });
-                    }
-                    this.wordCounts.get(word).count++;
-                }
+                wordCounts.set(word, (wordCounts.get(word) || 0) + 1);
             }
         }
-    }
 
-    async getResult() {
-        const allWords = [];
-        
-        for (const [word, data] of this.wordCounts.entries()) {
-            const history = data.history;
-            const todayCount = data.count;
-            
-            // Don't include words that weren't mentioned today
-            if (todayCount === 0) continue; 
-
-            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;
-                }
-            }
+        const sortedWords = Array.from(wordCounts.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 50);
 
-            allWords.push({
-                word: word,
-                count: todayCount,
-                trend_30d_pct: trend_30d_pct,
-                history_30d: newHistory
-            });
+        const result = {};
+        for (const [word, count] of sortedWords) {
+            result[word] = { count: count };
         }
-        
-        // Sort by today's count and take top 50
-        allWords.sort((a, b) => b.count - a.count);
-        
-        // The *full* result (for history) should be saved to a different
-        // doc ('social-top-mentioned-words-history') by the computation system.
-        
-        // Return only the top 50 for the API.
-        return allWords.slice(0, 50);
+
+        this.result = result;
+    }
+
+    async getResult(fetchedDependencies) {
+        return this.result;
     }
 
     reset() {
-        this.wordCounts.clear();
+        this.result = {};
     }
 }