aiden-shared-calculations-unified 1.0.108 → 1.0.110

package/calculations/gauss/cohort-capital-flow.js

@@ -1,12 +1,8 @@
-/**
- * @fileoverview GAUSS Product Line (Pass 3)
- * REFACTORED: Implemented getResult logic and mapping caching.
- */
 class CohortCapitalFlow {
     constructor() {
         this.cohortFlows = new Map();
         this.cohortMap = new Map();
-        this.tickerMap = null; // Cache mappings
+        this.tickerMap = null;
         this.dependenciesLoaded = false;
     }
 
@@ -14,36 +10,26 @@ class CohortCapitalFlow {
         const flowSchema = {
             "type": "object",
             "properties": {
-                "net_flow_percentage": { "type": "number" },
-                "net_flow_contribution": { "type": "number" }
+                "net_flow_percentage": { "type": ["number", "null"] },
+                "net_flow_contribution": { "type": ["number", "null"] },
+                "total_invested_today": { "type": "number" } // Baseline
             },
-            "required": ["net_flow_percentage", "net_flow_contribution"]
-        };
-        return {
-            "type": "object",
-            "patternProperties": { "^.*$": { "type": "object", "patternProperties": { "^.*$": flowSchema } } }
+            "required": ["net_flow_percentage", "net_flow_contribution", "total_invested_today"]
         };
+        return { "type": "object", "patternProperties": { "^.*$": { "type": "object", "patternProperties": { "^.*$": flowSchema } } } };
     }
 
     static getMetadata() {
-        return {
-            type: 'standard',
-            rootDataDependencies: ['portfolio', 'history'],
-            isHistorical: true,
-            userType: 'all',
-            category: 'gauss'
-        };
+        return { type: 'standard', rootDataDependencies: ['portfolio', 'history'], isHistorical: true, userType: 'all', category: 'gauss' };
     }
 
-    static getDependencies() {
-        return ['cohort-definer', 'instrument-price-change-1d'];
-    }
+    static getDependencies() { return ['cohort-definer', 'instrument-price-change-1d']; }
 
     _initFlowData(cohortName, instrumentId) {
         if (!this.cohortFlows.has(cohortName)) this.cohortFlows.set(cohortName, new Map());
         if (!this.cohortFlows.get(cohortName).has(instrumentId)) {
             this.cohortFlows.get(cohortName).set(instrumentId, {
-                total_invested_yesterday: 0, total_invested_today: 0, price_change_yesterday: 0
+                total_invested_yesterday: 0, total_invested_today: 0, price_change_yesterday: 0, has_yesterday: false
             });
         }
     }
@@ -62,84 +48,61 @@ class CohortCapitalFlow {
     process(context) {
         const { user, computed, mappings, math } = context;
         const { extract } = math;
-
-        // Cache mapping for getResult phase
         if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
-
         this._loadDependencies(computed);
-        
         const cohortName = this.cohortMap.get(user.id);
         if (!cohortName) return;
         
         const priceChangeMap = computed['instrument-price-change-1d'];
-        if (!priceChangeMap) return;
-
-        const yPos = extract.getPositions(user.portfolio.yesterday, user.type);
         const tPos = extract.getPositions(user.portfolio.today, user.type);
+        const yPos = user.portfolio.yesterday ? extract.getPositions(user.portfolio.yesterday, user.type) : [];
 
         const yPosMap = new Map(yPos.map(p => [extract.getInstrumentId(p), p]));
         const tPosMap = new Map(tPos.map(p => [extract.getInstrumentId(p), p]));
         const allInstrumentIds = new Set([...yPosMap.keys(), ...tPosMap.keys()]);
 
         for (const instId of allInstrumentIds) {
-            if (!instId) continue;
-            
             this._initFlowData(cohortName, instId);
             const asset = this.cohortFlows.get(cohortName).get(instId);
-            
-            const yInvested = extract.getPositionWeight(yPosMap.get(instId), user.type);
             const tInvested = extract.getPositionWeight(tPosMap.get(instId), user.type);
-
-            if (yInvested > 0) {
-                asset.total_invested_yesterday += yInvested;
-                
-                const ticker = this.tickerMap[instId];
-                const yPriceChange_pct = (ticker && priceChangeMap[ticker]) ? priceChangeMap[ticker].change_1d_pct : 0;
-                
-                asset.price_change_yesterday += (yPriceChange_pct / 100.0) * yInvested;
-            }
-            if (tInvested > 0) {
-                asset.total_invested_today += tInvested;
+            if (tInvested > 0) asset.total_invested_today += tInvested;
+
+            if (user.portfolio.yesterday) {
+                asset.has_yesterday = true;
+                const yInvested = extract.getPositionWeight(yPosMap.get(instId), user.type);
+                if (yInvested > 0) {
+                    asset.total_invested_yesterday += yInvested;
+                    const ticker = this.tickerMap[instId];
+                    const yPriceChange = (ticker && priceChangeMap?.[ticker]) ? priceChangeMap[ticker].change_1d_pct : 0;
+                    asset.price_change_yesterday += ((yPriceChange || 0) / 100.0) * yInvested;
+                }
             }
         }
     }
 
     async getResult() {
         const finalResult = {};
-        
-        if (!this.tickerMap) return {}; // Should be populated by process()
-
+        if (!this.tickerMap) return {};
         for (const [cohortName, assetsMap] of this.cohortFlows.entries()) {
             finalResult[cohortName] = {};
-            
             for (const [instId, data] of assetsMap.entries()) {
                 const ticker = this.tickerMap[instId] || `id_${instId}`;
-                
-                // Logic: Flow = Today - (Yesterday * (1 + PriceChange))
-                // This isolates the capital movement from the price action.
-                const expectedToday = data.total_invested_yesterday + data.price_change_yesterday;
-                const netFlow = data.total_invested_today - expectedToday;
-                
-                // Avoid divide by zero or noise for very small numbers
-                const denominator = Math.max(1, (data.total_invested_yesterday + data.total_invested_today) / 2);
-                const netFlowPct = (netFlow / denominator) * 100;
-
+                let netFlow = null, netFlowPct = null;
+                if (data.has_yesterday) {
+                    const expectedToday = data.total_invested_yesterday + data.price_change_yesterday;
+                    netFlow = data.total_invested_today - expectedToday;
+                    const denom = Math.max(1, (data.total_invested_yesterday + data.total_invested_today) / 2);
+                    netFlowPct = (netFlow / denom) * 100;
+                }
                 finalResult[cohortName][ticker] = {
-                    net_flow_percentage: netFlowPct,
-                    net_flow_contribution: netFlow
+                    net_flow_percentage: (netFlowPct !== null && isFinite(netFlowPct)) ? netFlowPct : null,
+                    net_flow_contribution: (netFlow !== null && isFinite(netFlow)) ? netFlow : null,
+                    total_invested_today: data.total_invested_today
                 };
             }
         }
-        
         return finalResult;
     }
-
-    reset() {
-        this.cohortFlows.clear();
-        this.cohortMap.clear();
-        this.tickerMap = null;
-        this.dependenciesLoaded = false;
-    }
+    reset() { this.cohortFlows.clear(); this.cohortMap.clear(); this.tickerMap = null; this.dependenciesLoaded = false; }
 }
-
-module.exports = CohortCapitalFlow;
+module.exports = CohortCapitalFlow;

package/calculations/gauss/cohort-definer.js

@@ -1,177 +1,96 @@
-/**
- * @fileoverview GAUSS Product Line (Pass 2)
- * REFACTORED: Uses context.computed and context.math.
- */
 class CohortDefiner {
-    constructor() {
-        this.smartVectors = []; 
-        this.dumbVectors = [];
-        this.cohortIdSets = null;
-    }
+    constructor() { this.smartVectors = []; this.dumbVectors = []; this.cohortIdSets = null; }
 
-    static getMetadata() {
-        return {
-            type: 'standard',
-            rootDataDependencies: ['portfolio', 'history'],
-            isHistorical: true,
-            userType: 'all',
-            category: 'gauss'
-        };
-    }
-
-    static getDependencies() {
-        return ['daily-dna-filter', 'instrument-price-momentum-20d'];
-    }
+    static getMetadata() { return { type: 'standard', rootDataDependencies: ['portfolio', 'history'], isHistorical: true, userType: 'all', category: 'gauss' }; }
+    static getDependencies() { return ['daily-dna-filter', 'instrument-price-momentum-20d']; }
 
     static getSchema() {
-        const cohortList = { 
-            "type": "array", 
-            "items": { "type": "string" },
-            "description": "List of User IDs belonging to this behavioral cohort" 
-        };
-
-        return {
-            "type": "object",
-            "required": [
-                "smart_investors",
-                "smart_scalpers",
-                "uncategorized_smart",
-                "fomo_chasers",
-                "patient_losers",
-                "fomo_bagholders",
-                "uncategorized_dumb"
-            ],
-            "properties": {
-                "smart_investors": cohortList,
-                "smart_scalpers": cohortList,
-                "uncategorized_smart": cohortList,
-                "fomo_chasers": cohortList,
-                "patient_losers": cohortList,
-                "fomo_bagholders": cohortList,
-                "uncategorized_dumb": cohortList
-            }
-        };
+        const list = { "type": "array", "items": { "type": "string" } };
+        return { "type": "object", "properties": { 
+            "smart_investors": list, "smart_scalpers": list, "uncategorized_smart": list,
+            "fomo_chasers": list, "patient_losers": list, "fomo_bagholders": list, "uncategorized_dumb": list
+        }, "required": ["smart_investors", "smart_scalpers", "uncategorized_smart", "fomo_chasers", "patient_losers", "fomo_bagholders", "uncategorized_dumb"] };
     }
     
     _loadDependencies(computed) {
         if (this.cohortIdSets) return;
-        const dnaFilterData = computed['daily-dna-filter'];
-        
-        this.cohortIdSets = {
-            smart: new Set(dnaFilterData?.smart_cohort_ids || []),
-            dumb: new Set(dnaFilterData?.dumb_cohort_ids || [])
-        };
-    }
-
-    _getFomoScore(extract, mappings, today, yesterday, momentumData, userType) {
-        if (!momentumData) return 0;
-
-        const tPos = extract.getPositions(today, userType);
-        const yPos = extract.getPositions(yesterday, userType);
-
-        const yIds = new Set(yPos.map(p => extract.getInstrumentId(p)));
-        const newPositions = tPos.filter(p => !yIds.has(extract.getInstrumentId(p)));
-
-        if (newPositions.length === 0) return 0;
-
-        let fomoSum = 0, count = 0;
-        for (const pos of newPositions) {
-            const instId = extract.getInstrumentId(pos);
-            const ticker = mappings.instrumentToTicker[instId];
-            if (ticker && momentumData[ticker]) {
-                fomoSum += momentumData[ticker].momentum_20d_pct || 0;
-                count++;
-            }
-        }
-        return count > 0 ? fomoSum / count : 0;
-    }
-
-    _getBagholderScore(extract, today, userType) {
-        const positions = extract.getPositions(today, userType);
-        if (positions.length === 0) return 0;
-
-        let durationSum = 0, count = 0;
-        const now = new Date();
-
-        for (const pos of positions) {
-            if (extract.getNetProfit(pos) < -20) {
-                const openDate = extract.getOpenDateTime(pos);
-                if (openDate) { 
-                    try {
-                        const durationDays = (now - openDate) / (86400000);
-                        durationSum += durationDays;
-                        count++;
-                    } catch (e) {}
-                }
-            }
-        }
-        return count > 0 ? durationSum / count : 0;
+        const dna = computed['daily-dna-filter'];
+        this.cohortIdSets = { smart: new Set(dna?.smart_cohort_ids || []), dumb: new Set(dna?.dumb_cohort_ids || []) };
     }
 
     process(context) {
         const { user, computed, mappings, math } = context;
         const { extract, history } = math;
-
         this._loadDependencies(computed);
-
-        const isSmart = this.cohortIdSets.smart.has(user.id);
-        const isDumb = this.cohortIdSets.dumb.has(user.id);
-
+        const isSmart = this.cohortIdSets.smart.has(user.id), isDumb = this.cohortIdSets.dumb.has(user.id);
         if (!isSmart && !isDumb) return;
 
-        // 1. Strict History Access
         const historyDoc = history.getDailyHistory(user);
         const summary = history.getSummary(historyDoc);
+        if (!summary) {
+            // No history? Keep them for aggregate count as uncategorized
+            const v = { userId: user.id, skill: 0, time: 0, fomo: 0, bagholder: 0, coldStart: true };
+            if (isSmart) this.smartVectors.push(v); else this.dumbVectors.push(v);
+            return;
+        }
         
-        if (!summary) return;
-        
-        // 2. Valid usage of Summary DTO properties
-        const winRate = summary.winRatio / 100.0;
-        const lossRate = 1.0 - winRate;
+        const winRate = summary.winRatio / 100.0, lossRate = 1.0 - winRate;
         const lt_skill = (winRate * summary.avgProfitPct) - (lossRate * Math.abs(summary.avgLossPct));
         const lt_time = summary.avgHoldingTimeInMinutes;
-
         const momentumData = computed['instrument-price-momentum-20d'];
-        const st_fomo = this._getFomoScore(extract, mappings, user.portfolio.today, user.portfolio.yesterday, momentumData, user.type);
-        const st_bagholder = this._getBagholderScore(extract, user.portfolio.today, user.type);
-
-        const vector = { userId: user.id, skill: lt_skill, time: lt_time, fomo: st_fomo, bagholder: st_bagholder };
+        
+        // st_fomo logic handles user.portfolio.yesterday internally via extract calls
+        const tPos = extract.getPositions(user.portfolio.today, user.type);
+        const yPos = user.portfolio.yesterday ? extract.getPositions(user.portfolio.yesterday, user.type) : [];
+        const yIds = new Set(yPos.map(p => extract.getInstrumentId(p)));
+        const newPos = tPos.filter(p => !yIds.has(extract.getInstrumentId(p)));
+        let fomo = 0; if (newPos.length > 0 && momentumData) {
+            let sum = 0, count = 0;
+            for (const p of newPos) {
+                const tick = mappings.instrumentToTicker[extract.getInstrumentId(p)];
+                if (tick && momentumData[tick]) { sum += momentumData[tick].momentum_20d_pct || 0; count++; }
+            }
+            fomo = count > 0 ? sum / count : 0;
+        }
 
-        if (isSmart) this.smartVectors.push(vector);
-        else this.dumbVectors.push(vector);
+        let bag = 0, bCount = 0; for (const p of tPos) {
+            if (extract.getNetProfit(p) < -20) {
+                const open = extract.getOpenDateTime(p);
+                if (open) { bag += (new Date() - open) / 86400000; bCount++; }
+            }
+        }
+        const st_bag = bCount > 0 ? bag / bCount : 0;
+        const vector = { userId: user.id, skill: lt_skill, time: lt_time, fomo: fomo, bagholder: st_bag, coldStart: false };
+        if (isSmart) this.smartVectors.push(vector); else this.dumbVectors.push(vector);
     }
 
     _getMedian(vectors, key) {
-        if (vectors.length === 0) return 0;
-        const sorted = vectors.map(v => v[key]).sort((a, b) => a - b);
+        const filtered = vectors.filter(v => !v.coldStart);
+        if (filtered.length === 0) return 0;
+        const sorted = filtered.map(v => v[key]).sort((a, b) => a - b);
         const mid = Math.floor(sorted.length / 2);
         return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
     }
 
     async getResult() {
-        const cohorts = {};
-        const assignedSmart = new Set(), assignedDumb = new Set();
-
-        const smart_time = this._getMedian(this.smartVectors, 'time');
-        cohorts['smart_investors'] = this.smartVectors.filter(u => u.time >= smart_time).map(u => { assignedSmart.add(u.userId); return u.userId; });
-        cohorts['smart_scalpers'] = this.smartVectors.filter(u => u.time < smart_time).map(u => { assignedSmart.add(u.userId); return u.userId; });
-        cohorts['uncategorized_smart'] = this.smartVectors.filter(u => !assignedSmart.has(u.userId)).map(u => u.userId);
-            
-        const dumb_fomo = this._getMedian(this.dumbVectors, 'fomo');
-        const dumb_bag = this._getMedian(this.dumbVectors, 'bagholder');
-
-        cohorts['fomo_chasers'] = this.dumbVectors.filter(u => u.fomo >= dumb_fomo && u.bagholder < dumb_bag).map(u => { assignedDumb.add(u.userId); return u.userId; });
-        cohorts['patient_losers'] = this.dumbVectors.filter(u => u.fomo < dumb_fomo && u.bagholder >= dumb_bag).map(u => { assignedDumb.add(u.userId); return u.userId; });
-        cohorts['fomo_bagholders'] = this.dumbVectors.filter(u => u.fomo >= dumb_fomo && u.bagholder >= dumb_bag).map(u => { assignedDumb.add(u.userId); return u.userId; });
-        cohorts['uncategorized_dumb'] = this.dumbVectors.filter(u => !assignedDumb.has(u.userId)).map(u => u.userId);
-
+        const cohorts = { smart_investors: [], smart_scalpers: [], uncategorized_smart: [], fomo_chasers: [], patient_losers: [], fomo_bagholders: [], uncategorized_dumb: [] };
+        const assSmart = new Set(), assDumb = new Set();
+        const sTime = this._getMedian(this.smartVectors, 'time');
+        this.smartVectors.forEach(u => {
+            if (u.coldStart) { cohorts.uncategorized_smart.push(u.userId); return; }
+            if (u.time >= sTime) { cohorts.smart_investors.push(u.userId); assSmart.add(u.userId); }
+            else { cohorts.smart_scalpers.push(u.userId); assSmart.add(u.userId); }
+        });
+        const dFomo = this._getMedian(this.dumbVectors, 'fomo'), dBag = this._getMedian(this.dumbVectors, 'bagholder');
+        this.dumbVectors.forEach(u => {
+            if (u.coldStart) { cohorts.uncategorized_dumb.push(u.userId); return; }
+            if (u.fomo >= dFomo && u.bagholder < dBag) cohorts.fomo_chasers.push(u.userId);
+            else if (u.fomo < dFomo && u.bagholder >= dBag) cohorts.patient_losers.push(u.userId);
+            else if (u.fomo >= dFomo && u.bagholder >= dBag) cohorts.fomo_bagholders.push(u.userId);
+            else cohorts.uncategorized_dumb.push(u.userId);
+        });
         return cohorts;
     }
-    
-    reset() {
-        this.smartVectors = [];
-        this.dumbVectors = [];
-        this.cohortIdSets = null;
-    }
+    reset() { this.smartVectors = []; this.dumbVectors = []; this.cohortIdSets = null; }
 }
 module.exports = CohortDefiner;

package/calculations/gem/cohort-momentum-state.js

@@ -1,101 +1,51 @@
-/**
- * @fileoverview GEM Product Line (Pass 2)
- * REFACTORED: Uses context.computed and context.math.
- */
 class CohortMomentumState {
-    constructor() {
-        this.cohortMomentum = new Map();
-        this.cohortMap = new Map();
-        this.dependenciesLoaded = false;
-        this.tickerMap = null; // Need to store this
-    }
-
-    static getMetadata() {
-        return {
-            type: 'standard',
-            rootDataDependencies: ['portfolio'],
-            isHistorical: true, 
-            userType: 'all',
-            category: 'gem'
-        };
-    }
-
-    static getDependencies() {
-        return ['cohort-skill-definition', 'instrument-price-momentum-20d'];
-    }
+    constructor() { this.cohortMomentum = new Map(); this.cohortMap = new Map(); this.dependenciesLoaded = false; this.tickerMap = null; }
+    static getMetadata() { return { type: 'standard', rootDataDependencies: ['portfolio'], isHistorical: true, userType: 'all', category: 'gem' }; }
+    static getDependencies() { return ['cohort-skill-definition', 'instrument-price-momentum-20d']; }
 
     static getSchema() {
-        const cohortSchema = {
-            "type": "object",
-            "properties": {
-                "average_momentum_exposure_pct": { "type": "number" },
-                "trade_count": { "type": "number" }
-            },
-            "required": ["average_momentum_exposure_pct", "trade_count"]
-        };
-        return { "type": "object", "properties": { "skilled": cohortSchema, "unskilled": cohortSchema } };
+        const s = { "type": "object", "properties": { "average_momentum_exposure_pct": { "type": ["number", "null"] }, "trade_count": { "type": "number" }, "total_exposure_today": { "type": "number" } }, "required": ["average_momentum_exposure_pct", "trade_count", "total_exposure_today"] };
+        return { "type": "object", "properties": { "skilled": s, "unskilled": s } };
     }
 
     _loadDependencies(computed) {
         if (this.dependenciesLoaded) return;
-        const cohortData = computed['cohort-skill-definition'];
-        if (cohortData) {
-            (cohortData.skilled_user_ids || []).forEach(uid => this.cohortMap.set(String(uid), 'skilled'));
-            (cohortData.unskilled_user_ids || []).forEach(uid => this.cohortMap.set(String(uid), 'unskilled'));
-        }
+        const d = computed['cohort-skill-definition'];
+        if (d) { (d.skilled_user_ids || []).forEach(uid => this.cohortMap.set(String(uid), 'skilled')); (d.unskilled_user_ids || []).forEach(uid => this.cohortMap.set(String(uid), 'unskilled')); }
         this.dependenciesLoaded = true;
     }
 
-    _initCohort(cohortName) {
-        if (!this.cohortMomentum.has(cohortName)) this.cohortMomentum.set(cohortName, { momentum_sum: 0, count: 0 });
-    }
-
     process(context) {
         const { user, computed, mappings, math } = context;
         const { extract } = math;
-        
         this._loadDependencies(computed);
-        if (!this.tickerMap) this.tickerMap = mappings.instrumentToTicker;
-
-        const cohortName = this.cohortMap.get(user.id);
-        if (!cohortName) return;
-
-        const momentumData = computed['instrument-price-momentum-20d'];
-        if (!momentumData) return;
-
-        const yIds = new Set(extract.getPositions(user.portfolio.yesterday, user.type).map(p => extract.getInstrumentId(p)));
-        const newPositions = extract.getPositions(user.portfolio.today, user.type).filter(p => !yIds.has(extract.getInstrumentId(p)));
-
-        if (newPositions.length === 0) return;
-
-        this._initCohort(cohortName);
-        const asset = this.cohortMomentum.get(cohortName);
+        const cohort = this.cohortMap.get(user.id); if (!cohort) return;
+        if (!this.cohortMomentum.has(cohort)) this.cohortMomentum.set(cohort, { sum: 0, count: 0, total_abs: 0 });
+        const asset = this.cohortMomentum.get(cohort);
+
+        const mom = computed['instrument-price-momentum-20d'];
+        const tPos = extract.getPositions(user.portfolio.today, user.type);
+        for (const p of tPos) {
+            const tick = mappings.instrumentToTicker[extract.getInstrumentId(p)];
+            if (tick && mom?.[tick]) asset.total_abs += Math.abs(mom[tick].momentum_20d_pct || 0);
+        }
 
-        for (const pos of newPositions) {
-            const ticker = mappings.instrumentToTicker[extract.getInstrumentId(pos)];
-            if (ticker && momentumData[ticker]) {
-                asset.momentum_sum += momentumData[ticker].momentum_20d_pct || 0;
-                asset.count++;
+        if (user.portfolio.yesterday) {
+            const yIds = new Set(extract.getPositions(user.portfolio.yesterday, user.type).map(p => extract.getInstrumentId(p)));
+            const newPos = tPos.filter(p => !yIds.has(extract.getInstrumentId(p)));
+            for (const p of newPos) {
+                const tick = mappings.instrumentToTicker[extract.getInstrumentId(p)];
+                if (tick && mom?.[tick]) { asset.sum += mom[tick].momentum_20d_pct || 0; asset.count++; }
             }
         }
     }
 
     async getResult() {
-        const finalResult = {};
-        for (const [cohortName, data] of this.cohortMomentum.entries()) {
-            finalResult[cohortName] = {
-                average_momentum_exposure_pct: (data.count > 0) ? data.momentum_sum / data.count : 0,
-                trade_count: data.count
-            };
+        const res = {}; for (const [c, d] of this.cohortMomentum.entries()) {
+            res[c] = { average_momentum_exposure_pct: (d.count > 0) ? d.sum / d.count : null, trade_count: d.count, total_exposure_today: d.total_abs };
         }
-        return finalResult;
-    }
-
-    reset() {
-        this.cohortMomentum.clear();
-        this.cohortMap.clear();
-        this.dependenciesLoaded = false;
-        this.tickerMap = null;
+        return res;
     }
+    reset() { this.cohortMomentum.clear(); this.cohortMap.clear(); this.dependenciesLoaded = false; this.tickerMap = null; }
 }
 module.exports = CohortMomentumState;