bulltrackers-module 1.0.768 → 1.0.770

package/functions/computation-system-v2/devtools/simulation/simulate.js

@@ -0,0 +1,324 @@
+#!/usr/bin/env node
+/**
+ * @fileoverview CLI for Computation Simulation
+ * * Usage:
+ * node simulate.js [command] [options]
+ * * Commands:
+ * serve                    Start the simulation server with dashboard
+ * run <computation>        Run a single computation simulation
+ * run-all <computation>    Run a computation with all its dependencies
+ * validate <computation>   Validate a computation's configuration
+ * list                     List all computations
+ * info <computation>       Get detailed info about a computation
+ * dag                      Print DAG summary
+ * * Options:
+ * --port <port>           Server port (default: 3210)
+ * --entities <count>      Number of mock entities (default: 10)
+ * --date <YYYY-MM-DD>     Target date for simulation
+ * --verbose               Enable verbose logging
+ * --json                  Output in JSON format
+ */
+
+const path = require('path');
+
+// Load config (relative to this script's location)
+const configPath = path.resolve(__dirname, '../../config/bulltrackers.config.js');
+let config;
+try {
+    config = require(configPath);
+} catch (e) {
+    console.error('Failed to load config:', e.message);
+    console.error('Expected at:', configPath);
+    process.exit(1);
+}
+
+const { SimulationEngine } = require('./SimulationEngine');
+const { SimulationServer } = require('./SimulationServer');
+const { DAGAnalyzer } = require('./DAGAnalyzer');
+const { SystemIntrospector } = require('../shared/SystemIntrospector');
+
+// Parse CLI arguments
+const args = process.argv.slice(2);
+const command = args[0] || 'serve';
+const target = args[1];
+
+// Parse options
+const options = {
+    port: parseInt(getOption('--port', '3210')),
+    entities: parseInt(getOption('--entities', '10')),
+    date: getOption('--date', new Date().toISOString().split('T')[0]),
+    verbose: args.includes('--verbose'),
+    json: args.includes('--json')
+};
+
+function getOption(name, defaultValue) {
+    const idx = args.indexOf(name);
+    return idx >= 0 && args[idx + 1] ? args[idx + 1] : defaultValue;
+}
+
+async function main() {
+    switch (command) {
+        case 'serve':
+            await startServer();
+            break;
+
+        case 'run':
+            if (!target) {
+                console.error('Usage: simulate.js run <computation-name>');
+                process.exit(1);
+            }
+            await runSimulation(target, false);
+            break;
+
+        case 'run-all':
+            if (!target) {
+                console.error('Usage: simulate.js run-all <computation-name>');
+                process.exit(1);
+            }
+            await runSimulation(target, true);
+            break;
+
+        case 'validate':
+            if (!target) {
+                console.error('Usage: simulate.js validate <computation-name>');
+                process.exit(1);
+            }
+            await validateComputation(target);
+            break;
+
+        case 'list':
+            await listComputations();
+            break;
+
+        case 'info':
+            if (!target) {
+                console.error('Usage: simulate.js info <computation-name>');
+                process.exit(1);
+            }
+            await showInfo(target);
+            break;
+
+        case 'dag':
+            await showDAG();
+            break;
+
+        case 'help':
+        case '--help':
+        case '-h':
+            showHelp();
+            break;
+
+        default:
+            console.error(`Unknown command: ${command}`);
+            showHelp();
+            process.exit(1);
+    }
+}
+
+async function startServer() {
+    const server = new SimulationServer(config, {
+        port: options.port,
+        entityCount: options.entities,
+        watch: true
+    });
+    await server.start();
+}
+
+async function runSimulation(computationName, withDependencies) {
+    const engine = new SimulationEngine(config, {
+        entityCount: options.entities,
+        targetDate: options.date,
+        verbose: options.verbose
+    });
+
+    console.log(`\n🔄 Running simulation: ${computationName}`);
+    console.log(`   Date: ${options.date}`);
+    console.log(`   Entities: ${options.entities}`);
+    if (withDependencies) {
+        console.log('   Mode: With Dependencies\n');
+    } else {
+        console.log('   Mode: Single Computation\n');
+    }
+
+    try {
+        let result;
+        if (withDependencies) {
+            result = await engine.runWithDependencies(computationName, {
+                targetDate: options.date
+            });
+        } else {
+            result = await engine.runComputation(computationName, {
+                targetDate: options.date
+            });
+        }
+
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        } else {
+            if (result.success) {
+                console.log(`✅ Success!`);
+                console.log(`   Execution Time: ${result.stats.executionTimeMs}ms`);
+                console.log(`   Entities Processed: ${result.stats.entitiesProcessed}`);
+                console.log(`   Memory Used: ${Math.round(result.stats.memoryUsedBytes / 1024)}KB`);
+                console.log(`\nSample Result:`);
+                const keys = Object.keys(result.results);
+                if (keys.length === 0) {
+                    console.log('   (No results returned)');
+                } else {
+                    const firstEntity = keys[0];
+                    console.log(`   Key: ${firstEntity}`);
+                    console.log(JSON.stringify(result.results[firstEntity], null, 2));
+                }
+            } else {
+                console.log(`❌ Failed: ${result.error}`);
+            }
+        }
+    } catch (e) {
+        console.error('Simulation failed:', e.message);
+        if (options.verbose) console.error(e.stack);
+        process.exit(1);
+    }
+}
+
+async function validateComputation(computationName) {
+    const introspector = new SystemIntrospector(config);
+    const configObj = introspector.getComputationConfig(computationName);
+
+    if (!configObj) {
+        console.error(`Computation not found: ${computationName}`);
+        process.exit(1);
+    }
+
+    const result = introspector.validateComputationConfig(configObj);
+
+    if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+    } else {
+        if (result.valid) {
+            console.log(`✅ ${computationName}: Valid`);
+            if (result.warnings.length > 0) {
+                console.log(`\n⚠️  Warnings:`);
+                result.warnings.forEach(w => console.log(`   - ${w}`));
+            }
+        } else {
+            console.log(`❌ ${computationName}: Invalid`);
+            console.log(`\nErrors:`);
+            result.errors.forEach(e => console.log(`   - ${e}`));
+        }
+    }
+}
+
+async function listComputations() {
+    const introspector = new SystemIntrospector(config);
+    const names = introspector.getComputationNames();
+    const levels = introspector.getPassLevels();
+
+    if (options.json) {
+        console.log(JSON.stringify(names.map(n => ({
+            name: n,
+            passLevel: levels.get(n) || 1
+        })), null, 2));
+    } else {
+        console.log(`\n📋 Computations (${names.length} total)\n`);
+
+        // Group by pass level
+        const byLevel = {};
+        for (const name of names) {
+            const level = levels.get(name) || 1;
+            if (!byLevel[level]) byLevel[level] = [];
+            byLevel[level].push(name);
+        }
+
+        for (const level of Object.keys(byLevel).sort((a, b) => a - b)) {
+            console.log(`Pass ${level}:`);
+            byLevel[level].forEach(n => console.log(`  - ${n}`));
+            console.log();
+        }
+    }
+}
+
+async function showInfo(computationName) {
+    const introspector = new SystemIntrospector(config);
+    const dagAnalyzer = new DAGAnalyzer(introspector);
+
+    const info = {
+        name: computationName,
+        passLevel: introspector.getPassLevel(computationName),
+        config: introspector.getComputationConfig(computationName),
+        validation: introspector.validateComputationConfig(
+            introspector.getComputationConfig(computationName)
+        ),
+        impact: dagAnalyzer.getImpactAnalysis(computationName)
+    };
+
+    if (options.json) {
+        console.log(JSON.stringify(info, null, 2));
+    } else {
+        console.log(`\n📊 ${computationName}\n`);
+        console.log(`Pass Level: ${info.passLevel}`);
+        console.log(`Type: ${info.config?.type || 'unknown'}`);
+        console.log(`Category: ${info.config?.category || 'unknown'}`);
+        console.log(`\nDependencies: ${info.impact.directDependents.length > 0 ? '' : 'None'}`);
+        (info.config?.dependencies || []).forEach(d => console.log(`  ← ${d}`));
+        console.log(`\nDependents: ${info.impact.directDependents.length > 0 ? '' : 'None'}`);
+        info.impact.directDependents.forEach(d => console.log(`  → ${d}`));
+        console.log(`\nValidation: ${info.validation.valid ? '✅ Valid' : '❌ Invalid'}`);
+    }
+}
+
+async function showDAG() {
+    const introspector = new SystemIntrospector(config);
+    const dagAnalyzer = new DAGAnalyzer(introspector);
+    const summary = dagAnalyzer.getSummary();
+
+    if (options.json) {
+        console.log(JSON.stringify(summary, null, 2));
+    } else {
+        console.log(`\n📈 DAG Summary\n`);
+        console.log(`Total Computations: ${summary.totalNodes}`);
+        console.log(`Total Edges: ${summary.totalEdges}`);
+        console.log(`Total Passes: ${summary.totalPasses}`);
+        console.log(`Entry Points: ${summary.entryPointCount}`);
+        console.log(`  ${summary.entryPoints.join(', ')}${summary.entryPointCount > 5 ? '...' : ''}`);
+        if (summary.cycles.length > 0) {
+            console.log(`\n⚠️ Cycles Detected: ${summary.cycles.length}`);
+        }
+    }
+}
+
+function showHelp() {
+    console.log(`
+Computation Simulator CLI
+
+Usage: node simulate.js [command] [options]
+
+Commands:
+  serve                    Start the simulation server with dashboard
+  run <computation>        Run a single computation simulation
+  run-all <computation>    Run a computation with all its dependencies
+  validate <computation>   Validate a computation's configuration
+  list                     List all computations
+  info <computation>       Get detailed info about a computation
+  dag                      Print DAG summary
+
+Options:
+  --port <port>           Server port (default: 3210)
+  --entities <count>      Number of mock entities (default: 10)
+  --date <YYYY-MM-DD>     Target date for simulation
+  --verbose               Enable verbose logging
+  --json                  Output in JSON format
+  -h, --help              Show this help message
+
+Examples:
+  node simulate.js serve
+  node simulate.js run SignedInUserMirrorHistory --entities 50
+  node simulate.js run-all PopularInvestorProfileMetrics --date 2026-01-15
+  node simulate.js validate SignedInUserList
+`);
+}
+
+main().catch(e => {
+    console.error('Fatal error:', e.message);
+    if (options.verbose) console.error(e.stack);
+    process.exit(1);
+});

package/functions/computation-system-v2/devtools/vscode-computation/package.json

@@ -0,0 +1,90 @@
+{
+    "name": "computation-developer",
+    "displayName": "BullTrackers Computation Developer",
+    "description": "Intelligent autocomplete and validation for BullTrackers computations",
+    "version": "0.1.0",
+    "publisher": "bulltrackers",
+    "engines": {
+        "vscode": "^1.75.0"
+    },
+    "categories": [
+        "Programming Languages",
+        "Linters",
+        "Snippets"
+    ],
+    "activationEvents": [
+        "onLanguage:javascript",
+        "workspaceContains:**/computation-system-v2/**"
+    ],
+    "main": "./out/extension.js",
+    "contributes": {
+        "configuration": {
+            "title": "Computation Developer",
+            "properties": {
+                "computationDeveloper.enableDiagnostics": {
+                    "type": "boolean",
+                    "default": true,
+                    "description": "Enable real-time validation diagnostics"
+                },
+                "computationDeveloper.enableHover": {
+                    "type": "boolean",
+                    "default": true,
+                    "description": "Enable hover documentation"
+                },
+                "computationDeveloper.maxLookbackWarningThreshold": {
+                    "type": "number",
+                    "default": 63,
+                    "description": "Warn when lookback exceeds this percentage of max (90)"
+                },
+                "computationDeveloper.simulationServerUrl": {
+                    "type": "string",
+                    "default": "http://localhost:3210",
+                    "description": "URL of the simulation server"
+                }
+            }
+        },
+        "commands": [
+            {
+                "command": "computationDeveloper.validate",
+                "title": "Validate Computation",
+                "category": "Computation"
+            },
+            {
+                "command": "computationDeveloper.simulate",
+                "title": "Simulate Computation",
+                "category": "Computation"
+            },
+            {
+                "command": "computationDeveloper.showDAG",
+                "title": "Show DAG Position",
+                "category": "Computation"
+            },
+            {
+                "command": "computationDeveloper.generateBoilerplate",
+                "title": "Generate Computation Boilerplate",
+                "category": "Computation"
+            }
+        ],
+        "snippets": [
+            {
+                "language": "javascript",
+                "path": "./snippets/computation.json"
+            }
+        ]
+    },
+    "scripts": {
+        "vscode:prepublish": "npm run compile",
+        "compile": "tsc -p ./",
+        "watch": "tsc -watch -p ./",
+        "lint": "eslint src --ext ts"
+    },
+    "devDependencies": {
+        "@types/vscode": "^1.75.0",
+        "@types/node": "^18.x",
+        "typescript": "^5.0.0",
+        "eslint": "^8.0.0"
+    },
+    "dependencies": {
+        "vscode-languageclient": "^8.0.0"
+    }
+}

package/functions/computation-system-v2/devtools/vscode-computation/snippets/computation.json

@@ -0,0 +1,128 @@
+{
+    "Computation Class": {
+        "prefix": "comp",
+        "body": [
+            "const { Computation } = require('../framework');",
+            "",
+            "class ${1:ComputationName} extends Computation {",
+            "    static getConfig() {",
+            "        return {",
+            "            name: '${1:ComputationName}',",
+            "            description: '${2:Description}',",
+            "            type: '${3|per-entity,global|}',",
+            "            category: '${4|signed_in_user,popular_investor,global|}',",
+            "            isHistorical: ${5|false,true|},",
+            "            requires: {",
+            "                '${6:table_name}': {",
+            "                    lookback: ${7:0},",
+            "                    mandatory: true,",
+            "                    fields: [${8:'user_id', 'date'}]",
+            "                }",
+            "            },",
+            "            storage: {",
+            "                bigquery: true,",
+            "                firestore: {",
+            "                    enabled: ${9|false,true|},",
+            "                    path: '${10:collection}/{entityId}',",
+            "                    merge: true",
+            "                }",
+            "            }",
+            "        };",
+            "    }",
+            "",
+            "    async process(data, { entityId, targetDate, rules, getDependency }) {",
+            "        $0",
+            "        return {",
+            "            // result",
+            "        };",
+            "    }",
+            "}",
+            "",
+            "module.exports = ${1:ComputationName};"
+        ],
+        "description": "Create a new computation class"
+    },
+    "Computation Config": {
+        "prefix": "compconfig",
+        "body": [
+            "static getConfig() {",
+            "    return {",
+            "        name: '${1:ComputationName}',",
+            "        description: '${2:Description}',",
+            "        type: '${3|per-entity,global|}',",
+            "        category: '${4|signed_in_user,popular_investor,global|}',",
+            "        isHistorical: ${5|false,true|},",
+            "        requires: {",
+            "            ${0}",
+            "        }",
+            "    };",
+            "}"
+        ],
+        "description": "Computation config method"
+    },
+    "Table Requirement": {
+        "prefix": "req",
+        "body": [
+            "'${1:table_name}': {",
+            "    lookback: ${2:0},",
+            "    mandatory: ${3|true,false|},",
+            "    fields: [${4:'user_id', 'date'}]",
+            "}"
+        ],
+        "description": "Add a table requirement"
+    },
+    "Dependency Requirement": {
+        "prefix": "dep",
+        "body": [
+            "'${1:DependencyName}': {",
+            "    type: 'metric',",
+            "    computation: '${1:DependencyName}',",
+            "    mandatory: ${2|true,false|}",
+            "}"
+        ],
+        "description": "Add a computation dependency"
+    },
+    "Storage Config": {
+        "prefix": "storage",
+        "body": [
+            "storage: {",
+            "    bigquery: true,",
+            "    firestore: {",
+            "        enabled: ${1|true,false|},",
+            "        path: '${2:collection}/{entityId}',",
+            "        merge: true",
+            "    }",
+            "}"
+        ],
+        "description": "Storage configuration block"
+    },
+    "Process Method": {
+        "prefix": "process",
+        "body": [
+            "async process(data, { entityId, targetDate, rules, getDependency }) {",
+            "    const ${1:tableData} = data.${2:table_name}[entityId] || [];",
+            "    ",
+            "    $0",
+            "    ",
+            "    return {",
+            "        // result",
+            "    };",
+            "}"
+        ],
+        "description": "Process method template"
+    },
+    "Extract Rule": {
+        "prefix": "rulesext",
+        "body": [
+            "const ${1:result} = rules.${2|portfolio,metrics,rankings|}.${3:functionName}(${4:data});"
+        ],
+        "description": "Use a rules function"
+    },
+    "Get Dependency": {
+        "prefix": "getdep",
+        "body": [
+            "const ${1:depResult} = getDependency('${2:DependencyName}', entityId);"
+        ],
+        "description": "Get dependency result"
+    }
+}