aiden-shared-calculations-unified 1.0.82 → 1.0.84

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

@@ -1,141 +1,124 @@
 /**
- * @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.
+ * @fileoverview Calculation (Pass 2 - Meta) for social posts trend.
+ * --- 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.timestamp' to 'post.createdAt'.
+ * 5. Changed 'post.instrumentIds' to 'post.tickers'.
+ * 6. Removed 'instrumentToTicker' mapping as 'post.tickers' is already tickers.
  */
+
 class SocialAssetPostsTrend {
+
     constructor() {
-        // { [ticker]: { count: 0, history: [] } }
-        this.assetData = new Map();
+        this.result = {};
     }
 
-    // --- NEW ---
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
             type: 'meta',
-            rootDataDependencies: ['social'], // Needs social posts
-            isHistorical: false, // It's stateful, but reads its *own* history
+            rootDataDependencies: ['social'],
+            isHistorical: true,
             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 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" }
-                }
+                "posts_1d_pct": { "type": "number" },
+                "posts_7d_pct": { "type": "number" },
+                "trend_ratio": { "type": ["number", "null"] }
             },
-            "required": ["count", "trend_30d_pct", "history_30d"]
+            "required": ["posts_1d_pct", "posts_7d_pct", "trend_ratio"]
         };
 
         return {
             "type": "object",
-            "description": "Tracks the daily post count and 30-day trend for each asset ticker.",
-            "patternProperties": {
-                "^.*$": tickerSchema // Ticker
-            },
+            "description": "Calculates the 1-day vs 7-day percentage of total posts for each asset.",
+            "patternProperties": { "^.*$": tickerSchema },
             "additionalProperties": tickerSchema
         };
     }
 
-    // --- 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
-        // The runner must provide `loadYesterdayData` on calculationUtils
-        const yHistoryData = await calculationUtils.loadYesterdayData('social-asset-posts-trend');
-
-        // 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 || []
-                });
-            }
+    // --- THIS IS THE FIX ---
+    async process(dateStr, rootData, dependencies, config, fetchedDependencies) {
+
+        // Get social data from Arg 1 (metaPayload)
+        const socialDoc = dateStr.social; // This IS the map of posts
+        // Get the date from Arg 1
+        const todayDateStr = dateStr.date;
+
+        if (!socialDoc || typeof socialDoc !== 'object' || !todayDateStr) {
+            this.result = {};
+            return;
         }
-        
-        // 3. Process today's raw social data
-        const todaySocialPosts = rootData.todaySocialPostInsights || {}; 
-
-        for (const post of Object.values(todaySocialPosts)) {
-            const tickers = post.tickers || [];
-            for (const ticker of tickers) {
-                if (!this.assetData.has(ticker)) {
-                    this.assetData.set(ticker, { count: 0, history: [] });
+
+        const today = new Date(todayDateStr + 'T00:00:00Z');
+        const sevenDaysAgo = new Date(today);
+        sevenDaysAgo.setUTCDate(today.getUTCDate() - 7);
+
+        const counts1d = new Map();
+        const counts7d = new Map();
+        let total1d = 0;
+        let total7d = 0;
+
+        for (const post of Object.values(socialDoc)) {
+            const postDate = new Date(post.createdAt); // Use 'createdAt'
+            const is1d = postDate.toISOString().slice(0, 10) === todayDateStr;
+            const is7d = postDate >= sevenDaysAgo;
+
+            if (!is7d) continue; 
+
+            // Use 'tickers' array directly from schema
+            for (const ticker of (post.tickers || [])) {
+                if (!ticker) continue;
+
+                if (is7d) {
+                    counts7d.set(ticker, (counts7d.get(ticker) || 0) + 1);
+                    total7d++;
+                }
+                if (is1d) {
+                    counts1d.set(ticker, (counts1d.get(ticker) || 0) + 1);
+                    total1d++;
                 }
-                const data = this.assetData.get(ticker);
-                data.count++;
             }
         }
-    }
 
-    async getResult() {
         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;
-                }
-            }
+        const allTickers = new Set([...counts1d.keys(), ...counts7d.keys()]);
+
+        for (const ticker of allTickers) {
+            const c1 = counts1d.get(ticker) || 0;
+            const c7 = counts7d.get(ticker) || 0;
+
+            const pct1d = (total1d > 0) ? (c1 / total1d) * 100 : 0;
+            const pct7d = (total7d > 0) ? (c7 / total7d) * 100 : 0;
 
             result[ticker] = {
-                count: todayCount,
-                trend_30d_pct: trend_30d_pct,
-                history_30d: newHistory
+                posts_1d_pct: pct1d,
+                posts_7d_pct: pct7d,
+                trend_ratio: (pct7d > 0) ? (pct1d / pct7d) : null
             };
         }
-        return result;
+
+        this.result = result;
+    }
+    // --- END FIX ---
+
+    async getResult(fetchedDependencies) {
+        return this.result;
     }
 
     reset() {
-        this.assetData.clear();
+        this.result = {};
     }
 }
 

package/calculations/core/social-event-correlation.js

@@ -1,143 +1,124 @@
 /**
- * @fileoverview Correlates social post volume spikes with topics from Gemini analysis.
- * This calculation ONLY uses the social post insights context.
+ * @fileoverview Calculation (Pass 2 - Meta) for social event correlation.
+ * --- FIX ---
+ * 1. Changed 'process' signature to 5-arg 'meta' standard.
+ * 2. Changed data access to read 'dateStr.social' (Arg 1).
+ * 3. Changed 'socialDoc.posts' to 'socialDoc' (Object).
+ * 4. **Rewrote logic** to infer events from 'post.pollData' and
+ * 'post.sentiment.topics' as 'post.event' does not exist in schema.
  */
-
 class SocialEventCorrelation {
+
     constructor() {
-        this.todayTickerVolume = {};
-        this.yesterdayTickerVolume = {};
-        this.todayTopicCounts = {}; // { "TICKER": { "topic": count } }
-        this.processed = false;
+        this.result = {};
     }
 
-    // --- NEW ---
-    /**
-     * Statically defines all metadata for the manifest builder.
-     */
     static getMetadata() {
         return {
-            type: 'standard', // Runs per-user, but only executes logic once
+            type: 'meta',
             rootDataDependencies: ['social'],
-            isHistorical: true, // Needs yesterday's social posts
-            userType: 'all', // Runs on the first user and then stops
+            isHistorical: false,
+            userType: 'n/a',
             category: 'core_social'
         };
     }
 
-    // --- NEW ---
-    /**
-     * Statically declare dependencies.
-     */
     static getDependencies() {
         return [];
     }
 
-    /**
-     * 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;
-                        }
-                    }
-                }
+    static getSchema() {
+        const eventSchema = {
+            "type": "object",
+            "properties": {
+                "topic_distribution": { "type": "object" },
+                "sentiment_distribution": { "type": "object" },
+                "post_count": { "type": "number" }
+            }
+        };
+
+        return {
+            "type": "object",
+            "description": "Correlates social events (e.g., 'poll') with topic and sentiment distributions.",
+            "properties": {
+                "poll": eventSchema,
+                "earnings": eventSchema, // Inferred from topics
+                "launch": eventSchema // Inferred from topics
             }
+        };
+    }
+
+    _initEvent(result, eventName) {
+        if (!result[eventName]) {
+            result[eventName] = {
+                topic_distribution: {},
+                sentiment_distribution: {},
+                post_count: 0
+            };
         }
     }
 
-    /**
-     * @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 - (Not used)
-     * @param {object} yesterdayInsights - (Not used)
-     * @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 IS THE FIX ---
+    async process(dateStr, rootData, dependencies, config, fetchedDependencies) {
+        const result = {};
+
+        // Get social data from Arg 1 (metaPayload)
+        const socialDoc = dateStr.social; // This IS the map of posts
+
+        if (!socialDoc || typeof socialDoc !== 'object') {
+            this.result = {};
+            return;
         }
-        this.processed = true;
 
-        // 1. Process yesterday's posts for baseline volume
-        this._processPosts(yesterdaySocialPostInsights, this.yesterdayTickerVolume);
+        for (const post of Object.values(socialDoc)) {
 
-        // 2. Process today's posts for volume AND topic correlation
-        this._processPosts(todaySocialPostInsights, this.todayTickerVolume, this.todayTopicCounts);
-    }
+            // Infer events from schema.md fields
+            const topics = post.sentiment?.topics || [];
+            const sentiment = post.sentiment?.overallSentiment || 'Neutral';
+
+            const detectedEvents = new Set();
 
-    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
+            // Event 1: Check for Polls
+            if (post.pollData) {
+                detectedEvents.add('poll');
             }
 
-            // Only report tickers with activity today
-            if (todayVolume === 0) continue;
+            // Event 2: Check for Topics as Events
+            if (topics.includes('Earnings')) {
+                detectedEvents.add('earnings');
+            }
+            // Add any other topic-based events you want to track
+            // if (topics.includes('Launch')) {
+            //     detectedEvents.add('launch');
+            // }
 
-            // 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
+            if (detectedEvents.size === 0) continue;
 
-            results[ticker] = {
-                volume: todayVolume,
-                volumeSpikePercent: volumeSpikePercent,
-                correlatedEvents: correlatedEvents
-            };
+            for (const eventName of detectedEvents) {
+                this._initEvent(result, eventName);
+                const eventData = result[eventName];
+                eventData.post_count++;
+
+                // Aggregate topics
+                for (const topic of topics) {
+                    eventData.topic_distribution[topic] = (eventData.topic_distribution[topic] || 0) + 1;
+                }
+
+                // Aggregate sentiment
+                eventData.sentiment_distribution[sentiment] = (eventData.sentiment_distribution[sentiment] || 0) + 1;
+            }
         }
 
-        return results;
+        this.result = result;
+    }
+    // --- END FIX ---
+
+    async getResult(fetchedDependencies) {
+        return this.result;
     }
 
     reset() {
-        this.todayTickerVolume = {};
-        this.yesterdayTickerVolume = {};
-        this.todayTopicCounts = {};
-        this.processed = false;
+        this.result = {};
     }
 }