bulltrackers-module 1.0.768 → 1.0.770

package/functions/computation-system-v2/legacy/PiAssetRecommender.js.old

@@ -0,0 +1,115 @@
+const { Computation } = require('../framework');
+
+class PiAssetRecommender extends Computation {
+    static getConfig() {
+        return {
+            name: 'PiAssetRecommender',
+            type: 'per-entity', // Recommendation is specific to THIS user
+            category: 'recommendations',
+            
+            // 1. We rely on Global computations that pre-calculate the similarity graph
+            dependencies: ['PiSimilarityMatrix', 'PiTopHoldings'],
+            
+            requires: {
+                'portfolio_snapshots': {
+                    lookback: 0,
+                    mandatory: true,
+                    fields: ['user_id', 'portfolio_data'] // Needed to get Mirrors
+                },
+                'user_watchlists': { // Assuming table existence
+                    lookback: 0,
+                    mandatory: false,
+                    fields: ['user_id', 'watched_pi_ids']
+                }
+            },
+            
+            storage: {
+                bigquery: true,
+                firestore: { enabled: true, path: 'users/{entityId}/recommendations' }
+            }
+        };
+    }
+
+    async process(context) {
+        const { data, entityId, rules, getDependency } = context;
+
+        // 1. Get User's Signals (Mirrors + Watchlist)
+        const seedPIs = new Set();
+        
+        // A. From Mirrors
+        const portfolioRow = data['portfolio_snapshots'];
+        if (portfolioRow) {
+            const pData = rules.portfolio.extractPortfolioData(portfolioRow);
+            const mirrors = rules.portfolio.extractMirrors(pData);
+            mirrors.forEach(m => {
+                if (m.ParentCID) seedPIs.add(String(m.ParentCID));
+            });
+        }
+
+        // B. From Watchlist
+        const watchlistRow = data['user_watchlists'];
+        if (watchlistRow && watchlistRow.watched_pi_ids) {
+            // Assuming array of IDs in column
+            const ids = Array.isArray(watchlistRow.watched_pi_ids) 
+                ? watchlistRow.watched_pi_ids 
+                : JSON.parse(watchlistRow.watched_pi_ids);
+            ids.forEach(id => seedPIs.add(String(id)));
+        }
+
+        if (seedPIs.size === 0) return; // No signals, no recommendations
+
+        // 2. Load Global Context (The Graph) via Dependencies
+        // These are large objects, so typically we fetch specific parts or the whole thing
+        // Assuming getDependency returns a Map of PI_ID -> Data
+        const similarityGraph = getDependency('PiSimilarityMatrix'); 
+        const piHoldings = getDependency('PiTopHoldings');
+
+        if (!similarityGraph || !piHoldings) return;
+
+        // 3. Find Similar PIs (Collaborative Filtering)
+        const candidateAssets = new Map(); // AssetID -> Score
+
+        seedPIs.forEach(seedId => {
+            // Find PIs similar to the ones I already copy/watch
+            const neighbors = similarityGraph[seedId] || []; // List of { id, score }
+            
+            neighbors.forEach(neighbor => {
+                const neighborId = String(neighbor.id);
+                const similarityScore = neighbor.score;
+
+                // What does this neighbor hold?
+                const holdings = piHoldings[neighborId] || []; // List of { assetId, weight }
+                
+                holdings.forEach(holding => {
+                    const currentScore = candidateAssets.get(holding.assetId) || 0;
+                    // Boost score based on PI similarity and holding weight
+                    candidateAssets.set(holding.assetId, currentScore + (similarityScore * holding.weight));
+                });
+            });
+        });
+
+        // 4. Filter Assets User Already Owns
+        // (Re-use portfolio logic)
+        const myAssets = new Set();
+        if (portfolioRow) {
+            const pData = rules.portfolio.extractPortfolioData(portfolioRow);
+            const positions = rules.portfolio.extractPositions(pData);
+            positions.forEach(p => myAssets.add(String(rules.portfolio.getInstrumentId(p))));
+        }
+
+        // 5. Final Ranking
+        const recommendations = Array.from(candidateAssets.entries())
+            .filter(([assetId]) => !myAssets.has(String(assetId))) // Exclude owned
+            .sort((a, b) => b[1] - a[1]) // Sort by score DESC
+            .slice(0, 5) // Top 5
+            .map(([assetId, score]) => ({
+                assetId: Number(assetId),
+                score: Number(score.toFixed(4)),
+                reason: 'Held by investors similar to those you copy'
+            }));
+
+        this.setResult(entityId, { recommendations });
+    }
+}
+
+module.exports = PiAssetRecommender;

package/functions/computation-system-v2/legacy/PiSimilarityMatrix.js

@@ -0,0 +1,104 @@
+/**
+ * @fileoverview Similarity Matrix Meta-Computation.
+ * Calculates cosine similarity between all PI vectors to find nearest neighbors.
+ */
+class PiSimilarityMatrix {
+    constructor() { this.results = {}; }
+
+    static getMetadata() {
+        return {
+            type: 'meta', // Runs once per date
+            category: 'popular_investor_meta',
+            userType: 'POPULAR_INVESTOR'
+        };
+    }
+
+    // DEPENDENCY: Forces this to run in Pass 2
+    static getDependencies() { return ['PiSimilarityVector']; } 
+
+    static getSchema() {
+        return {
+            type: 'object', // Map<UserId, Array<SimilarUser>>
+            description: 'Top 5 similar users for each PI'
+        };
+    }
+
+    async process(context) {
+        const vectorMap = context.computed['PiSimilarityVector'];
+        
+        // [FIX] Ensure we have enough peers to actually compare
+        if (!vectorMap || Object.keys(vectorMap).length < 2) {
+            this.results = {}; // Explicitly set empty
+            return this.results; 
+        }
+
+        const userIds = Object.keys(vectorMap);
+        const matrix = {};
+
+        for (let i = 0; i < userIds.length; i++) {
+            const u1 = userIds[i];
+            const v1 = vectorMap[u1];
+            
+            // Skip empty vectors
+            if (!v1 || Object.keys(v1).length === 0) continue;
+
+            const matches = [];
+
+            // Compare against every other user
+            for (let j = 0; j < userIds.length; j++) {
+                if (i === j) continue; // Don't compare self
+
+                const u2 = userIds[j];
+                const v2 = vectorMap[u2];
+
+                if (!v2 || Object.keys(v2).length === 0) continue;
+
+                // Calculate Cosine Similarity
+                let dotProduct = 0;
+                let mag1 = 0;
+                let mag2 = 0;
+
+                // v1 magnitude & dot product
+                for (const [k, val] of Object.entries(v1)) {
+                    mag1 += (val * val);
+                    if (v2[k]) dotProduct += (val * v2[k]);
+                }
+                
+                // v2 magnitude
+                for (const val of Object.values(v2)) {
+                    mag2 += (val * val);
+                }
+
+                mag1 = Math.sqrt(mag1);
+                mag2 = Math.sqrt(mag2);
+
+                if (mag1 > 0 && mag2 > 0) {
+                    const similarity = dotProduct / (mag1 * mag2);
+                    if (similarity > 0.1) { // Threshold to filter noise
+                        matches.push({ 
+                            id: u2, 
+                            score: Number(similarity.toFixed(4)),
+                            reason: "Portfolio Composition Match" 
+                        });
+                    }
+                }
+            }
+
+            // Sort by score desc and take top 5
+            matrix[u1] = matches.sort((a,b) => b.score - a.score).slice(0, 5);
+        }
+
+        // --- CRITICAL FIX ---
+        // 1. Assign to class property (for getResult)
+        this.results = matrix;
+
+        // 2. Return to MetaExecutor (for wrapping)
+        return this.results;
+    }
+
+    async getResult() {
+        return this.results;
+    }
+}
+
+module.exports = PiSimilarityMatrix;

package/functions/computation-system-v2/legacy/PiSimilarityVector.js

@@ -0,0 +1,71 @@
+/**
+ * @fileoverview Similarity Vector for Popular Investors.
+ * Generates a normalized asset allocation vector.
+ */
+
+class PiSimilarityVector {
+    constructor() {
+        this.results = {}; 
+    }
+
+    static getMetadata() {
+        return {
+            type: 'standard', // MUST be 'standard'
+            category: 'popular_investor',
+            rootDataDependencies: ['portfolio'],
+            userType: 'POPULAR_INVESTOR'
+        };
+    }
+
+    static getDependencies() { return []; } 
+
+    static getSchema() {
+        return {
+            type: 'object',
+            patternProperties: {
+                "^[0-9]+$": { type: 'number' } // InstrumentID -> Weight
+            },
+            description: 'Normalized Asset Allocation Vector'
+        };
+    }
+
+    process(context) {
+        const { DataExtractor } = context.math;
+        const userId = context.user.id;
+        const portfolio = context.user.portfolio.today;
+
+        if (!portfolio) {
+            this.results[userId] = {};
+            return;
+        }
+
+        const positions = DataExtractor.getPositions(portfolio, 'POPULAR_INVESTOR');
+        const vector = {};
+        let totalValue = 0;
+        
+        for (const pos of positions) {
+            const id = DataExtractor.getInstrumentId(pos);
+            const weight = DataExtractor.getPositionWeight(pos);
+            
+            if (id && weight > 0) {
+                vector[id] = (vector[id] || 0) + weight;
+                totalValue += weight;
+            }
+        }
+
+        // Normalize
+        if (totalValue > 0) {
+            for (const key in vector) {
+                vector[key] = Number((vector[key] / totalValue).toFixed(6));
+            }
+        }
+
+        this.results[userId] = vector;
+    }
+
+    async getResult() {
+        return this.results;
+    }
+}
+
+module.exports = PiSimilarityVector;

package/functions/computation-system-v2/scripts/debug_aggregation.js

@@ -0,0 +1,25 @@
+const { BigQuery } = require('@google-cloud/bigquery');
+const config = require('../config/bulltrackers.config');
+
+async function checkAggregation() {
+    const bq = new BigQuery({ projectId: config.bigquery.projectId });
+    const date = '2026-01-30';
+
+    console.log(`Checking Aggregation on ${date}`);
+
+    const query = `
+        SELECT user_type, COUNT(*) as count 
+        FROM \`${config.bigquery.projectId}.${config.bigquery.dataset}.portfolio_snapshots\` 
+        WHERE date = @date 
+        GROUP BY 1
+    `;
+
+    const [rows] = await bq.query({
+        query,
+        params: { date }
+    });
+
+    console.log('Result:', rows);
+}
+
+checkAggregation().catch(console.error);

package/functions/computation-system-v2/scripts/test-invalidation-scenarios.js

@@ -0,0 +1,234 @@
+/**
+ * @fileoverview Real-World Invalidation Simulator
+ * Dynamically loads ALL computation AND rule code to verify:
+ * 1. Code Hash Generation (using real files).
+ * 2. Invalidation logic (Simulated DB vs Real Disk Hash).
+ * 3. Dependency chains (Dynamic discovery of chains).
+ * * Usage: node scripts/test-real-scenarios.js
+ */
+
+const fs = require('fs');
+const path = require('path');
+const assert = require('assert');
+
+// Framework Components
+const { RunAnalyzer } = require('../framework/core/RunAnalyzer');
+const { Orchestrator } = require('../framework/execution/Orchestrator');
+const { ManifestBuilder } = require('../framework/core/Manifest');
+
+// -----------------------------------------------------------------------------
+// 1. MOCKS (Virtual Environment)
+// -----------------------------------------------------------------------------
+
+class MockDataFetcher {
+    async checkAvailability() { return { canRun: true, missing: [] }; }
+}
+
+class MockStateRepository {
+    constructor() {
+        this.statusMap = new Map();
+        this.results = new Map();
+    }
+
+    setDailyStatus(date, compName, status) {
+        if (!this.statusMap.has(date)) this.statusMap.set(date, new Map());
+        this.statusMap.get(date).set(compName.toLowerCase(), status);
+    }
+
+    async getDailyStatus(date) {
+        return this.statusMap.get(date) || new Map();
+    }
+    
+    // Simulate finding history for backfills
+    async getRunDates(compName) { return ['2024-01-01', '2024-01-02']; }
+
+    // Mock Result fetching
+    async getResult(date, compName) { return this.results.get(`${date}:${compName}`); }
+}
+
+class TestOrchestrator extends Orchestrator {
+    constructor(config, stateRepo) {
+        super(config);
+        this.stateRepository = stateRepo;
+        this.scheduledTasks = [];
+    }
+    async _scheduleCloudTask(name, date, source, delay) {
+        this.scheduledTasks.push({ name, date, source });
+    }
+    _log(level, msg) { /* console.log(`[${level}] ${msg}`); */ }
+}
+
+// -----------------------------------------------------------------------------
+// 2. HELPER: Dynamic Loader
+// -----------------------------------------------------------------------------
+function loadModulesFromDir(directory, label) {
+    let modules = [];
+    try {
+        if (fs.existsSync(directory)) {
+            const files = fs.readdirSync(directory).filter(f => f.endsWith('.js') && f !== 'index.js');
+            console.log(`INFO: Found ${files.length} ${label} files in ${directory}`);
+            
+            modules = files.map(file => {
+                try {
+                    return require(path.join(directory, file));
+                } catch (e) {
+                    console.warn(`WARN: Failed to load ${file}: ${e.message}`);
+                    return null;
+                }
+            }).filter(c => c !== null);
+        } else {
+            console.warn(`WARN: ${label} directory not found at ${directory}`);
+        }
+    } catch (e) {
+        console.error(`ERROR: Could not load ${label}: ${e.message}`);
+    }
+    return modules;
+}
+
+// -----------------------------------------------------------------------------
+// 3. TEST SUITE
+// -----------------------------------------------------------------------------
+
+async function runRealWorldTests() {
+    console.log('┌────────────────────────────────────────────────────────┐');
+    console.log('│           REAL CODE SIMULATION SUITE                   │');
+    console.log('└────────────────────────────────────────────────────────┘');
+
+    // 1. LOAD ARTIFACTS
+    const computationsDir = path.join(__dirname, '../computations');
+    const rulesDir = path.join(__dirname, '../rules');
+
+    const computationClasses = loadModulesFromDir(computationsDir, 'computation');
+    const ruleModules = loadModulesFromDir(rulesDir, 'rule'); // <--- NEW: Load Rules
+
+    if (computationClasses.length === 0) {
+        console.error("❌ ABORT: No valid computations found to test.");
+        return;
+    }
+
+    // 2. BUILD REAL MANIFEST
+    const config = {
+        computations: computationClasses,
+        rules: ruleModules // <--- NEW: Pass Rules to Config
+    };
+    
+    // Initialize ManifestBuilder (this internally initializes RulesRegistry too)
+    const builder = new ManifestBuilder(config, console);
+    const realManifest = builder.build(config.computations);
+    
+    console.log(`INFO: Successfully built manifest with ${realManifest.length} entries.`);
+
+    // 3. RUN TESTS
+    await test_RealCodeInvalidation(realManifest);
+    await test_DynamicDependencyCascading(realManifest, config);
+}
+
+/**
+ * SCENARIO 1: Simulate a Deployment (Code Change)
+ */
+async function test_RealCodeInvalidation(manifest) {
+    // Pick 'RiskScoreIncrease' if available, otherwise the first one
+    let target = manifest.find(c => c.name === 'riskscoreincrease');
+    if (!target) target = manifest[0];
+
+    console.log(`\n🧪 Test 1: Real Code Hash Mismatch (${target.originalName})`);
+
+    const analyzer = new RunAnalyzer(manifest, new MockDataFetcher());
+    const date = '2024-06-01';
+    
+    // CONDITION: The DB has an old/different hash
+    const dailyStatus = new Map();
+    dailyStatus.set(target.name, { 
+        hash: 'OLD_DEPLOYMENT_HASH_123', 
+        resultHash: 'res_v1', 
+        updatedAt: new Date().toISOString() 
+    });
+
+    // ANALYZE
+    const result = await analyzer._evaluateEntry(target, date, true, dailyStatus, new Map());
+
+    // ASSERT
+    try {
+        assert.strictEqual(result.type, 'reRuns', 'Should trigger re-run');
+        assert.strictEqual(result.payload.reason, 'Code changed', 'Reason must be code change');
+        
+        console.log(`   [Current Disk Hash]: ${target.hash.substring(0, 16)}...`);
+        console.log(`   [Simulated DB Hash]: OLD_DEPLOYMENT_HASH_123`);
+        console.log('✅ PASS: System correctly detected the code mismatch.');
+    } catch (e) {
+        console.error('❌ FAIL:', e.message);
+        console.log('   Decision:', result);
+    }
+}
+
+/**
+ * SCENARIO 2: Dynamic Dependency Propagation
+ */
+async function test_DynamicDependencyCascading(manifest, config) {
+    console.log('\n🧪 Test 2: Dependency Propagation (Dynamic Chain Detection)');
+
+    // 1. Find a valid dependency chain (Parent -> Child)
+    let upstream = null;
+    let downstream = null;
+
+    for (const child of manifest) {
+        if (child.dependencies && child.dependencies.length > 0) {
+            // Find the parent object
+            const parentName = child.dependencies[0]; // normalized name usually
+            const parent = manifest.find(c => c.name === parentName); // match normalized names
+            
+            if (parent) {
+                upstream = parent;
+                downstream = child;
+                break; // Found a pair!
+            }
+        }
+    }
+
+    // 2. Handle Case: No Chains Found
+    if (!upstream || !downstream) {
+        console.log('⚠️  SKIPPED: No valid dependency chains found in the loaded computations.');
+        console.log('   (This is NOT a failure. It simply means all loaded computations are independent)');
+        console.log('✅ PASS: Skipped due to lack of testable chains.');
+        return;
+    }
+
+    console.log(`   Found chain: ${upstream.originalName} -> ${downstream.originalName}`);
+
+    // 3. Setup Orchestrator
+    const mockState = new MockStateRepository();
+    const orch = new TestOrchestrator({ ...config, bigquery: {}, tables: {} }, mockState);
+    orch.manifest = manifest;
+    orch._buildDependentsIndex();
+
+    const date = '2024-06-01';
+
+    // 4. Simulate Upstream Finishing
+    mockState.setDailyStatus(date, upstream.name, {
+        hash: upstream.hash,
+        resultHash: 'NEW_RESULT_HASH_XYZ',
+        updatedAt: new Date().toISOString()
+    });
+
+    // 5. Trigger Cascading Logic
+    await orch._scheduleDependents(upstream, date);
+
+    // 6. Assert
+    try {
+        const task = orch.scheduledTasks.find(t => t.name === downstream.originalName);
+        if (task) {
+             console.log(`   [Triggered]: ${task.name} due to update in ${upstream.name}`);
+             console.log('✅ PASS: Dependency chain resolved and task scheduled.');
+        } else {
+             console.error(`❌ FAIL: Downstream task (${downstream.name}) was NOT scheduled.`);
+             console.log('   Dependents Map keys:', Array.from(orch.dependentsByName.keys()));
+        }
+    } catch (e) {
+        console.error('❌ FAIL:', e.message);
+    }
+}
+
+// EXECUTE
+runRealWorldTests().catch(e => {
+    console.error('FATAL:', e);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulltrackers-module",
-  "version": "1.0.768",
+  "version": "1.0.770",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [