bulltrackers-module 1.0.768 → 1.0.770

package/functions/computation-system-v2/devtools/vscode-computation/src/extension.ts

@@ -0,0 +1,401 @@
+/**
+ * @fileoverview VS Code Extension Entry Point
+ * 
+ * Provides:
+ * - Autocomplete for tables, fields, rules
+ * - Diagnostics for validation errors
+ * - Hover documentation
+ * - Code actions (quick fixes)
+ * - Status bar for DAG position
+ */
+
+import * as vscode from 'vscode';
+import * as path from 'path';
+import * as fs from 'fs';
+
+// Providers
+import { ComputationCompletionProvider } from './providers/completions';
+import { ComputationDiagnosticsProvider } from './providers/diagnostics';
+import { ComputationHoverProvider } from './providers/hover';
+import { ComputationCodeActionProvider } from './providers/codeActions';
+
+// State
+let diagnosticsProvider: ComputationDiagnosticsProvider | null = null;
+let statusBarItem: vscode.StatusBarItem | null = null;
+
+export function activate(context: vscode.ExtensionContext) {
+    console.log('Computation Developer extension is now active');
+
+    // Load system knowledge
+    const systemKnowledge = loadSystemKnowledge();
+    if (!systemKnowledge) {
+        vscode.window.showWarningMessage(
+            'Computation Developer: Could not load system configuration. Some features may be limited.'
+        );
+    }
+
+    // Register completion provider
+    const completionProvider = new ComputationCompletionProvider(systemKnowledge);
+    context.subscriptions.push(
+        vscode.languages.registerCompletionItemProvider(
+            { language: 'javascript', pattern: '**/computation*/**/*.js' },
+            completionProvider,
+            '.', "'", '"' // Trigger characters
+        )
+    );
+
+    // Register diagnostics provider
+    diagnosticsProvider = new ComputationDiagnosticsProvider(systemKnowledge);
+    context.subscriptions.push(diagnosticsProvider);
+
+    // Register hover provider
+    const hoverProvider = new ComputationHoverProvider(systemKnowledge);
+    context.subscriptions.push(
+        vscode.languages.registerHoverProvider(
+            { language: 'javascript', pattern: '**/computation*/**/*.js' },
+            hoverProvider
+        )
+    );
+
+    // Register code action provider
+    const codeActionProvider = new ComputationCodeActionProvider(systemKnowledge);
+    context.subscriptions.push(
+        vscode.languages.registerCodeActionsProvider(
+            { language: 'javascript', pattern: '**/computation*/**/*.js' },
+            codeActionProvider,
+            { providedCodeActionKinds: [vscode.CodeActionKind.QuickFix] }
+        )
+    );
+
+    // Create status bar item
+    statusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 100);
+    statusBarItem.command = 'computationDeveloper.showDAG';
+    context.subscriptions.push(statusBarItem);
+
+    // Update status bar on active editor change
+    context.subscriptions.push(
+        vscode.window.onDidChangeActiveTextEditor(updateStatusBar)
+    );
+    updateStatusBar(vscode.window.activeTextEditor);
+
+    // Register commands
+    context.subscriptions.push(
+        vscode.commands.registerCommand('computationDeveloper.validate', () => {
+            if (diagnosticsProvider && vscode.window.activeTextEditor) {
+                diagnosticsProvider.validateDocument(vscode.window.activeTextEditor.document);
+                vscode.window.showInformationMessage('Validation complete');
+            }
+        })
+    );
+
+    context.subscriptions.push(
+        vscode.commands.registerCommand('computationDeveloper.simulate', async () => {
+            const editor = vscode.window.activeTextEditor;
+            if (!editor) return;
+
+            const computationName = extractComputationName(editor.document.getText());
+            if (!computationName) {
+                vscode.window.showErrorMessage('Could not identify computation name');
+                return;
+            }
+
+            const config = vscode.workspace.getConfiguration('computationDeveloper');
+            const serverUrl = config.get<string>('simulationServerUrl') || 'http://localhost:3210';
+
+            try {
+                const response = await fetch(`${serverUrl}/api/simulate`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ computation: computationName })
+                });
+                const result = await response.json();
+
+                const output = vscode.window.createOutputChannel('Computation Simulation');
+                output.clear();
+                output.appendLine(`Simulation: ${computationName}`);
+                output.appendLine(`Status: ${result.success ? '✓ Success' : '✗ Failed'}`);
+                if (result.stats) {
+                    output.appendLine(`Time: ${result.stats.executionTimeMs}ms`);
+                    output.appendLine(`Entities: ${result.stats.entitiesProcessed}`);
+                }
+                output.appendLine('\nResults:');
+                output.appendLine(JSON.stringify(result.results || result, null, 2));
+                output.show();
+            } catch (e: any) {
+                vscode.window.showErrorMessage(`Simulation failed: ${e.message}. Is the server running?`);
+            }
+        })
+    );
+
+    context.subscriptions.push(
+        vscode.commands.registerCommand('computationDeveloper.showDAG', async () => {
+            const editor = vscode.window.activeTextEditor;
+            if (!editor) return;
+
+            const computationName = extractComputationName(editor.document.getText());
+            if (!computationName) {
+                vscode.window.showErrorMessage('Could not identify computation name');
+                return;
+            }
+
+            const config = vscode.workspace.getConfiguration('computationDeveloper');
+            const serverUrl = config.get<string>('simulationServerUrl') || 'http://localhost:3210';
+
+            try {
+                const response = await fetch(`${serverUrl}/api/info?computation=${computationName}`);
+                const info = await response.json();
+
+                const panel = vscode.window.createWebviewPanel(
+                    'dagView',
+                    `DAG: ${computationName}`,
+                    vscode.ViewColumn.Beside,
+                    {}
+                );
+                panel.webview.html = getDAGWebviewContent(info);
+            } catch (e: any) {
+                vscode.window.showErrorMessage(`Could not load DAG info: ${e.message}`);
+            }
+        })
+    );
+
+    context.subscriptions.push(
+        vscode.commands.registerCommand('computationDeveloper.generateBoilerplate', async () => {
+            const name = await vscode.window.showInputBox({
+                prompt: 'Computation name (e.g., UserProfileMetrics)',
+                validateInput: (value) => {
+                    if (!value || !/^[A-Z][a-zA-Z0-9]+$/.test(value)) {
+                        return 'Name must be PascalCase';
+                    }
+                    return null;
+                }
+            });
+            if (!name) return;
+
+            const type = await vscode.window.showQuickPick(['per-entity', 'global'], {
+                placeHolder: 'Computation type'
+            });
+            if (!type) return;
+
+            const boilerplate = generateBoilerplate(name, type);
+
+            const doc = await vscode.workspace.openTextDocument({
+                content: boilerplate,
+                language: 'javascript'
+            });
+            await vscode.window.showTextDocument(doc);
+        })
+    );
+
+    // Watch for document changes
+    context.subscriptions.push(
+        vscode.workspace.onDidChangeTextDocument(event => {
+            if (event.document.languageId === 'javascript') {
+                diagnosticsProvider?.validateDocument(event.document);
+            }
+        })
+    );
+
+    // Validate open documents
+    vscode.workspace.textDocuments.forEach(doc => {
+        if (doc.languageId === 'javascript') {
+            diagnosticsProvider?.validateDocument(doc);
+        }
+    });
+}
+
+export function deactivate() {
+    if (diagnosticsProvider) {
+        diagnosticsProvider.dispose();
+    }
+}
+
+// =========================================================================
+// HELPERS
+// =========================================================================
+
+interface SystemKnowledge {
+    tables: string[];
+    tableMetadata: Record<string, any>;
+    ruleModules: string[];
+    ruleFunctions: Record<string, string[]>;
+    maxLookback: number;
+    validTypes: string[];
+    validCategories: string[];
+}
+
+function loadSystemKnowledge(): SystemKnowledge | null {
+    try {
+        // Try to find the config file
+        const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
+        if (!workspaceFolder) return null;
+
+        // Look for bulltrackers.config.js
+        const configPaths = [
+            path.join(workspaceFolder.uri.fsPath, 'config', 'bulltrackers.config.js'),
+            path.join(workspaceFolder.uri.fsPath, 'functions', 'computation-system-v2', 'config', 'bulltrackers.config.js')
+        ];
+
+        for (const configPath of configPaths) {
+            if (fs.existsSync(configPath)) {
+                // For now, return hardcoded knowledge
+                // In production, would parse the config
+                return {
+                    tables: [
+                        'portfolio_snapshots',
+                        'trade_history_snapshots',
+                        'pi_rankings',
+                        'social_post_snapshots',
+                        'pi_ratings',
+                        'pi_page_views',
+                        'watchlist_membership',
+                        'pi_alert_history',
+                        'pi_master_list',
+                        'ticker_mappings',
+                        'sector_mappings',
+                        'asset_prices'
+                    ],
+                    tableMetadata: {
+                        portfolio_snapshots: { dateField: 'date', entityField: 'user_id' },
+                        pi_rankings: { dateField: 'date', entityField: 'pi_id' },
+                        trade_history_snapshots: { dateField: 'date', entityField: 'user_id' }
+                    },
+                    ruleModules: ['portfolio', 'metrics', 'rankings', 'trades', 'social', 'instruments'],
+                    ruleFunctions: {
+                        portfolio: ['extractPositions', 'extractMirrors', 'getInvested', 'getNetProfit', 'extractPortfolioData'],
+                        metrics: ['calculateSharpeRatio', 'calculateVolatility', 'calculateDrawdown'],
+                        rankings: ['getRank', 'getPercentile'],
+                        trades: ['getOpenTrades', 'getClosedTrades', 'getTradeHistory'],
+                        social: ['getPostCount', 'getEngagement'],
+                        instruments: ['getTicker', 'getSector', 'getPrice']
+                    },
+                    maxLookback: 90,
+                    validTypes: ['per-entity', 'global'],
+                    validCategories: ['signed_in_user', 'popular_investor', 'global', 'instrument']
+                };
+            }
+        }
+
+        return null;
+    } catch (e) {
+        console.error('Failed to load system knowledge:', e);
+        return null;
+    }
+}
+
+function extractComputationName(text: string): string | null {
+    // Look for class definition
+    const classMatch = text.match(/class\s+(\w+)\s+extends\s+Computation/);
+    if (classMatch) return classMatch[1];
+
+    // Look for name in getConfig
+    const nameMatch = text.match(/name:\s*['"](\w+)['"]/);
+    if (nameMatch) return nameMatch[1];
+
+    return null;
+}
+
+function updateStatusBar(editor: vscode.TextEditor | undefined) {
+    if (!statusBarItem) return;
+
+    if (editor && editor.document.languageId === 'javascript' &&
+        editor.document.fileName.includes('computation')) {
+        const name = extractComputationName(editor.document.getText());
+        if (name) {
+            statusBarItem.text = `$(graph) ${name}`;
+            statusBarItem.tooltip = 'Click to show DAG position';
+            statusBarItem.show();
+            return;
+        }
+    }
+
+    statusBarItem.hide();
+}
+
+function generateBoilerplate(name: string, type: string): string {
+    return `const { Computation } = require('../framework');
+
+class ${name} extends Computation {
+    static getConfig() {
+        return {
+            name: '${name}',
+            description: '',
+            type: '${type}',
+            category: '${type === 'global' ? 'global' : 'signed_in_user'}',
+            isHistorical: false,
+            requires: {
+                'portfolio_snapshots': {
+                    lookback: 0,
+                    mandatory: true,
+                    fields: ['user_id', 'date', 'portfolio_data']
+                }
+            },
+            storage: {
+                bigquery: true,
+                firestore: {
+                    enabled: false,
+                    path: 'users/{entityId}/${name.toLowerCase()}',
+                    merge: true
+                }
+            }
+        };
+    }
+
+    async process(data, { entityId, targetDate, rules, getDependency }) {
+        const snapshots = data.portfolio_snapshots[entityId] || [];
+        
+        // TODO: Implement computation logic
+        
+        return {
+            // result
+        };
+    }
+}
+
+module.exports = ${name};
+`;
+}
+
+function getDAGWebviewContent(info: any): string {
+    return `<!DOCTYPE html>
+<html>
+<head>
+    <style>
+        body { font-family: -apple-system, sans-serif; padding: 20px; background: #1e1e1e; color: #d4d4d4; }
+        h1 { margin-bottom: 20px; }
+        .info { background: #2d2d2d; padding: 15px; border-radius: 8px; margin-bottom: 15px; }
+        .label { color: #888; font-size: 0.9em; }
+        .value { font-size: 1.1em; margin-top: 4px; }
+        .deps { display: flex; gap: 8px; flex-wrap: wrap; margin-top: 8px; }
+        .dep { background: #3d3d3d; padding: 4px 12px; border-radius: 4px; }
+        .pass { background: #4a4a9a; color: white; padding: 4px 12px; border-radius: 4px; display: inline-block; }
+    </style>
+</head>
+<body>
+    <h1>${info.name || 'Unknown'}</h1>
+    <div class="info">
+        <div class="label">Pass Level</div>
+        <div class="value"><span class="pass">Pass ${info.passLevel || '?'}</span> of ${info.totalPasses || '?'}</div>
+    </div>
+    <div class="info">
+        <div class="label">Dependencies</div>
+        <div class="deps">
+            ${(info.dependencies || []).map((d: string) => `<span class="dep">← ${d}</span>`).join('') || 'None'}
+        </div>
+    </div>
+    <div class="info">
+        <div class="label">Dependents</div>
+        <div class="deps">
+            ${(info.dependents || []).map((d: string) => `<span class="dep">→ ${d}</span>`).join('') || 'None'}
+        </div>
+    </div>
+    <div class="info">
+        <div class="label">Type</div>
+        <div class="value">${info.config?.type || 'unknown'}</div>
+    </div>
+    <div class="info">
+        <div class="label">Category</div>
+        <div class="value">${info.config?.category || 'unknown'}</div>
+    </div>
+</body>
+</html>`;
+}

package/functions/computation-system-v2/devtools/vscode-computation/src/providers/codeActions.ts

@@ -0,0 +1,152 @@
+/**
+ * @fileoverview Code Action Provider
+ * 
+ * Provides quick fixes for:
+ * - Unknown table names (suggest similar)
+ * - Lookback exceeds max (reduce to max)
+ * - Missing required fields (add template)
+ */
+
+import * as vscode from 'vscode';
+
+export class ComputationCodeActionProvider implements vscode.CodeActionProvider {
+    private knowledge: SystemKnowledge | null;
+
+    constructor(knowledge: SystemKnowledge | null) {
+        this.knowledge = knowledge;
+    }
+
+    provideCodeActions(
+        document: vscode.TextDocument,
+        range: vscode.Range | vscode.Selection,
+        context: vscode.CodeActionContext,
+        token: vscode.CancellationToken
+    ): vscode.CodeAction[] | null {
+        const actions: vscode.CodeAction[] = [];
+
+        for (const diagnostic of context.diagnostics) {
+            if (diagnostic.source !== 'computation') continue;
+
+            const message = diagnostic.message;
+
+            // Unknown table - suggest similar
+            if (message.startsWith('Unknown table:')) {
+                const tableName = message.match(/Unknown table: (\w+)/)?.[1];
+                if (tableName) {
+                    const suggestions = this.findSimilarTables(tableName);
+                    for (const suggestion of suggestions) {
+                        const action = new vscode.CodeAction(
+                            `Change to '${suggestion}'`,
+                            vscode.CodeActionKind.QuickFix
+                        );
+                        action.edit = new vscode.WorkspaceEdit();
+                        action.edit.replace(document.uri, diagnostic.range, `'${suggestion}'`);
+                        action.diagnostics = [diagnostic];
+                        actions.push(action);
+                    }
+                }
+            }
+
+            // Lookback exceeds max
+            if (message.includes('exceeds maximum')) {
+                const action = new vscode.CodeAction(
+                    'Reduce to maximum (90)',
+                    vscode.CodeActionKind.QuickFix
+                );
+                action.edit = new vscode.WorkspaceEdit();
+                action.edit.replace(document.uri, diagnostic.range, 'lookback: 90');
+                action.diagnostics = [diagnostic];
+                actions.push(action);
+            }
+
+            // Missing required field
+            if (message.startsWith('Missing required config field:')) {
+                const field = message.match(/field: (\w+)/)?.[1];
+                if (field) {
+                    const action = this.createAddFieldAction(document, diagnostic, field);
+                    if (action) actions.push(action);
+                }
+            }
+        }
+
+        return actions;
+    }
+
+    private findSimilarTables(name: string): string[] {
+        if (!this.knowledge) return [];
+
+        const suggestions: Array<{ name: string; score: number }> = [];
+
+        for (const table of this.knowledge.tables) {
+            const score = this.similarity(name.toLowerCase(), table.toLowerCase());
+            if (score > 0.3) {
+                suggestions.push({ name: table, score });
+            }
+        }
+
+        return suggestions
+            .sort((a, b) => b.score - a.score)
+            .slice(0, 3)
+            .map(s => s.name);
+    }
+
+    private similarity(a: string, b: string): number {
+        // Simple Jaccard similarity on character bigrams
+        const bigramsA = new Set<string>();
+        const bigramsB = new Set<string>();
+
+        for (let i = 0; i < a.length - 1; i++) bigramsA.add(a.slice(i, i + 2));
+        for (let i = 0; i < b.length - 1; i++) bigramsB.add(b.slice(i, i + 2));
+
+        let intersection = 0;
+        for (const bi of bigramsA) {
+            if (bigramsB.has(bi)) intersection++;
+        }
+
+        const union = bigramsA.size + bigramsB.size - intersection;
+        return union === 0 ? 0 : intersection / union;
+    }
+
+    private createAddFieldAction(
+        document: vscode.TextDocument,
+        diagnostic: vscode.Diagnostic,
+        field: string
+    ): vscode.CodeAction | null {
+        const templates: Record<string, string> = {
+            name: "name: 'ComputationName',",
+            type: "type: 'per-entity',",
+            category: "category: 'signed_in_user',"
+        };
+
+        const template = templates[field];
+        if (!template) return null;
+
+        const action = new vscode.CodeAction(
+            `Add ${field} field`,
+            vscode.CodeActionKind.QuickFix
+        );
+
+        // Find position to insert (after 'return {')
+        const text = document.getText();
+        const returnIdx = text.indexOf('return {');
+        if (returnIdx === -1) return null;
+
+        const insertPosition = document.positionAt(returnIdx + 'return {'.length);
+
+        action.edit = new vscode.WorkspaceEdit();
+        action.edit.insert(document.uri, insertPosition, `\n            ${template}`);
+        action.diagnostics = [diagnostic];
+
+        return action;
+    }
+}
+
+interface SystemKnowledge {
+    tables: string[];
+    tableMetadata: Record<string, any>;
+    ruleModules: string[];
+    ruleFunctions: Record<string, string[]>;
+    maxLookback: number;
+    validTypes: string[];
+    validCategories: string[];
+}