bulltrackers-module 1.0.766 → 1.0.769

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

@@ -0,0 +1,207 @@
+/**
+ * @fileoverview Completion Provider
+ * 
+ * Provides intelligent autocomplete for:
+ * - Table names in requires blocks
+ * - Field names for tables
+ * - Rule module/function access
+ * - Computation dependencies
+ */
+
+import * as vscode from 'vscode';
+
+export class ComputationCompletionProvider implements vscode.CompletionItemProvider {
+    private knowledge: SystemKnowledge | null;
+
+    constructor(knowledge: SystemKnowledge | null) {
+        this.knowledge = knowledge;
+    }
+
+    provideCompletionItems(
+        document: vscode.TextDocument,
+        position: vscode.Position,
+        token: vscode.CancellationToken,
+        context: vscode.CompletionContext
+    ): vscode.CompletionItem[] | vscode.CompletionList {
+        const line = document.lineAt(position).text;
+        const textBefore = line.substring(0, position.character);
+
+        // Detect context
+        if (this.isInRequiresBlock(document, position)) {
+            if (this.isStartingQuote(textBefore)) {
+                return this.getTableCompletions();
+            }
+        }
+
+        if (this.isAccessingRules(textBefore)) {
+            return this.getRuleCompletions(textBefore);
+        }
+
+        if (this.isAccessingData(textBefore)) {
+            return this.getTableCompletions();
+        }
+
+        if (this.isInFieldsArray(document, position)) {
+            return this.getFieldCompletions(document, position);
+        }
+
+        if (this.isInTypeValue(textBefore)) {
+            return this.getTypeCompletions();
+        }
+
+        if (this.isInCategoryValue(textBefore)) {
+            return this.getCategoryCompletions();
+        }
+
+        return [];
+    }
+
+    // =========================================================================
+    // COMPLETION GENERATORS
+    // =========================================================================
+
+    private getTableCompletions(): vscode.CompletionItem[] {
+        if (!this.knowledge) return [];
+
+        return this.knowledge.tables.map(table => {
+            const item = new vscode.CompletionItem(table, vscode.CompletionItemKind.Field);
+            const meta = this.knowledge?.tableMetadata[table];
+            item.detail = meta ? `Entity: ${meta.entityField}, Date: ${meta.dateField}` : 'Table';
+            item.documentation = new vscode.MarkdownString(`**${table}**\n\nBigQuery table for computation input.`);
+            item.insertText = table;
+            return item;
+        });
+    }
+
+    private getRuleCompletions(textBefore: string): vscode.CompletionItem[] {
+        if (!this.knowledge) return [];
+
+        // Check if accessing rules.MODULE.
+        const moduleMatch = textBefore.match(/rules\.(\w+)\.$/);
+        if (moduleMatch) {
+            const module = moduleMatch[1];
+            const functions = this.knowledge.ruleFunctions[module] || [];
+            return functions.map(fn => {
+                const item = new vscode.CompletionItem(fn, vscode.CompletionItemKind.Method);
+                item.detail = `${module}.${fn}()`;
+                item.insertText = new vscode.SnippetString(`${fn}(\${1})`);
+                return item;
+            });
+        }
+
+        // Accessing rules.
+        if (textBefore.endsWith('rules.')) {
+            return this.knowledge.ruleModules.map(mod => {
+                const item = new vscode.CompletionItem(mod, vscode.CompletionItemKind.Module);
+                item.detail = 'Rule module';
+                const funcs = this.knowledge?.ruleFunctions[mod] || [];
+                item.documentation = new vscode.MarkdownString(`**${mod}**\n\nFunctions: ${funcs.join(', ')}`);
+                return item;
+            });
+        }
+
+        return [];
+    }
+
+    private getFieldCompletions(document: vscode.TextDocument, position: vscode.Position): vscode.CompletionItem[] {
+        if (!this.knowledge) return [];
+
+        // Try to determine which table we're in
+        const text = document.getText(new vscode.Range(new vscode.Position(0, 0), position));
+
+        // Find the nearest table name in the context
+        const tableMatches = [...text.matchAll(/'(\w+_\w+)':\s*\{/g)];
+        if (tableMatches.length === 0) return [];
+
+        const lastTable = tableMatches[tableMatches.length - 1][1];
+
+        // Return common fields
+        const commonFields = ['user_id', 'date', 'pi_id', 'created_at'];
+        const tableSpecificFields: Record<string, string[]> = {
+            portfolio_snapshots: ['portfolio_data', 'cash', 'total_value', 'platform'],
+            trade_history_snapshots: ['trade_history', 'open_trades_count', 'closed_trades_count'],
+            pi_rankings: ['rank', 'percentile', 'rankings_data'],
+            social_post_snapshots: ['post_count', 'engagement_data'],
+            pi_master_list: ['verified_date', 'tier', 'country']
+        };
+
+        const fields = [...commonFields, ...(tableSpecificFields[lastTable] || [])];
+
+        return fields.map(field => {
+            const item = new vscode.CompletionItem(field, vscode.CompletionItemKind.Property);
+            item.detail = lastTable;
+            item.insertText = `'${field}'`;
+            return item;
+        });
+    }
+
+    private getTypeCompletions(): vscode.CompletionItem[] {
+        return ['per-entity', 'global'].map(type => {
+            const item = new vscode.CompletionItem(type, vscode.CompletionItemKind.Value);
+            item.detail = type === 'per-entity'
+                ? 'Processes one entity at a time'
+                : 'Processes all data at once';
+            return item;
+        });
+    }
+
+    private getCategoryCompletions(): vscode.CompletionItem[] {
+        return ['signed_in_user', 'popular_investor', 'global', 'instrument'].map(cat => {
+            const item = new vscode.CompletionItem(cat, vscode.CompletionItemKind.Value);
+            item.detail = 'Computation category';
+            return item;
+        });
+    }
+
+    // =========================================================================
+    // CONTEXT DETECTION
+    // =========================================================================
+
+    private isInRequiresBlock(document: vscode.TextDocument, position: vscode.Position): boolean {
+        const text = document.getText(new vscode.Range(new vscode.Position(0, 0), position));
+        const lastRequires = text.lastIndexOf('requires:');
+        if (lastRequires === -1) return false;
+
+        // Count braces after 'requires:'
+        const afterRequires = text.substring(lastRequires);
+        const openBraces = (afterRequires.match(/\{/g) || []).length;
+        const closeBraces = (afterRequires.match(/\}/g) || []).length;
+
+        return openBraces > closeBraces;
+    }
+
+    private isStartingQuote(textBefore: string): boolean {
+        return /[{,]\s*['"]?$/.test(textBefore);
+    }
+
+    private isAccessingRules(textBefore: string): boolean {
+        return /rules\.(\w+\.)?$/.test(textBefore);
+    }
+
+    private isAccessingData(textBefore: string): boolean {
+        return /data\.\[?['"]?$/.test(textBefore);
+    }
+
+    private isInFieldsArray(document: vscode.TextDocument, position: vscode.Position): boolean {
+        const line = document.lineAt(position).text;
+        return line.includes('fields:') && line.includes('[');
+    }
+
+    private isInTypeValue(textBefore: string): boolean {
+        return /type:\s*['"]?$/.test(textBefore);
+    }
+
+    private isInCategoryValue(textBefore: string): boolean {
+        return /category:\s*['"]?$/.test(textBefore);
+    }
+}
+
+interface SystemKnowledge {
+    tables: string[];
+    tableMetadata: Record<string, any>;
+    ruleModules: string[];
+    ruleFunctions: Record<string, string[]>;
+    maxLookback: number;
+    validTypes: string[];
+    validCategories: string[];
+}

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

@@ -0,0 +1,205 @@
+/**
+ * @fileoverview Diagnostics Provider
+ * 
+ * Provides real-time validation:
+ * - Unknown table names
+ * - Lookback exceeds maximum
+ * - Missing required config fields
+ * - Invalid type/category values
+ * - Unused dependencies
+ */
+
+import * as vscode from 'vscode';
+
+export class ComputationDiagnosticsProvider implements vscode.Disposable {
+    private diagnosticCollection: vscode.DiagnosticCollection;
+    private knowledge: SystemKnowledge | null;
+
+    constructor(knowledge: SystemKnowledge | null) {
+        this.knowledge = knowledge;
+        this.diagnosticCollection = vscode.languages.createDiagnosticCollection('computation');
+    }
+
+    dispose() {
+        this.diagnosticCollection.dispose();
+    }
+
+    validateDocument(document: vscode.TextDocument) {
+        const diagnostics: vscode.Diagnostic[] = [];
+        const text = document.getText();
+
+        // Only validate computation files
+        if (!this.isComputationFile(text)) {
+            this.diagnosticCollection.set(document.uri, []);
+            return;
+        }
+
+        // Extract config block
+        const configMatch = text.match(/getConfig\s*\(\s*\)\s*\{[\s\S]*?return\s*\{([\s\S]*?)\};/);
+        if (!configMatch) {
+            diagnostics.push(this.createDiagnostic(
+                document,
+                'Missing getConfig() method',
+                0,
+                vscode.DiagnosticSeverity.Error
+            ));
+        } else {
+            const configContent = configMatch[1];
+            const configStart = document.positionAt(text.indexOf(configMatch[0]));
+
+            // Validate required fields
+            this.validateRequiredFields(document, configContent, configStart, diagnostics);
+
+            // Validate requires block
+            this.validateRequiresBlock(document, text, diagnostics);
+
+            // Validate type and category
+            this.validateEnumFields(document, text, diagnostics);
+        }
+
+        // Validate process method
+        if (!text.includes('async process(')) {
+            diagnostics.push(this.createDiagnostic(
+                document,
+                'Missing process() method',
+                0,
+                vscode.DiagnosticSeverity.Error
+            ));
+        }
+
+        this.diagnosticCollection.set(document.uri, diagnostics);
+    }
+
+    private validateRequiredFields(
+        document: vscode.TextDocument,
+        configContent: string,
+        configStart: vscode.Position,
+        diagnostics: vscode.Diagnostic[]
+    ) {
+        const requiredFields = ['name', 'type', 'category'];
+
+        for (const field of requiredFields) {
+            const regex = new RegExp(`${field}\\s*:`);
+            if (!regex.test(configContent)) {
+                diagnostics.push(new vscode.Diagnostic(
+                    new vscode.Range(configStart, configStart.translate(1)),
+                    `Missing required config field: ${field}`,
+                    vscode.DiagnosticSeverity.Error
+                ));
+            }
+        }
+    }
+
+    private validateRequiresBlock(
+        document: vscode.TextDocument,
+        text: string,
+        diagnostics: vscode.Diagnostic[]
+    ) {
+        if (!this.knowledge) return;
+
+        // Find all table references in requires
+        const tableMatches = [...text.matchAll(/'(\w+_?\w*)':\s*\{[^}]*lookback/g)];
+
+        for (const match of tableMatches) {
+            const tableName = match[1];
+            const position = document.positionAt(text.indexOf(match[0]));
+
+            // Check if table exists
+            if (!this.knowledge.tables.includes(tableName)) {
+                const range = new vscode.Range(
+                    position,
+                    position.translate(0, tableName.length + 2)
+                );
+                diagnostics.push(new vscode.Diagnostic(
+                    range,
+                    `Unknown table: ${tableName}`,
+                    vscode.DiagnosticSeverity.Warning
+                ));
+            }
+        }
+
+        // Check lookback values
+        const lookbackMatches = [...text.matchAll(/lookback:\s*(\d+)/g)];
+        for (const match of lookbackMatches) {
+            const lookback = parseInt(match[1]);
+            const position = document.positionAt(text.indexOf(match[0]));
+
+            if (lookback > this.knowledge.maxLookback) {
+                const range = new vscode.Range(
+                    position,
+                    position.translate(0, match[0].length)
+                );
+                diagnostics.push(new vscode.Diagnostic(
+                    range,
+                    `Lookback ${lookback} exceeds maximum of ${this.knowledge.maxLookback}`,
+                    vscode.DiagnosticSeverity.Error
+                ));
+            } else if (lookback > this.knowledge.maxLookback * 0.7) {
+                const range = new vscode.Range(
+                    position,
+                    position.translate(0, match[0].length)
+                );
+                diagnostics.push(new vscode.Diagnostic(
+                    range,
+                    `Lookback ${lookback} is high (${Math.round(lookback / this.knowledge.maxLookback * 100)}% of max)`,
+                    vscode.DiagnosticSeverity.Warning
+                ));
+            }
+        }
+    }
+
+    private validateEnumFields(
+        document: vscode.TextDocument,
+        text: string,
+        diagnostics: vscode.Diagnostic[]
+    ) {
+        if (!this.knowledge) return;
+
+        // Validate type
+        const typeMatch = text.match(/type:\s*['"](\w+)['"]/);
+        if (typeMatch && !this.knowledge.validTypes.includes(typeMatch[1])) {
+            const position = document.positionAt(text.indexOf(typeMatch[0]));
+            diagnostics.push(new vscode.Diagnostic(
+                new vscode.Range(position, position.translate(0, typeMatch[0].length)),
+                `Invalid type: ${typeMatch[1]}. Must be: ${this.knowledge.validTypes.join(', ')}`,
+                vscode.DiagnosticSeverity.Error
+            ));
+        }
+
+        // Validate category
+        const categoryMatch = text.match(/category:\s*['"](\w+)['"]/);
+        if (categoryMatch && !this.knowledge.validCategories.includes(categoryMatch[1])) {
+            const position = document.positionAt(text.indexOf(categoryMatch[0]));
+            diagnostics.push(new vscode.Diagnostic(
+                new vscode.Range(position, position.translate(0, categoryMatch[0].length)),
+                `Invalid category: ${categoryMatch[1]}. Must be: ${this.knowledge.validCategories.join(', ')}`,
+                vscode.DiagnosticSeverity.Error
+            ));
+        }
+    }
+
+    private isComputationFile(text: string): boolean {
+        return text.includes('extends Computation') ||
+            (text.includes('getConfig') && text.includes('process'));
+    }
+
+    private createDiagnostic(
+        document: vscode.TextDocument,
+        message: string,
+        line: number,
+        severity: vscode.DiagnosticSeverity
+    ): vscode.Diagnostic {
+        const lineText = document.lineAt(line);
+        return new vscode.Diagnostic(lineText.range, message, severity);
+    }
+}
+
+interface SystemKnowledge {
+    tables: string[];
+    tableMetadata: Record<string, any>;
+    ruleModules: string[];
+    ruleFunctions: Record<string, string[]>;
+    maxLookback: number;
+    validTypes: string[];
+    validCategories: string[];
+}

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

@@ -0,0 +1,205 @@
+/**
+ * @fileoverview Hover Provider
+ * 
+ * Provides hover documentation for:
+ * - Table names (shows fields, date field, entity field)
+ * - Rule functions (shows signature, description)
+ * - Config fields (shows valid values, defaults)
+ */
+
+import * as vscode from 'vscode';
+
+export class ComputationHoverProvider implements vscode.HoverProvider {
+    private knowledge: SystemKnowledge | null;
+
+    constructor(knowledge: SystemKnowledge | null) {
+        this.knowledge = knowledge;
+    }
+
+    provideHover(
+        document: vscode.TextDocument,
+        position: vscode.Position,
+        token: vscode.CancellationToken
+    ): vscode.Hover | null {
+        const wordRange = document.getWordRangeAtPosition(position, /[\w_]+/);
+        if (!wordRange) return null;
+
+        const word = document.getText(wordRange);
+        const line = document.lineAt(position).text;
+
+        // Check if hovering over a table name
+        if (this.knowledge?.tables.includes(word)) {
+            return this.getTableHover(word);
+        }
+
+        // Check if hovering over a rule function
+        const ruleMatch = line.match(/rules\.(\w+)\.(\w+)/);
+        if (ruleMatch && ruleMatch[2] === word) {
+            return this.getRuleFunctionHover(ruleMatch[1], ruleMatch[2]);
+        }
+
+        // Check if hovering over config field
+        if (this.isConfigField(word, line)) {
+            return this.getConfigFieldHover(word);
+        }
+
+        return null;
+    }
+
+    private getTableHover(tableName: string): vscode.Hover {
+        const meta = this.knowledge?.tableMetadata[tableName];
+
+        const md = new vscode.MarkdownString();
+        md.appendMarkdown(`### 📊 ${tableName}\n\n`);
+
+        if (meta) {
+            md.appendMarkdown(`**Entity Field:** \`${meta.entityField || 'unknown'}\`\n\n`);
+            md.appendMarkdown(`**Date Field:** \`${meta.dateField || 'none'}\`\n\n`);
+        }
+
+        // Add common fields for known tables
+        const fieldInfo = this.getTableFieldInfo(tableName);
+        if (fieldInfo) {
+            md.appendMarkdown(`**Key Fields:**\n`);
+            for (const [field, desc] of Object.entries(fieldInfo)) {
+                md.appendMarkdown(`- \`${field}\`: ${desc}\n`);
+            }
+        }
+
+        return new vscode.Hover(md);
+    }
+
+    private getRuleFunctionHover(module: string, func: string): vscode.Hover | null {
+        const functionDocs: Record<string, Record<string, string>> = {
+            portfolio: {
+                extractPositions: `Extract positions from portfolio_data JSON.
+\`\`\`javascript
+const positions = rules.portfolio.extractPositions(portfolioData);
+// Returns: { instrumentId: position }[]
+\`\`\``,
+                extractMirrors: `Extract mirror positions from portfolio_data.
+\`\`\`javascript
+const mirrors = rules.portfolio.extractMirrors(portfolioData);
+// Returns: { username, allocation, netProfit }[]
+\`\`\``,
+                getInvested: `Calculate total invested amount.
+\`\`\`javascript
+const invested = rules.portfolio.getInvested(positions);
+// Returns: number
+\`\`\``,
+                getNetProfit: `Calculate net profit from positions.
+\`\`\`javascript
+const profit = rules.portfolio.getNetProfit(positions);
+// Returns: number
+\`\`\``
+            },
+            metrics: {
+                calculateSharpeRatio: `Calculate Sharpe ratio from daily returns.
+\`\`\`javascript
+const sharpe = rules.metrics.calculateSharpeRatio(returns);
+// Returns: number (-3 to 3 typical)
+\`\`\``,
+                calculateVolatility: `Calculate annualized volatility.
+\`\`\`javascript
+const vol = rules.metrics.calculateVolatility(returns);
+// Returns: number (percentage)
+\`\`\``,
+                calculateDrawdown: `Calculate maximum drawdown.
+\`\`\`javascript
+const dd = rules.metrics.calculateDrawdown(equityCurve);
+// Returns: { maxDrawdown, currentDrawdown }
+\`\`\``
+            },
+            rankings: {
+                getRank: `Get ranking position.
+\`\`\`javascript
+const rank = rules.rankings.getRank(data, metric);
+// Returns: number (1 = best)
+\`\`\``,
+                getPercentile: `Get percentile position.
+\`\`\`javascript
+const pct = rules.rankings.getPercentile(data, metric);
+// Returns: number (0-100)
+\`\`\``
+            }
+        };
+
+        const doc = functionDocs[module]?.[func];
+        if (!doc) return null;
+
+        const md = new vscode.MarkdownString();
+        md.appendMarkdown(`### ${module}.${func}\n\n`);
+        md.appendMarkdown(doc);
+        md.isTrusted = true;
+
+        return new vscode.Hover(md);
+    }
+
+    private getConfigFieldHover(field: string): vscode.Hover | null {
+        const configDocs: Record<string, string> = {
+            name: `**name** (required)\n\nUnique identifier for the computation. Should match the class name.`,
+            type: `**type** (required)\n\nExecution mode:\n- \`per-entity\`: Process one entity at a time\n- \`global\`: Process all data at once`,
+            category: `**category** (required)\n\nEntity category:\n- \`signed_in_user\`: User-specific computations\n- \`popular_investor\`: PI-specific computations\n- \`global\`: Cross-entity computations`,
+            isHistorical: `**isHistorical** (optional)\n\n\`true\` = needs lookback data for comparison\n\`false\` = only needs current date (default)`,
+            lookback: `**lookback** (optional)\n\nNumber of historical days to fetch.\n- Max: **90 days**\n- Warning threshold: **63 days** (70%)`,
+            mandatory: `**mandatory** (optional)\n\n\`true\` = computation fails if data missing\n\`false\` = continues with empty data (default)`,
+            requires: `**requires** (important)\n\nTable/dependency requirements for this computation.\n\`\`\`javascript
+requires: {
+    'table_name': { lookback: 0, mandatory: true }
+}
+\`\`\``,
+            dependencies: `**dependencies** (optional)\n\nOther computations that must run first.\n\`\`\`javascript
+dependencies: ['ComputationA', 'ComputationB']
+\`\`\``
+        };
+
+        const doc = configDocs[field];
+        if (!doc) return null;
+
+        const md = new vscode.MarkdownString(doc);
+        md.isTrusted = true;
+        return new vscode.Hover(md);
+    }
+
+    private getTableFieldInfo(tableName: string): Record<string, string> | null {
+        const fieldDocs: Record<string, Record<string, string>> = {
+            portfolio_snapshots: {
+                user_id: 'Entity identifier',
+                date: 'Snapshot date',
+                portfolio_data: 'JSON with positions, mirrors, metrics',
+                cash: 'Available cash balance',
+                total_value: 'Total portfolio value'
+            },
+            pi_rankings: {
+                pi_id: 'Popular Investor ID',
+                date: 'Ranking date',
+                rank: 'Overall rank position',
+                rankings_data: 'JSON with detailed rankings'
+            },
+            trade_history_snapshots: {
+                user_id: 'Entity identifier',
+                trade_history: 'JSON array of trades',
+                open_trades_count: 'Number of open positions',
+                closed_trades_count: 'Number of closed positions'
+            }
+        };
+
+        return fieldDocs[tableName] || null;
+    }
+
+    private isConfigField(word: string, line: string): boolean {
+        const configFields = ['name', 'type', 'category', 'isHistorical', 'lookback',
+            'mandatory', 'requires', 'dependencies', 'storage'];
+        return configFields.includes(word) && line.includes(':');
+    }
+}
+
+interface SystemKnowledge {
+    tables: string[];
+    tableMetadata: Record<string, any>;
+    ruleModules: string[];
+    ruleFunctions: Record<string, string[]>;
+    maxLookback: number;
+    validTypes: string[];
+    validCategories: string[];
+}

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

@@ -0,0 +1,22 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "ES2020",
+        "outDir": "out",
+        "lib": [
+            "ES2020"
+        ],
+        "sourceMap": true,
+        "rootDir": "src",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules"
+    ]
+}