aiden-shared-calculations-unified 1.0.83 → 1.0.86

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

@@ -1,145 +1,131 @@
 /**
- * @fileoverview Social Calculation (Pass 1)
- *
- * This metric answers: "How many times was each
- * predefined keyword mentioned in posts today?"
- *
- * This is a stateful calculation.
+ * @fileoverview Calculation (Pass 2 - Meta) for social word 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' (Array) to 'socialDoc' (Object).
+ * 4. Changed 'post.timestamp' to 'post.createdAt'.
+ * 5. Changed 'post.content' to 'post.textSnippet'.
  */
+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 SocialWordMentionsTrend {
+
     constructor() {
-        // { [keyword]: { count: 0, history: [] } }
-        this.keywordData = new Map();
-        // Keywords are loaded from config
-        this.keywords = []; 
+        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: true, // Needs 7 days of posts
+            userType: 'n'/'a',
             category: 'core_social'
         };
     }
 
-    // --- NEW ---
-    /**
-     * Statically declare dependencies.
-     */
     static getDependencies() {
-        return [];
+        return ['social-top-mentioned-words'];
     }
 
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
     static getSchema() {
-        const keywordSchema = {
+        const wordSchema = {
             "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"]
+                "count_1d": { "type": "number" },
+                "count_7d": { "type": "number" }
+            }
         };
 
         return {
             "type": "object",
-            "description": "Tracks the daily mention count and 30-day trend for predefined keywords.",
-            "patternProperties": {
-                "^.*$": keywordSchema // Keyword
-            },
-            "additionalProperties": keywordSchema
+            "description": "Tracks the 1-day vs 7-day mention count for the top 50 words.",
+            "patternProperties": { "^.*$": wordSchema },
+            "additionalProperties": wordSchema
         };
     }
 
-    // --- REFACTORED ---
-    /**
-     * @param {string} dateStr - Today's date.
-     * @param {object} rootData - The root data object.
-     * @param {object} dependencies - db, logger, calculationUtils
-     * @param {object} config - Computation config.
-     */
-    async process(dateStr, rootData, dependencies, config) {
-        const { calculationUtils } = dependencies;
-        
-        // 1. Load keywords from config (or another source)
-        this.keywords = config.trackedKeywords || ['inflation', 'fed', 'AI', 'crypto', 'recession'];
-
-        // 2. Load this metric's history from yesterday
-        const yHistoryData = await calculationUtils.loadYesterdayData('social-word-mentions-trend');
-
-        // 3. Initialize state for all keywords
-        for (const keyword of this.keywords) {
-            const normalizedKey = keyword.toLowerCase();
-            this.keywordData.set(normalizedKey, {
-                count: 0,
-                history: yHistoryData?.[normalizedKey]?.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)
+            );
+    }
+
+    // --- THIS IS THE FIX ---
+    async process(dateStr, rootData, dependencies, config, fetchedDependencies) {
+        // dateStr is Arg 1 (metaPayload), rootData is Arg 2, dependencies is Arg 3
+
+        // Get social data from Arg 1 (worker hack)
+        const socialDoc = dateStr.social; // This IS the map of posts
+        // Get dependency from Arg 5
+        const topWordsData = fetchedDependencies['social-top-mentioned-words'];
+
+        if (!socialDoc || typeof socialDoc !== 'object' || !topWordsData) {
+            this.result = {};
+            return;
         }
-        
-        // 4. Process today's raw social data
-        const todaySocialPosts = rootData.todaySocialPostInsights || {}; 
-
-        for (const post of Object.values(todaySocialPosts)) {
-            const text = (post.fullText || '').toLowerCase();
-            
-            for (const keyword of this.keywords) {
-                const normalizedKey = keyword.toLowerCase();
-                if (text.includes(normalizedKey)) {
-                    this.keywordData.get(normalizedKey).count++;
-                }
-            }
+
+        const topWords = new Set(Object.keys(topWordsData));
+        // dateStr is the metaPayload, but it has a 'date' field
+        const today = new Date(dateStr.date + 'T00:00:00Z'); 
+        const sevenDaysAgo = new Date(today);
+        sevenDaysAgo.setUTCDate(today.getUTCDate() - 7);
+
+        const counts = new Map();
+        for (const word of topWords) {
+            counts.set(word, { count_1d: 0, count_7d: 0 });
         }
-    }
 
-    async getResult() {
-        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;
+        for (const post of Object.values(socialDoc)) {
+            const postDate = new Date(post.createdAt); // Use 'createdAt'
+            const is1d = postDate.toISOString().slice(0, 10) === dateStr.date;
+            const is7d = postDate >= sevenDaysAgo;
+
+            if (!is7d) continue;
+
+            const words = this._tokenize(post.textSnippet); // Use 'textSnippet'
+
+            for (const word of words) {
+                if (counts.has(word)) {
+                    const stats = counts.get(word);
+                    if (is7d) stats.count_7d++;
+                    if (is1d) stats.count_1d++;
                 }
             }
-
-            result[keyword] = {
-                count: todayCount,
-                trend_30d_pct: trend_30d_pct,
-                history_30d: newHistory
-            };
         }
-        return result;
+
+        this.result = Object.fromEntries(counts);
+    }
+    // --- END FIX ---
+
+    async getResult(fetchedDependencies) {
+        return this.result;
     }
 
     reset() {
-        this.keywordData.clear();
-        this.keywords = [];
+        this.result = {};
     }
 }
 

package/calculations/core/speculator-asset-sentiment.js

@@ -1,53 +1,17 @@
 /**
- * @fileoverview Calculation (Pass 1) for speculator metric.
+ * @fileoverview Calculation (Pass 1) for speculator sentiment.
  *
- * This metric answers: "For each asset, what are the average
- * P&L, leverage, SL rate, and TP rate for *long* and *short*
- * speculator positions?"
+ * This metric answers: "For each asset, what is the sentiment
+ * (long vs. short) *only* for speculators?"
  */
-const { loadInstrumentMappings } = require('../../utils/sector_mapping_provider');
+// --- STANDARD 0: REMOVED require('../../utils/sector_mapping_provider') ---
 
 class SpeculatorAssetSentiment {
     constructor() {
-        // { [instrumentId]: { long: {...}, short: {...} } }
+        // { [instrumentId]: { long: 0, short: 0 } }
         this.assets = new Map();
-        this.mappings = null;
-    }
-
-    /**
-     * Defines the output schema for this calculation.
-     * @returns {object} JSON Schema object
-     */
-    static getSchema() {
-        const sentimentDetailSchema = {
-            "type": "object",
-            "properties": {
-                "avg_pnl_pct": { "type": "number" },
-                "avg_leverage": { "type": "number" },
-                "sl_rate_pct": { "type": "number" },
-                "tp_rate_pct": { "type": "number" },
-                "count": { "type": "number" }
-            },
-            "required": ["avg_pnl_pct", "avg_leverage", "sl_rate_pct", "tp_rate_pct", "count"]
-        };
-
-        const tickerSchema = {
-            "type": "object",
-            "properties": {
-                "long": sentimentDetailSchema,
-                "short": sentimentDetailSchema
-            },
-            "required": ["long", "short"]
-        };
-
-        return {
-            "type": "object",
-            "description": "Aggregates P&L, leverage, and SL/TP usage for speculators, split by long/short positions per asset.",
-            "patternProperties": {
-                "^.*$": tickerSchema // Ticker
-            },
-            "additionalProperties": tickerSchema
-        };
+        // --- STANDARD 0: RENAMED ---
+        this.tickerMap = null;
     }
 
     /**
@@ -58,8 +22,8 @@ class SpeculatorAssetSentiment {
             type: 'standard',
             rootDataDependencies: ['portfolio'],
             isHistorical: false,
-            userType: 'speculator',
-            category: 'core_speculator'
+            userType: 'speculator', // <-- KEY: Only runs for speculators
+            category: 'core_sentiment'
         };
     }
 
@@ -70,28 +34,43 @@ class SpeculatorAssetSentiment {
         return [];
     }
 
+    /**
+     * Defines the output schema for this calculation.
+     */
+    static getSchema() {
+        const tickerSchema = {
+            "type": "object",
+            "properties": {
+                "long_count": { "type": "number" },
+                "short_count": { "type": "number" },
+                "sentiment_ratio": { "type": ["number", "null"] }
+            },
+            "required": ["long_count", "short_count", "sentiment_ratio"]
+        };
+
+        return {
+            "type": "object",
+            "description": "Calculates the long/short sentiment ratio *only* for speculators.",
+            "patternProperties": { "^.*$": tickerSchema },
+            "additionalProperties": tickerSchema
+        };
+    }
+
     _initAsset(instrumentId) {
         if (!this.assets.has(instrumentId)) {
-            const createSide = () => ({
-                pnl_sum: 0,
-                leverage_sum: 0,
-                sl_set_count: 0,
-                tp_set_count: 0,
-                count: 0
-            });
-            this.assets.set(instrumentId, {
-                long: createSide(),
-                short: createSide()
-            });
+            this.assets.set(instrumentId, { long: 0, short: 0 });
         }
     }
 
-    process(portfolioData) {
-        if (portfolioData?.context?.userType !== 'speculator') {
-            return;
+    // --- STANDARD 0: UPDATED SIGNATURE ---
+    process(todayPortfolio, yesterdayPortfolio, userId, context) {
+        // --- STANDARD 0: ADDED ---
+        if (!this.tickerMap) {
+             this.tickerMap = context.instrumentToTicker;
         }
-        
-        const positions = portfolioData.PublicPositions;
+
+        // Only speculators are processed, so we can assume PublicPositions exists
+        const positions = todayPortfolio.PublicPositions;
         if (!positions || !Array.isArray(positions)) {
             return;
         }
@@ -101,52 +80,44 @@ class SpeculatorAssetSentiment {
             if (!instrumentId) continue;
             
             this._initAsset(instrumentId);
-            const sideData = pos.IsBuy ? this.assets.get(instrumentId).long : this.assets.get(instrumentId).short;
-            
-            const pnl_percent = (pos.NetProfit || 0) / (pos.Amount || 1);
-            
-            sideData.pnl_sum += pnl_percent;
-            sideData.leverage_sum += pos.Leverage || 1;
-            if (pos.StopLossRate) sideData.sl_set_count++;
-            if (pos.TakeProfitRate) sideData.tp_set_count++;
-            sideData.count++;
-        }
-    }
-    
-    _calculateAverages(data) {
-        const count = data.count;
-        if (count === 0) {
-            return { avg_pnl_pct: 0, avg_leverage: 0, sl_rate_pct: 0, tp_rate_pct: 0, count: 0 };
+            const assetData = this.assets.get(instrumentId);
+
+            if (pos.IsBuy) {
+                assetData.long++;
+            } else {
+                assetData.short++;
+            }
         }
-        return {
-            avg_pnl_pct: data.pnl_sum / count,
-            avg_leverage: data.leverage_sum / count,
-            sl_rate_pct: (data.sl_set_count / count) * 100,
-            tp_rate_pct: (data.tp_set_count / count) * 100,
-            count: count
-        };
     }
 
     async getResult() {
-        if (!this.mappings) {
-            this.mappings = await loadInstrumentMappings();
+        // --- STANDARD 0: REMOVED forbidden data load ---
+
+        // Failsafe check
+        if (!this.tickerMap) {
+            return {}; // process() must run first
         }
 
         const result = {};
         for (const [instrumentId, data] of this.assets.entries()) {
-            const ticker = this.mappings.instrumentToTicker[instrumentId] || `id_${instrumentId}`;
+            // --- STANDARD 0: SIMPLIFIED ---
+            const ticker = this.tickerMap[instrumentId] || `id_${instrumentId}`;
             
-            result[ticker] = {
-                long: this._calculateAverages(data.long),
-                short: this._calculateAverages(data.short)
-            };
+            if (data.long > 0 || data.short > 0) {
+                result[ticker] = {
+                    long_count: data.long,
+                    short_count: data.short,
+                    sentiment_ratio: (data.short > 0) ? (data.long / data.short) : null
+                };
+            }
         }
         return result;
     }
 
     reset() {
         this.assets.clear();
-        this.mappings = null;
+        // --- STANDARD 0: RENAMED ---
+        this.tickerMap = null;
     }
 }