aiden-shared-calculations-unified 1.0.103 → 1.0.105

package/calculations/audit_results.txt

@@ -0,0 +1,97 @@
+Scanning 92 files...
+
+--- Files MISSING getSchema() ---
+
+--- Files WITH getSchema() ---
+capitulation\asset-volatility-estimator.js
+capitulation\retail-capitulation-risk-forecast.js
+core\asset-cost-basis-profile.js
+core\asset-pnl-status.js
+core\asset-position-size.js
+core\average-daily-pnl-all-users.js
+core\average-daily-pnl-per-sector.js
+core\average-daily-pnl-per-stock.js
+core\average-daily-position-pnl.js
+core\crowd-cost-basis.js
+core\holding-duration-per-asset.js
+core\insights-daily-bought-vs-sold-count.js
+core\insights-daily-ownership-delta.js
+core\insights-sentimet-per-stock.js
+core\insights-total-long-per-sector.js
+core\Insights-total-long-per-stock.js
+core\insights-total-positions-held.js
+core\instrument-price-change-1d.js
+core\instrument-price-momentum-20d.js
+core\leverage-divergence.js
+core\liquidation-cascade.js
+core\long-position-per-stock.js
+core\overall-holding-duration.js
+core\overall-profitability-ratio.js
+core\ownership-vs-performance-ytd.js
+core\ownership-vs-volatility.js
+core\platform-buy-sell-sentiment.js
+core\platform-daily-bought-vs-sold-count.js
+core\platform-daily-ownership-delta.js
+core\platform-ownership-per-sector.js
+core\platform-total-positions-held.js
+core\pnl-distribution-per-stock.js
+core\price-metrics.js
+core\profitability-ratio-per-sector.js
+core\profitability-ratio-per-stock.js
+core\profitability-skew-per-stock.js
+core\profitable-and-unprofitable-status.js
+core\sentiment-per-stock.js
+core\short-interest-growth.js
+core\short-position-per-stock.js
+core\social-activity-aggregation.js
+core\social-asset-posts-trend.js
+core\social-event-correlation.js
+core\social-sentiment-aggregation.js
+core\social-top-mentioned-words.js
+core\social-topic-interest-evolution.js
+core\social-topic-sentiment-matrix.js
+core\social-word-mentions-trend.js
+core\speculator-asset-sentiment.js
+core\speculator-danger-zone.js
+core\speculator-distance-to-stop-loss-per-leverage.js
+core\speculator-distance-to-tp-per-leverage.js
+core\speculator-entry-distance-to-sl-per-leverage.js
+core\speculator-entry-distance-to-tp-per-leverage.js
+core\speculator-leverage-per-asset.js
+core\speculator-leverage-per-sector.js
+core\speculator-risk-reward-ratio-per-asset.js
+core\speculator-stop-loss-distance-by-sector-short-long-breakdown.js
+core\speculator-stop-loss-distance-by-ticker-short-long-breakdown.js
+core\speculator-stop-loss-per-asset.js
+core\speculator-take-profit-per-asset.js
+core\speculator-tsl-per-asset.js
+core\total-long-figures.js
+core\total-long-per-sector.js
+core\total-short-figures.js
+core\total-short-per-sector.js
+core\trending-ownership-momentum.js
+core\user-history-reconstructor.js
+core\users-processed.js
+gauss\cohort-capital-flow.js
+gauss\cohort-definer.js
+gauss\daily-dna-filter.js
+gauss\gauss-divergence-signal.js
+gem\cohort-momentum-state.js
+gem\cohort-skill-definition.js
+gem\platform-conviction-divergence.js
+gem\quant-skill-alpha-signal.js
+gem\skilled-cohort-flow.js
+gem\skilled-unskilled-divergence.js
+gem\unskilled-cohort-flow.js
+ghost-book\cost-basis-density.js
+ghost-book\liquidity-vacuum.js
+ghost-book\retail-gamma-exposure.js
+helix\helix-contrarian-signal.js
+helix\herd-consensus-score.js
+helix\winner-loser-flow.js
+predicative-alpha\cognitive-dissonance.js
+predicative-alpha\diamond-hand-fracture.js
+predicative-alpha\mimetic-latency.js
+pyro\risk-appetite-index.js
+pyro\squeeze-potential.js
+pyro\volatility-signal.js

package/calculations/audit_schemas.js

@@ -0,0 +1,47 @@
+const fs = require('fs');
+const path = require('path');
+
+const rootDir = __dirname;
+
+function getAllFiles(dirPath, arrayOfFiles) {
+    const files = fs.readdirSync(dirPath);
+
+    arrayOfFiles = arrayOfFiles || [];
+
+    files.forEach(function (file) {
+        if (fs.statSync(dirPath + "/" + file).isDirectory()) {
+            arrayOfFiles = getAllFiles(dirPath + "/" + file, arrayOfFiles);
+        } else {
+            if (file.endsWith('.js') && file !== 'audit_schemas.js') {
+                arrayOfFiles.push(path.join(dirPath, "/", file));
+            }
+        }
+    });
+
+    return arrayOfFiles;
+}
+
+const files = getAllFiles(rootDir);
+let missingSchema = [];
+let hasSchema = [];
+
+const output = [];
+output.push(`Scanning ${files.length} files...`);
+
+files.forEach(file => {
+    const content = fs.readFileSync(file, 'utf8');
+    if (content.includes('static getSchema()')) {
+        hasSchema.push(file);
+    } else {
+        missingSchema.push(file);
+    }
+});
+
+output.push('\n--- Files MISSING getSchema() ---');
+missingSchema.forEach(f => output.push(path.relative(rootDir, f)));
+
+output.push('\n--- Files WITH getSchema() ---');
+hasSchema.forEach(f => output.push(path.relative(rootDir, f)));
+
+fs.writeFileSync(path.join(rootDir, 'audit_results.txt'), output.join('\n'));
+console.log('Audit complete. Results written to audit_results.txt');

package/calculations/core/Insights-total-long-per-stock.js

@@ -28,7 +28,7 @@ class InsightsTotalPositionsHeld {
         if (insights.length === 0) return;
 
         for (const insight of insights) {
-            this.totalPositions += insightsHelper.getTotalOwners(insight);
+            this.totalPositions += insightsHelper.getLongCount(insight); // Corrected to use getLongCount
         }
     }
     

package/calculations/core/crowd-cost-basis.js

@@ -1,6 +1,6 @@
 class CrowdCostBasis {
     constructor() {
-        this.results = {}; 
+        this.results = {};
     }
 
     static getMetadata() {
@@ -18,9 +18,23 @@ class CrowdCostBasis {
         return ['user-history-reconstructor'];
     }
 
+    static getSchema() {
+        const schema = {
+            "type": "object",
+            "properties": {
+                "avgEntry": { "type": "number" },
+                "holderCount": { "type": "number" },
+                "profitabilityPct": { "type": "number" },
+                "state": { "type": "string" }
+            },
+            "required": ["avgEntry", "holderCount", "profitabilityPct", "state"]
+        };
+        return { "type": "object", "patternProperties": { "^.*$": schema } };
+    }
+
     async process(context) {
         const { computed, prices, math } = context;
-        
+
         // 1. Access the output of the Standard calculation
         const userReconstructions = computed['user-history-reconstructor'];
         if (!userReconstructions) return;
@@ -30,12 +44,12 @@ class CrowdCostBasis {
         // 2. Iterate over all users' reconstructed states
         for (const userId in userReconstructions) {
             const userPortfolio = userReconstructions[userId];
-            
+
             for (const ticker in userPortfolio) {
                 const position = userPortfolio[ticker];
-                
+
                 if (!aggregator[ticker]) aggregator[ticker] = { sumEntry: 0, count: 0 };
-                
+
                 // Aggregating global average entry
                 aggregator[ticker].sumEntry += position.avgEntry;
                 aggregator[ticker].count++;
@@ -48,7 +62,7 @@ class CrowdCostBasis {
             if (data.count < 10) continue; // Noise filter
 
             const globalAvgEntry = data.sumEntry / data.count;
-            
+
             // Get today's closing price
             const priceHistory = math.priceExtractor.getHistory(prices, ticker);
             // The last item in price history for this context is "Today"

package/calculations/core/leverage-divergence.js

@@ -16,12 +16,27 @@ class LeverageDivergence {
         return ['user-history-reconstructor'];
     }
 
+    static getSchema() {
+        const schema = {
+            "type": "object",
+            "properties": {
+                "levHolders": { "type": "number" },
+                "spotHolders": { "type": "number" },
+                "levDelta": { "type": "number" },
+                "spotDelta": { "type": "number" },
+                "signal": { "type": "string" }
+            },
+            "required": ["levHolders", "spotHolders", "levDelta", "spotDelta", "signal"]
+        };
+        return { "type": "object", "patternProperties": { "^.*$": schema } };
+    }
+
     async process(context) {
         const { computed, previousComputed } = context;
-        
+
         const currentReconstruction = computed['user-history-reconstructor'];
         // Access SELF from yesterday
-        const previousResult = previousComputed['leverage-divergence']; 
+        const previousResult = previousComputed['leverage-divergence'];
 
         const currentAgg = {}; // { AAPL: { levHolders: 0, spotHolders: 0 } }
 
@@ -30,9 +45,9 @@ class LeverageDivergence {
             const userPortfolio = currentReconstruction[userId];
             for (const ticker in userPortfolio) {
                 const pos = userPortfolio[ticker];
-                
+
                 if (!currentAgg[ticker]) currentAgg[ticker] = { levHolders: 0, spotHolders: 0 };
-                
+
                 // If avg leverage > 1.1, count as "Leveraged Holder"
                 if (pos.avgLeverage > 1.1) {
                     currentAgg[ticker].levHolders++;
@@ -56,10 +71,10 @@ class LeverageDivergence {
             const spotDelta = curr.spotHolders - prev.spotHolders;
 
             let signal = 'NEUTRAL';
-            
+
             // Retail (Spot) Buying + Speculators (Lev) Selling = Smart Money Exit
-            if (spotDelta > 0 && levDelta < 0) signal = 'SMART_EXIT'; 
-            
+            if (spotDelta > 0 && levDelta < 0) signal = 'SMART_EXIT';
+
             // Retail (Spot) Selling + Speculators (Lev) Buying = High Conviction Pump
             if (spotDelta < 0 && levDelta > 0) signal = 'SPECULATIVE_PUMP';
 

package/calculations/core/liquidation-cascade.js

@@ -8,7 +8,7 @@ class LiquidationCascade {
             category: 'History Reconstruction',
             userType: 'n/a',
             isHistorical: false,
-            rootDataDependencies: [] 
+            rootDataDependencies: []
         };
     }
 
@@ -16,23 +16,37 @@ class LiquidationCascade {
         return ['user-history-reconstructor'];
     }
 
+    static getSchema() {
+        const schema = {
+            "type": "object",
+            "properties": {
+                "totalClosures": { "type": "number" },
+                "forcedClosures": { "type": "number" },
+                "painIndex": { "type": "number" },
+                "isFlushEvent": { "type": "boolean" }
+            },
+            "required": ["totalClosures", "forcedClosures", "painIndex", "isFlushEvent"]
+        };
+        return { "type": "object", "patternProperties": { "^.*$": schema } };
+    }
+
     async process(context) {
         const { computed } = context;
         const userReconstructions = computed['user-history-reconstructor'];
         if (!userReconstructions) return;
 
-        const aggregator = {}; 
+        const aggregator = {};
 
         // 1. Aggregate Forced Exits
         for (const userId in userReconstructions) {
             const userPortfolio = userReconstructions[userId];
-            
+
             for (const ticker in userPortfolio) {
                 const position = userPortfolio[ticker];
-                
+
                 if (position.closedToday > 0) {
                     if (!aggregator[ticker]) aggregator[ticker] = { closed: 0, forced: 0 };
-                    
+
                     aggregator[ticker].closed += position.closedToday;
                     aggregator[ticker].forced += position.forcedExits;
                 }

package/calculations/core/ownership-vs-performance-ytd.js

@@ -0,0 +1,125 @@
+class OwnershipVsPerformanceYTD {
+    constructor() { this.results = {}; }
+
+    static getMetadata() {
+        return {
+            name: 'ownership-vs-performance-ytd',
+            type: 'meta',
+            category: 'core',
+            userType: 'n/a',
+            isHistorical: true, // Required to carry forward Jan 1st baseline
+            rootDataDependencies: ['insights', 'price']
+        };
+    }
+
+    static getDependencies() { return []; }
+
+    static getSchema() {
+        const metricSchema = {
+            "type": "object",
+            "properties": {
+                "priceYtd": { "type": "number" },
+                "ownersYtd": { "type": "number" },
+                "currentPrice": { "type": "number" },
+                "currentOwners": { "type": "number" }
+            },
+            "required": ["priceYtd", "ownersYtd", "currentPrice", "currentOwners"]
+        };
+
+        const baselineSchema = {
+            "type": "object",
+            "patternProperties": {
+                "^.*$": {
+                    "type": "object",
+                    "properties": {
+                        "startPrice": { "type": "number" },
+                        "startOwners": { "type": "number" },
+                        "date": { "type": "string" }
+                    }
+                }
+            }
+        };
+
+        return {
+            "type": "object",
+            "properties": {
+                "baselines": baselineSchema
+            },
+            "additionalProperties": metricSchema
+        };
+    }
+
+    async process(context) {
+        const { insights: insightsHelper, priceExtractor } = context.math;
+        const { previousComputed, mappings, prices, date } = context;
+
+        const dailyInsights = insightsHelper.getInsights(context, 'today');
+
+        // 1. Manage Baseline State (Jan 1st snapshot)
+        // If today is Jan 1st (or first run), we reset. Otherwise, we load from yesterday.
+        let baselineState = previousComputed['ownership-vs-performance-ytd']?.baselines || {};
+        const isStartOfYear = date.today.endsWith('-01-01') || date.today.endsWith('-01-02');
+
+        if (isStartOfYear) {
+            baselineState = {}; // Reset for new year
+        }
+
+        const currentMetrics = {};
+
+        for (const insight of dailyInsights) {
+            const instId = insight.instrumentId;
+            const ticker = mappings.instrumentToTicker[instId];
+            if (!ticker) continue;
+
+            const currentOwners = insightsHelper.getTotalOwners(insight);
+
+            // Get Price History
+            const priceHist = priceExtractor.getHistory(prices, ticker);
+            if (!priceHist.length) continue;
+
+            const currentPrice = priceHist[priceHist.length - 1].price;
+
+            // 2. Set Baseline if missing
+            if (!baselineState[ticker]) {
+                baselineState[ticker] = {
+                    startPrice: currentPrice,
+                    startOwners: currentOwners,
+                    date: date.today
+                };
+            }
+
+            const base = baselineState[ticker];
+
+            // 3. Calculate Deltas
+            const priceYtd = base.startPrice > 0
+                ? ((currentPrice - base.startPrice) / base.startPrice) * 100
+                : 0;
+
+            const ownersYtd = base.startOwners > 0
+                ? ((currentOwners - base.startOwners) / base.startOwners) * 100
+                : 0;
+
+            currentMetrics[ticker] = {
+                priceYtd,
+                ownersYtd,
+                currentPrice,
+                currentOwners
+            };
+        }
+
+        // 4. Output structure includes the baselines so they are saved for tomorrow
+        this.results = {
+            metrics: currentMetrics,
+            baselines: baselineState
+        };
+    }
+
+    async getResult() {
+        // We flatten the 'metrics' for easy API consumption, 
+        // but we must ensure 'baselines' is preserved in the stored document 
+        // so 'previousComputed' picks it up tomorrow.
+        return { ...this.results.metrics, baselines: this.results.baselines };
+    }
+}
+
+module.exports = OwnershipVsPerformanceYTD;

package/calculations/core/ownership-vs-volatility.js

@@ -0,0 +1,86 @@
+class OwnershipVsVolatility {
+    constructor() { this.results = {}; }
+
+    static getMetadata() {
+        return {
+            name: 'ownership-vs-volatility',
+            type: 'meta',
+            category: 'core',
+            userType: 'n/a',
+            isHistorical: true, // To calculate ownership change over window
+            rootDataDependencies: ['insights', 'price']
+        };
+    }
+
+    static getDependencies() { return []; }
+
+    static getSchema() {
+        const schema = {
+            "type": "object",
+            "properties": {
+                "volatilityScore": { "type": "number" },
+                "ownerChange7d": { "type": "number" },
+                "laggedOwners": { "type": "number" },
+                "_history": {
+                    "type": "array",
+                    "items": { "type": "number" }
+                }
+            },
+            "required": ["volatilityScore", "ownerChange7d", "laggedOwners"]
+        };
+        return { "type": "object", "patternProperties": { "^.*$": schema } };
+    }
+
+    async process(context) {
+        const { insights: insightsHelper, priceExtractor, compute } = context.math;
+        const { previousComputed, mappings, prices } = context;
+
+        const dailyInsights = insightsHelper.getInsights(context, 'today');
+
+        // Use 7-day lookback for ownership change
+        const prevState = previousComputed['ownership-vs-volatility'] || {};
+
+        for (const insight of dailyInsights) {
+            const instId = insight.instrumentId;
+            const ticker = mappings.instrumentToTicker[instId];
+            if (!ticker) continue;
+
+            // 1. Calculate Recent Volatility (14 Day StdDev of Returns)
+            const priceHist = priceExtractor.getHistory(prices, ticker);
+            if (priceHist.length < 14) continue;
+
+            const recentPrices = priceHist.slice(-14);
+            const returns = [];
+            for (let i = 1; i < recentPrices.length; i++) {
+                returns.push((recentPrices[i].price - recentPrices[i - 1].price) / recentPrices[i - 1].price);
+            }
+
+            const volatility = compute.standardDeviation(returns); // Raw std dev
+
+            // 2. Calculate Ownership Change (Current vs 7 days ago stored state)
+            const currentOwners = insightsHelper.getTotalOwners(insight);
+            const prevOwners = prevState[ticker]?.laggedOwners || currentOwners;
+
+            const ownerChangePct = prevOwners > 0
+                ? ((currentOwners - prevOwners) / prevOwners) * 100
+                : 0;
+
+            this.results[ticker] = {
+                volatilityScore: volatility,
+                ownerChange7d: ownerChangePct,
+                // Store current owners as 'laggedOwners' for next week? 
+                // Actually, for daily rolling 7d change, we need a queue. 
+                // Simplified: We store today's value, and the API/UI compares.
+                // Better: Use a simple rolling queue like the Momentum calc.
+                _history: [...(prevState[ticker]?._history || []), currentOwners].slice(-7),
+
+                // For the output: Calculate change vs the oldest in history (approx 7d ago)
+                laggedOwners: (prevState[ticker]?._history?.[0] || currentOwners)
+            };
+        }
+    }
+
+    async getResult() { return this.results; }
+}
+
+module.exports = OwnershipVsVolatility;

package/calculations/core/short-interest-growth.js

@@ -0,0 +1,69 @@
+class ShortInterestGrowth {
+    constructor() { this.results = {}; }
+
+    static getMetadata() {
+        return {
+            name: 'short-interest-growth',
+            type: 'meta',
+            category: 'core',
+            userType: 'n/a',
+            isHistorical: true,
+            rootDataDependencies: ['insights']
+        };
+    }
+
+    static getDependencies() { return []; }
+
+    static getSchema() {
+        return {
+            "TICKER": {
+                "shortCount": 0,
+                "shortSparkline": [0, 0, 0, 0, 0, 0, 0],
+                "growth7d": 0.0
+            }
+        };
+    }
+
+    async process(context) {
+        const { insights: insightsHelper } = context.math;
+        const { previousComputed, mappings } = context;
+        
+        const dailyInsights = insightsHelper.getInsights(context, 'today');
+        const previousState = previousComputed['short-interest-growth'] || {};
+
+        for (const insight of dailyInsights) {
+            const instId = insight.instrumentId;
+            const ticker = mappings.instrumentToTicker[instId];
+            if (!ticker) continue;
+
+            // Calculate Short Count: Total Owners * (Sell % / 100)
+            const shortCount = insightsHelper.getShortCount(insight);
+            
+            const prevState = previousState[ticker] || { shortSparkline: [] };
+            const sparkline = [...(prevState.shortSparkline || [])];
+            
+            sparkline.push(shortCount);
+            if (sparkline.length > 7) sparkline.shift();
+
+            // Calculate simple 7-day growth %
+            let growth7d = 0;
+            if (sparkline.length > 1) {
+                const start = sparkline[0];
+                const end = sparkline[sparkline.length - 1];
+                if (start > 0) {
+                    growth7d = ((end - start) / start) * 100;
+                }
+            }
+
+            this.results[ticker] = {
+                shortCount,
+                shortSparkline: sparkline,
+                growth7d
+            };
+        }
+    }
+
+    async getResult() { return this.results; }
+}
+
+module.exports = ShortInterestGrowth;

package/calculations/core/trending-ownership-momentum.js

@@ -0,0 +1,87 @@
+class TrendingOwnershipMomentum {
+    constructor() { this.results = {}; }
+
+    static getMetadata() {
+        return {
+            name: 'trending-ownership-momentum',
+            type: 'meta',
+            category: 'core',
+            userType: 'n/a',
+            isHistorical: true, // Needed for rolling history
+            rootDataDependencies: ['insights']
+        };
+    }
+
+    static getDependencies() { return []; }
+
+    static getSchema() {
+        return {
+            "TICKER": {
+                "currentOwners": 0,
+                "sparkline": [0, 0, 0, 0, 0, 0, 0], // 7-Day History
+                "momentumScore": 0.0, // Slope of the trend
+                "trend": "string" // 'RISING', 'FALLING', 'STABLE'
+            }
+        };
+    }
+
+    async process(context) {
+        const { insights: insightsHelper } = context.math;
+        const { previousComputed, mappings } = context;
+        
+        // 1. Get Today's Data
+        const dailyInsights = insightsHelper.getInsights(context, 'today');
+        if (!dailyInsights.length) return;
+
+        // 2. Get Yesterday's State (for rolling history)
+        const previousState = previousComputed['trending-ownership-momentum'] || {};
+
+        for (const insight of dailyInsights) {
+            const instId = insight.instrumentId;
+            const ticker = mappings.instrumentToTicker[instId];
+            if (!ticker) continue;
+
+            const currentCount = insightsHelper.getTotalOwners(insight);
+            const prevState = previousState[ticker] || { sparkline: [] };
+            
+            // 3. Update Rolling Window (Last 7 Days)
+            // Create new array copy to avoid mutation issues
+            const sparkline = [...(prevState.sparkline || [])];
+            sparkline.push(currentCount);
+            
+            // Keep only last 7 entries
+            if (sparkline.length > 7) sparkline.shift();
+
+            // 4. Calculate Momentum Score (Linear Regression Slope)
+            let momentumScore = 0;
+            if (sparkline.length >= 2) {
+                const n = sparkline.length;
+                let sumX = 0, sumY = 0, sumXY = 0, sumXX = 0;
+                for (let i = 0; i < n; i++) {
+                    sumX += i;
+                    sumY += sparkline[i];
+                    sumXY += i * sparkline[i];
+                    sumXX += i * i;
+                }
+                const slope = (n * sumXY - sumX * sumY) / (n * sumXX - sumX * sumX);
+                // Normalize slope by current count to get percentage-like momentum
+                momentumScore = currentCount > 0 ? (slope / currentCount) * 100 : 0;
+            }
+
+            let trend = 'STABLE';
+            if (momentumScore > 0.5) trend = 'RISING';
+            if (momentumScore < -0.5) trend = 'FALLING';
+
+            this.results[ticker] = {
+                currentOwners: currentCount,
+                sparkline,
+                momentumScore,
+                trend
+            };
+        }
+    }
+
+    async getResult() { return this.results; }
+}
+
+module.exports = TrendingOwnershipMomentum;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aiden-shared-calculations-unified",
-  "version": "1.0.103",
+  "version": "1.0.105",
   "description": "Shared calculation modules for the BullTrackers Computation System.",
   "main": "index.js",
   "files": [