bulltrackers-module 1.0.768 → 1.0.769

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

@@ -0,0 +1,581 @@
+/**
+ * @fileoverview Simulation Server
+ * 
+ * HTTP server with WebSocket for live updates.
+ * Provides:
+ * - REST API for simulation control
+ * - File watcher for auto-reload
+ * - WebSocket for live result push
+ * - Dashboard serving
+ */
+
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const { promisify } = require('util');
+
+// Try to load optional dependencies
+let chokidar;
+try {
+    chokidar = require('chokidar');
+} catch (e) {
+    console.warn('chokidar not available - file watching disabled');
+}
+
+const { SimulationEngine } = require('./SimulationEngine');
+const { DAGAnalyzer } = require('./DAGAnalyzer');
+const { SystemIntrospector } = require('../shared/SystemIntrospector');
+
+class SimulationServer {
+    /**
+     * @param {Object} config - The bulltrackers.config.js exports
+     * @param {Object} options
+     * @param {number} [options.port=3210] - Server port
+     * @param {boolean} [options.watch=true] - Enable file watching
+     * @param {string} [options.computationsDir] - Directory to watch
+     * @param {number} [options.entityCount=10] - Default entity count
+     */
+    constructor(config, options = {}) {
+        this.config = config;
+        this.port = options.port || 3210;
+        this.shouldWatch = options.watch !== false;
+        this.computationsDir = options.computationsDir ||
+            path.resolve(__dirname, '../../computations');
+        this.entityCount = options.entityCount || 10;
+
+        // Core components
+        this.engine = new SimulationEngine(config, {
+            entityCount: this.entityCount,
+            verbose: true
+        });
+        this.introspector = new SystemIntrospector(config);
+        this.dagAnalyzer = new DAGAnalyzer(this.introspector);
+
+        // Server state
+        this.server = null;
+        this.watcher = null;
+        this.clients = new Set(); // WebSocket-like clients (SSE)
+
+        // Current simulation state
+        this.lastRun = null;
+        this.activeComputation = null;
+    }
+
+    /**
+     * Start the server.
+     */
+    async start() {
+        await this.engine.initialize();
+
+        this.server = http.createServer((req, res) => this._handleRequest(req, res));
+
+        this.server.listen(this.port, () => {
+            console.log(`\n🚀 Simulation Server running at http://localhost:${this.port}`);
+            console.log(`   Dashboard: http://localhost:${this.port}/`);
+            console.log(`   API: http://localhost:${this.port}/api`);
+            console.log(`\n   Watching: ${this.computationsDir}\n`);
+        });
+
+        // Start file watcher
+        if (this.shouldWatch && chokidar) {
+            this._startWatcher();
+        }
+    }
+
+    /**
+     * Stop the server.
+     */
+    stop() {
+        if (this.watcher) {
+            this.watcher.close();
+        }
+        if (this.server) {
+            this.server.close();
+        }
+    }
+
+    // =========================================================================
+    // REQUEST HANDLING
+    // =========================================================================
+
+    _handleRequest(req, res) {
+        const url = new URL(req.url, `http://localhost:${this.port}`);
+        const pathname = url.pathname;
+
+        // CORS headers
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+
+        // Route handling
+        if (pathname === '/' || pathname === '/index.html') {
+            this._serveDashboard(res);
+        } else if (pathname === '/dashboard.css') {
+            this._serveFile(res, 'dashboard.css', 'text/css');
+        } else if (pathname === '/dashboard.js') {
+            this._serveFile(res, 'dashboard.js', 'application/javascript');
+        } else if (pathname === '/events') {
+            this._handleSSE(req, res);
+        } else if (pathname.startsWith('/api/')) {
+            this._handleAPI(req, res, pathname, url);
+        } else {
+            res.writeHead(404);
+            res.end('Not Found');
+        }
+    }
+
+    async _handleAPI(req, res, pathname, url) {
+        res.setHeader('Content-Type', 'application/json');
+
+        try {
+            let result;
+
+            switch (pathname) {
+                case '/api/stats':
+                    result = this.introspector.getStats();
+                    break;
+
+                case '/api/computations':
+                    result = this.introspector.getComputationNames().map(name => ({
+                        name,
+                        passLevel: this.introspector.getPassLevel(name),
+                        config: this.introspector.getComputationConfig(name)
+                    }));
+                    break;
+
+                case '/api/dag':
+                    result = this.dagAnalyzer.getVisualizationData();
+                    break;
+
+                case '/api/dag/summary':
+                    result = this.dagAnalyzer.getSummary();
+                    break;
+
+                case '/api/tables':
+                    result = this.introspector.getAvailableTables().map(name => ({
+                        name,
+                        ...this.introspector.getTableMetadata(name)
+                    }));
+                    break;
+
+                case '/api/rules':
+                    result = {};
+                    for (const mod of this.introspector.getRuleModules()) {
+                        result[mod] = this.introspector.getRuleFunctions(mod);
+                    }
+                    break;
+
+                case '/api/simulate': {
+                    // POST body contains computation name
+                    const body = await this._readBody(req);
+                    const { computation, entityCount, entityIds, targetDate } = JSON.parse(body);
+
+                    this.activeComputation = computation;
+                    this._broadcast({ type: 'simulationStarted', computation });
+
+                    result = await this.engine.runComputation(computation, {
+                        entityCount: entityCount || this.entityCount,
+                        entityIds,
+                        targetDate
+                    });
+
+                    this.lastRun = { computation, result, timestamp: new Date().toISOString() };
+                    this._broadcast({ type: 'simulationComplete', ...this.lastRun });
+                    this.activeComputation = null;
+                    break;
+                }
+
+                case '/api/simulate-with-deps': {
+                    const body = await this._readBody(req);
+                    const { computation, entityCount, targetDate } = JSON.parse(body);
+
+                    this.activeComputation = computation;
+                    this._broadcast({ type: 'simulationStarted', computation, withDependencies: true });
+
+                    result = await this.engine.runWithDependencies(computation, {
+                        entityCount: entityCount || this.entityCount,
+                        targetDate
+                    });
+
+                    this.lastRun = { computation, result, timestamp: new Date().toISOString() };
+                    this._broadcast({ type: 'simulationComplete', ...this.lastRun });
+                    this.activeComputation = null;
+                    break;
+                }
+
+                case '/api/validate': {
+                    const body = await this._readBody(req);
+                    const { computation } = JSON.parse(body);
+                    result = this.engine.validateComputation(computation);
+                    break;
+                }
+
+                case '/api/info': {
+                    const computation = url.searchParams.get('computation');
+                    result = this.engine.getComputationInfo(computation);
+                    break;
+                }
+
+                case '/api/results': {
+                    const computation = url.searchParams.get('computation');
+                    result = this.engine.getResults(computation);
+                    break;
+                }
+
+                case '/api/reset':
+                    this.engine.reset();
+                    result = { success: true };
+                    break;
+
+                case '/api/last-run':
+                    result = this.lastRun || null;
+                    break;
+
+                case '/api/execution-log':
+                    result = this.engine.getExecutionLog();
+                    break;
+
+                default:
+                    res.writeHead(404);
+                    result = { error: 'Unknown endpoint' };
+            }
+
+            res.writeHead(200);
+            res.end(JSON.stringify(result, null, 2));
+
+        } catch (error) {
+            res.writeHead(500);
+            res.end(JSON.stringify({ error: error.message, stack: error.stack }));
+        }
+    }
+
+    // =========================================================================
+    // SSE (Server-Sent Events)
+    // =========================================================================
+
+    _handleSSE(req, res) {
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive'
+        });
+
+        const client = {
+            send: (data) => {
+                res.write(`data: ${JSON.stringify(data)}\n\n`);
+            }
+        };
+
+        this.clients.add(client);
+
+        req.on('close', () => {
+            this.clients.delete(client);
+        });
+
+        // Send initial state
+        client.send({ type: 'connected', timestamp: new Date().toISOString() });
+    }
+
+    _broadcast(data) {
+        for (const client of this.clients) {
+            try {
+                client.send(data);
+            } catch (e) {
+                this.clients.delete(client);
+            }
+        }
+    }
+
+    // =========================================================================
+    // FILE WATCHING
+    // =========================================================================
+
+    _startWatcher() {
+        this.watcher = chokidar.watch(path.join(this.computationsDir, '**/*.js'), {
+            ignoreInitial: true
+        });
+
+        this.watcher.on('change', (filepath) => {
+            const filename = path.basename(filepath);
+            console.log(`📝 File changed: ${filename}`);
+
+            // Clear require cache for this file
+            delete require.cache[require.resolve(filepath)];
+
+            this._broadcast({
+                type: 'fileChanged',
+                file: filename,
+                path: filepath,
+                timestamp: new Date().toISOString()
+            });
+
+            // TODO: Auto-rerun if active computation matches changed file
+        });
+    }
+
+    // =========================================================================
+    // STATIC FILE SERVING
+    // =========================================================================
+
+    _serveDashboard(res) {
+        const dashboardPath = path.join(__dirname, 'ui', 'dashboard.html');
+        if (fs.existsSync(dashboardPath)) {
+            res.setHeader('Content-Type', 'text/html');
+            res.writeHead(200);
+            res.end(fs.readFileSync(dashboardPath, 'utf8'));
+        } else {
+            res.setHeader('Content-Type', 'text/html');
+            res.writeHead(200);
+            res.end(this._getInlineDashboard());
+        }
+    }
+
+    _serveFile(res, filename, contentType) {
+        const filePath = path.join(__dirname, 'ui', filename);
+        if (fs.existsSync(filePath)) {
+            res.setHeader('Content-Type', contentType);
+            res.writeHead(200);
+            res.end(fs.readFileSync(filePath, 'utf8'));
+        } else {
+            res.writeHead(404);
+            res.end('Not Found');
+        }
+    }
+
+    _getInlineDashboard() {
+        return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Computation Simulator</title>
+    <style>
+        * { box-sizing: border-box; margin: 0; padding: 0; }
+        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #0f172a; color: #e2e8f0; min-height: 100vh; }
+        .container { max-width: 1400px; margin: 0 auto; padding: 1.5rem; }
+        header { display: flex; justify-content: space-between; align-items: center; margin-bottom: 2rem; padding-bottom: 1rem; border-bottom: 1px solid #334155; }
+        h1 { font-size: 1.5rem; display: flex; align-items: center; gap: 0.5rem; }
+        h1::before { content: '🔄'; }
+        .status { padding: 0.5rem 1rem; border-radius: 9999px; font-size: 0.875rem; }
+        .status.connected { background: #064e3b; color: #6ee7b7; }
+        .status.disconnected { background: #7f1d1d; color: #fca5a5; }
+        .grid { display: grid; grid-template-columns: 300px 1fr; gap: 1.5rem; }
+        .sidebar { display: flex; flex-direction: column; gap: 1rem; }
+        .card { background: #1e293b; border-radius: 0.75rem; padding: 1.25rem; }
+        .card h2 { font-size: 0.875rem; text-transform: uppercase; letter-spacing: 0.05em; color: #94a3b8; margin-bottom: 1rem; }
+        .comp-list { max-height: 400px; overflow-y: auto; }
+        .comp-item { padding: 0.75rem; border-radius: 0.5rem; cursor: pointer; margin-bottom: 0.5rem; background: #334155; display: flex; justify-content: space-between; align-items: center; transition: background 0.2s; }
+        .comp-item:hover { background: #475569; }
+        .comp-item.active { background: #3b82f6; }
+        .pass-badge { background: #4338ca; padding: 0.25rem 0.5rem; border-radius: 0.25rem; font-size: 0.75rem; }
+        .main { display: flex; flex-direction: column; gap: 1.5rem; }
+        .controls { display: flex; gap: 1rem; }
+        .btn { padding: 0.75rem 1.5rem; border-radius: 0.5rem; border: none; cursor: pointer; font-weight: 600; transition: all 0.2s; }
+        .btn-primary { background: #3b82f6; color: white; }
+        .btn-primary:hover { background: #2563eb; }
+        .btn-secondary { background: #475569; color: white; }
+        .btn-secondary:hover { background: #64748b; }
+        .stats-grid { display: grid; grid-template-columns: repeat(4, 1fr); gap: 1rem; }
+        .stat { background: #334155; padding: 1rem; border-radius: 0.5rem; text-align: center; }
+        .stat-value { font-size: 1.5rem; font-weight: 700; color: #60a5fa; }
+        .stat-label { font-size: 0.75rem; color: #94a3b8; margin-top: 0.25rem; }
+        .output { background: #0f172a; border-radius: 0.5rem; padding: 1rem; max-height: 400px; overflow-y: auto; font-family: monospace; font-size: 0.875rem; white-space: pre-wrap; }
+        .log-entry { padding: 0.5rem; border-left: 3px solid #3b82f6; margin-bottom: 0.5rem; background: #1e293b; }
+        .log-entry.success { border-color: #22c55e; }
+        .log-entry.error { border-color: #ef4444; }
+        .validation { padding: 1rem; border-radius: 0.5rem; }
+        .validation.valid { background: #064e3b; }
+        .validation.invalid { background: #7f1d1d; }
+        #result-output { background: #0f172a; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <header>
+            <h1>Computation Simulator</h1>
+            <span id="status" class="status disconnected">Disconnected</span>
+        </header>
+        <div class="grid">
+            <aside class="sidebar">
+                <div class="card">
+                    <h2>Computations</h2>
+                    <div id="comp-list" class="comp-list"></div>
+                </div>
+                <div class="card">
+                    <h2>System Stats</h2>
+                    <div id="system-stats"></div>
+                </div>
+            </aside>
+            <main class="main">
+                <div class="card">
+                    <h2>Controls</h2>
+                    <div class="controls">
+                        <button class="btn btn-primary" id="btn-run">Run Selected</button>
+                        <button class="btn btn-secondary" id="btn-run-deps">Run with Dependencies</button>
+                        <button class="btn btn-secondary" id="btn-validate">Validate</button>
+                        <button class="btn btn-secondary" id="btn-reset">Reset</button>
+                    </div>
+                </div>
+                <div class="card">
+                    <h2>Results</h2>
+                    <div class="stats-grid" id="result-stats"></div>
+                    <div class="output" id="result-output">Select a computation and click Run</div>
+                </div>
+                <div class="card">
+                    <h2>Execution Log</h2>
+                    <div class="output" id="execution-log"></div>
+                </div>
+            </main>
+        </div>
+    </div>
+    <script>
+        let selectedComputation = null;
+        let eventSource = null;
+        
+        async function init() {
+            await loadComputations();
+            await loadSystemStats();
+            connectSSE();
+        }
+        
+        async function loadComputations() {
+            const res = await fetch('/api/computations');
+            const comps = await res.json();
+            const list = document.getElementById('comp-list');
+            list.innerHTML = comps.map(c => \`
+                <div class="comp-item" data-name="\${c.name}">
+                    <span>\${c.name}</span>
+                    <span class="pass-badge">Pass \${c.passLevel}</span>
+                </div>
+            \`).join('');
+            
+            list.querySelectorAll('.comp-item').forEach(el => {
+                el.addEventListener('click', () => {
+                    document.querySelectorAll('.comp-item').forEach(e => e.classList.remove('active'));
+                    el.classList.add('active');
+                    selectedComputation = el.dataset.name;
+                });
+            });
+        }
+        
+        async function loadSystemStats() {
+            const res = await fetch('/api/stats');
+            const stats = await res.json();
+            document.getElementById('system-stats').innerHTML = \`
+                <div class="stat"><div class="stat-value">\${stats.computations}</div><div class="stat-label">Computations</div></div>
+                <div class="stat"><div class="stat-value">\${stats.tables}</div><div class="stat-label">Tables</div></div>
+                <div class="stat"><div class="stat-value">\${stats.totalPasses}</div><div class="stat-label">Passes</div></div>
+            \`;
+        }
+        
+        function connectSSE() {
+            eventSource = new EventSource('/events');
+            eventSource.onopen = () => {
+                document.getElementById('status').className = 'status connected';
+                document.getElementById('status').textContent = 'Connected';
+            };
+            eventSource.onerror = () => {
+                document.getElementById('status').className = 'status disconnected';
+                document.getElementById('status').textContent = 'Disconnected';
+            };
+            eventSource.onmessage = (e) => {
+                const data = JSON.parse(e.data);
+                handleEvent(data);
+            };
+        }
+        
+        function handleEvent(data) {
+            if (data.type === 'fileChanged') {
+                addLog(\`File changed: \${data.file}\`, 'info');
+            } else if (data.type === 'simulationComplete') {
+                displayResults(data.result);
+            }
+        }
+        
+        async function runSimulation(withDeps = false) {
+            if (!selectedComputation) return alert('Select a computation first');
+            const endpoint = withDeps ? '/api/simulate-with-deps' : '/api/simulate';
+            const res = await fetch(endpoint, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ computation: selectedComputation })
+            });
+            const result = await res.json();
+            displayResults(result);
+        }
+        
+        async function validate() {
+            if (!selectedComputation) return alert('Select a computation first');
+            const res = await fetch('/api/validate', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ computation: selectedComputation })
+            });
+            const result = await res.json();
+            const output = document.getElementById('result-output');
+            output.innerHTML = result.valid 
+                ? '<div class="validation valid">✅ Valid configuration</div>'
+                : \`<div class="validation invalid">❌ Errors: \${result.errors.join(', ')}</div>\`;
+        }
+        
+        function displayResults(result) {
+            const statsEl = document.getElementById('result-stats');
+            const outputEl = document.getElementById('result-output');
+            
+            if (result.stats) {
+                statsEl.innerHTML = \`
+                    <div class="stat"><div class="stat-value">\${result.stats.executionTimeMs}ms</div><div class="stat-label">Execution</div></div>
+                    <div class="stat"><div class="stat-value">\${result.stats.entitiesProcessed}</div><div class="stat-label">Entities</div></div>
+                    <div class="stat"><div class="stat-value">\${Math.round(result.stats.memoryUsedBytes / 1024)}KB</div><div class="stat-label">Memory</div></div>
+                    <div class="stat"><div class="stat-value">\${result.passLevel || '?'}</div><div class="stat-label">Pass Level</div></div>
+                \`;
+            }
+            
+            outputEl.textContent = JSON.stringify(result.results || result, null, 2);
+            addLog(\`Simulation complete: \${selectedComputation}\`, result.success ? 'success' : 'error');
+        }
+        
+        function addLog(message, type = 'info') {
+            const log = document.getElementById('execution-log');
+            const entry = document.createElement('div');
+            entry.className = \`log-entry \${type}\`;
+            entry.textContent = \`[\${new Date().toLocaleTimeString()}] \${message}\`;
+            log.prepend(entry);
+        }
+        
+        document.getElementById('btn-run').addEventListener('click', () => runSimulation(false));
+        document.getElementById('btn-run-deps').addEventListener('click', () => runSimulation(true));
+        document.getElementById('btn-validate').addEventListener('click', validate);
+        document.getElementById('btn-reset').addEventListener('click', async () => {
+            await fetch('/api/reset');
+            document.getElementById('result-output').textContent = 'Reset complete';
+            document.getElementById('result-stats').innerHTML = '';
+        });
+        
+        init();
+    </script>
+</body>
+</html>`;
+    }
+
+    // =========================================================================
+    // HELPERS
+    // =========================================================================
+
+    _readBody(req) {
+        return new Promise((resolve, reject) => {
+            let body = '';
+            req.on('data', chunk => body += chunk);
+            req.on('end', () => resolve(body));
+            req.on('error', reject);
+        });
+    }
+}
+
+module.exports = { SimulationServer };

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

@@ -0,0 +1,17 @@
+/**
+ * @fileoverview Simulation Module Index
+ */
+
+const { SimulationEngine } = require('./SimulationEngine');
+const { SimulationServer } = require('./SimulationServer');
+const { MockDataFetcher } = require('./MockDataFetcher');
+const { MockStorageManager } = require('./MockStorageManager');
+const { DAGAnalyzer } = require('./DAGAnalyzer');
+
+module.exports = {
+    SimulationEngine,
+    SimulationServer,
+    MockDataFetcher,
+    MockStorageManager,
+    DAGAnalyzer
+};