hedgequantx 2.9.20 → 2.9.22

package/src/pages/positions.js

@@ -7,37 +7,40 @@ const ora = require('ora');
 
 const { connections } = require('../services');
 const { ORDER_SIDE } = require('../config');
-const { getLogoWidth, drawBoxHeader, drawBoxFooter, drawBoxRow, drawBoxSeparator } = require('../ui');
+const { getLogoWidth, drawBoxHeader, drawBoxFooter, drawBoxRow, drawBoxSeparator, displayBanner, clearScreen } = require('../ui');
 const { prompts } = require('../utils');
 
 /**
  * Show all open positions
  */
 const showPositions = async (service) => {
+  // Clear screen and show banner
+  clearScreen();
+  displayBanner();
+  
   const boxWidth = getLogoWidth();
   let spinner;
 
   try {
-    // Step 1: Get connections
-    spinner = ora({ text: 'Loading connections...', color: 'yellow' }).start();
+    spinner = ora({ text: 'LOADING POSITIONS...', color: 'yellow' }).start();
     
     const allConns = connections.count() > 0 
       ? connections.getAll() 
       : (service ? [{ service, propfirm: service.propfirm?.name || 'Unknown', type: 'single' }] : []);
     
     if (allConns.length === 0) {
-      spinner.fail('No connections found');
+      spinner.fail('NO CONNECTIONS FOUND');
       await prompts.waitForEnter();
       return;
     }
-    spinner.succeed(`Found ${allConns.length} connection(s)`);
+    spinner.succeed(`FOUND ${allConns.length} CONNECTION(S)`);
 
     // Step 2: Fetch accounts
     let allAccounts = [];
     
     for (const conn of allConns) {
       const propfirmName = conn.propfirm || conn.type || 'Unknown';
-      spinner = ora({ text: `Fetching accounts from ${propfirmName}...`, color: 'yellow' }).start();
+      spinner = ora({ text: `FETCHING ACCOUNTS FROM ${propfirmName.toUpperCase()}...`, color: 'yellow' }).start();
       
       try {
         const result = await conn.service.getTradingAccounts();
@@ -49,17 +52,17 @@ const showPositions = async (service) => {
               service: conn.service 
             });
           });
-          spinner.succeed(`${propfirmName}: ${result.accounts.length} account(s)`);
+          spinner.succeed(`${propfirmName.toUpperCase()}: ${result.accounts.length} ACCOUNT(S)`);
         } else {
-          spinner.warn(`${propfirmName}: No accounts`);
+          spinner.warn(`${propfirmName.toUpperCase()}: NO ACCOUNTS`);
         }
       } catch (e) {
-        spinner.fail(`${propfirmName}: Failed`);
+        spinner.fail(`${propfirmName.toUpperCase()}: FAILED`);
       }
     }
 
     if (allAccounts.length === 0) {
-      console.log(chalk.yellow('\n  No accounts found.'));
+      console.log(chalk.yellow('\n  NO ACCOUNTS FOUND.'));
       await prompts.waitForEnter();
       return;
     }
@@ -69,7 +72,7 @@ const showPositions = async (service) => {
     
     for (const account of allAccounts) {
       const accName = String(account.accountName || account.rithmicAccountId || account.accountId || 'Unknown').substring(0, 20);
-      spinner = ora({ text: `Fetching positions for ${accName}...`, color: 'yellow' }).start();
+      spinner = ora({ text: `FETCHING POSITIONS FOR ${accName.toUpperCase()}...`, color: 'yellow' }).start();
       
       try {
         const result = await account.service.getPositions(account.accountId);
@@ -81,26 +84,26 @@ const showPositions = async (service) => {
               propfirm: account.propfirm 
             });
           });
-          spinner.succeed(`${accName}: ${result.positions.length} position(s)`);
+          spinner.succeed(`${accName.toUpperCase()}: ${result.positions.length} POSITION(S)`);
         } else {
-          spinner.succeed(`${accName}: No positions`);
+          spinner.succeed(`${accName.toUpperCase()}: NO POSITIONS`);
         }
       } catch (e) {
-        spinner.fail(`${accName}: Failed to fetch positions`);
+        spinner.fail(`${accName.toUpperCase()}: FAILED TO FETCH POSITIONS`);
       }
     }
 
-    spinner = ora({ text: 'Preparing display...', color: 'yellow' }).start();
-    spinner.succeed(`Total: ${allPositions.length} position(s)`);
+    spinner = ora({ text: 'PREPARING DISPLAY...', color: 'yellow' }).start();
+    spinner.succeed(`TOTAL: ${allPositions.length} POSITION(S)`);
     console.log();
 
     // Display
     drawBoxHeader('OPEN POSITIONS', boxWidth);
 
     if (allPositions.length === 0) {
-      drawBoxRow(chalk.gray('  No open positions'), boxWidth);
+      drawBoxRow(chalk.gray('  NO OPEN POSITIONS'), boxWidth);
     } else {
-      const header = '  ' + 'Symbol'.padEnd(15) + 'Side'.padEnd(8) + 'Size'.padEnd(8) + 'Entry'.padEnd(12) + 'P&L'.padEnd(12) + 'Account';
+      const header = '  ' + 'SYMBOL'.padEnd(15) + 'SIDE'.padEnd(8) + 'SIZE'.padEnd(8) + 'ENTRY'.padEnd(12) + 'P&L'.padEnd(12) + 'ACCOUNT';
       drawBoxRow(chalk.white.bold(header), boxWidth);
       drawBoxSeparator(boxWidth);
 
@@ -131,7 +134,7 @@ const showPositions = async (service) => {
     console.log();
 
   } catch (error) {
-    if (spinner) spinner.fail('Error: ' + error.message);
+    if (spinner) spinner.fail('ERROR: ' + error.message.toUpperCase());
   }
 
   await prompts.waitForEnter();

package/src/pages/stats/index.js

@@ -11,7 +11,7 @@ const ora = require('ora');
 
 const { connections } = require('../../services');
 const { prompts } = require('../../utils');
-const { displayBanner } = require('../../ui');
+const { displayBanner , clearScreen } = require('../../ui');
 const { aggregateStats, calculateDerivedMetrics, calculateQuantMetrics, calculateHQXScore } = require('./metrics');
 const { renderOverview, renderPnLMetrics, renderQuantMetrics, renderTradesHistory, renderHQXScore, renderNotice } = require('./display');
 const { renderEquityCurve } = require('./chart');
@@ -124,7 +124,7 @@ const aggregateAccountData = async (activeAccounts) => {
         } catch (e) {}
       }
       
-      // Trade history (Rithmic doesn't provide this)
+      // Trade history from ORDER_PLANT
       if (typeof svc.getTradeHistory === 'function') {
         try {
           const tradesResult = await svc.getTradeHistory(account.accountId, 30);
@@ -137,7 +137,9 @@ const aggregateAccountData = async (activeAccounts) => {
               connectionType: connType
             })));
           }
-        } catch (e) {}
+        } catch (e) {
+          // Silent - trade history may not be available
+        }
       }
     } catch (e) {}
   }
@@ -159,10 +161,14 @@ const aggregateAccountData = async (activeAccounts) => {
  * Show Stats Page
  */
 const showStats = async (service) => {
+  // Clear screen and show banner
+  clearScreen();
+  displayBanner();
+  
   let spinner;
   
   try {
-    spinner = ora({ text: 'Loading stats...', color: 'yellow' }).start();
+    spinner = ora({ text: 'LOADING STATS...', color: 'yellow' }).start();
     
     // Get all connections
     const allConns = connections.count() > 0 
@@ -184,22 +190,17 @@ const showStats = async (service) => {
       return;
     }
 
-    // Filter active accounts (status === 0)
-    const activeAccounts = allAccountsData.filter(acc => acc.status === 0);
-    
-    if (activeAccounts.length === 0) {
-      spinner.fail('No active accounts found');
-      await prompts.waitForEnter();
-      return;
-    }
+    // Use all accounts (don't filter by status - Rithmic may have different status formats)
+    const activeAccounts = allAccountsData;
 
     // Aggregate account data from APIs
     const accountData = await aggregateAccountData(activeAccounts);
     
-    spinner.succeed('Stats loaded');
-    console.clear();
+    spinner.stop();
+    
+    // Clear and show banner before displaying stats
+    clearScreen();
     displayBanner();
-    console.log();
     
     // Calculate stats from API data
     const stats = aggregateStats(activeAccounts, accountData.allTrades);

package/src/pages/user.js

@@ -6,13 +6,17 @@ const chalk = require('chalk');
 const ora = require('ora');
 
 const { connections } = require('../services');
-const { getLogoWidth, getColWidths, drawBoxHeader, drawBoxFooter, draw2ColHeader, visibleLength, padText } = require('../ui');
+const { getLogoWidth, getColWidths, drawBoxHeader, drawBoxFooter, draw2ColHeader, visibleLength, padText, displayBanner, clearScreen } = require('../ui');
 const { prompts } = require('../utils');
 
 /**
  * Show user info
  */
 const showUserInfo = async (service) => {
+  // Clear screen and show banner
+  clearScreen();
+  displayBanner();
+  
   const boxWidth = getLogoWidth();
   const { col1, col2 } = getColWidths(boxWidth);
   let spinner;
@@ -26,7 +30,7 @@ const showUserInfo = async (service) => {
 
   try {
     // Step 1: Get user info
-    spinner = ora({ text: 'Loading user info...', color: 'yellow' }).start();
+    spinner = ora({ text: 'LOADING USER INFO...', color: 'yellow' }).start();
     
     let userInfo = null;
     
@@ -39,10 +43,10 @@ const showUserInfo = async (service) => {
       } catch (e) {}
     }
     
-    spinner.succeed('User info loaded');
+    spinner.succeed('USER INFO LOADED');
 
     // Step 2: Get account count
-    spinner = ora({ text: 'Counting accounts...', color: 'yellow' }).start();
+    spinner = ora({ text: 'COUNTING ACCOUNTS...', color: 'yellow' }).start();
     
     let accountCount = 0;
     
@@ -58,14 +62,14 @@ const showUserInfo = async (service) => {
       } catch (e) {}
     }
     
-    spinner.succeed(`Found ${accountCount} account(s)`);
+    spinner.succeed(`FOUND ${accountCount} ACCOUNT(S)`);
     console.log();
 
     // Display
     drawBoxHeader('USER INFO', boxWidth);
 
     if (!userInfo) {
-      console.log(chalk.cyan('║') + padText(chalk.gray('  No user info available'), boxWidth - 2) + chalk.cyan('║'));
+      console.log(chalk.cyan('║') + padText(chalk.gray('  NO USER INFO AVAILABLE'), boxWidth - 2) + chalk.cyan('║'));
     } else {
       draw2ColHeader('PROFILE', 'CONNECTIONS', boxWidth);
 
@@ -90,7 +94,7 @@ const showUserInfo = async (service) => {
     console.log();
 
   } catch (error) {
-    if (spinner) spinner.fail('Error: ' + error.message);
+    if (spinner) spinner.fail('ERROR: ' + error.message.toUpperCase());
   }
 
   await prompts.waitForEnter();

package/src/services/ai-supervision/consensus.js

@@ -0,0 +1,284 @@
+/**
+ * Consensus Calculator for Multi-Agent Supervision
+ * 
+ * Calculates weighted consensus from multiple AI agent responses.
+ * Each agent has a weight, and the final decision is based on
+ * the weighted average of all responses.
+ */
+
+/**
+ * Default consensus when no valid responses
+ */
+const DEFAULT_CONSENSUS = {
+  decision: 'approve',
+  confidence: 50,
+  optimizations: null,
+  reason: 'No consensus - default approve',
+  alerts: [],
+  agentCount: 0,
+  respondedCount: 0,
+  unanimous: false
+};
+
+/**
+ * Calculate weighted average of a numeric field
+ */
+const weightedAverage = (values, weights) => {
+  if (values.length === 0) return 0;
+  
+  let sum = 0;
+  let totalWeight = 0;
+  
+  for (let i = 0; i < values.length; i++) {
+    const val = values[i];
+    const weight = weights[i] || 1;
+    if (val !== null && val !== undefined && !isNaN(val)) {
+      sum += val * weight;
+      totalWeight += weight;
+    }
+  }
+  
+  return totalWeight > 0 ? sum / totalWeight : 0;
+};
+
+/**
+ * Calculate weighted mode (most common value by weight)
+ */
+const weightedMode = (values, weights) => {
+  if (values.length === 0) return null;
+  
+  const weightMap = {};
+  
+  for (let i = 0; i < values.length; i++) {
+    const val = values[i];
+    const weight = weights[i] || 1;
+    if (val !== null && val !== undefined) {
+      weightMap[val] = (weightMap[val] || 0) + weight;
+    }
+  }
+  
+  let maxWeight = 0;
+  let mode = null;
+  
+  for (const [val, w] of Object.entries(weightMap)) {
+    if (w > maxWeight) {
+      maxWeight = w;
+      mode = val;
+    }
+  }
+  
+  return mode;
+};
+
+/**
+ * Merge optimizations from multiple agents
+ */
+const mergeOptimizations = (responses, weights) => {
+  const validOpts = responses
+    .map((r, i) => ({ opt: r.optimizations, weight: weights[i] }))
+    .filter(o => o.opt !== null);
+  
+  if (validOpts.length === 0) return null;
+  
+  // Collect values for each field
+  const entries = validOpts.filter(o => o.opt.entry !== null).map(o => ({ val: o.opt.entry, w: o.weight }));
+  const stops = validOpts.filter(o => o.opt.stopLoss !== null).map(o => ({ val: o.opt.stopLoss, w: o.weight }));
+  const targets = validOpts.filter(o => o.opt.takeProfit !== null).map(o => ({ val: o.opt.takeProfit, w: o.weight }));
+  const sizes = validOpts.filter(o => o.opt.size !== null).map(o => ({ val: o.opt.size, w: o.weight }));
+  const timings = validOpts.map(o => ({ val: o.opt.timing, w: o.weight }));
+
+  return {
+    entry: entries.length > 0 
+      ? Math.round(weightedAverage(entries.map(e => e.val), entries.map(e => e.w)) * 100) / 100 
+      : null,
+    stopLoss: stops.length > 0 
+      ? Math.round(weightedAverage(stops.map(s => s.val), stops.map(s => s.w)) * 100) / 100 
+      : null,
+    takeProfit: targets.length > 0 
+      ? Math.round(weightedAverage(targets.map(t => t.val), targets.map(t => t.w)) * 100) / 100 
+      : null,
+    size: sizes.length > 0 
+      ? Math.round(weightedAverage(sizes.map(s => s.val), sizes.map(s => s.w)) * 100) / 100 
+      : null,
+    timing: weightedMode(timings.map(t => t.val), timings.map(t => t.w)) || 'now'
+  };
+};
+
+/**
+ * Collect all alerts from responses
+ */
+const collectAlerts = (responses) => {
+  const alerts = [];
+  for (const r of responses) {
+    if (r.alerts && Array.isArray(r.alerts)) {
+      alerts.push(...r.alerts);
+    }
+  }
+  return [...new Set(alerts)].slice(0, 10);
+};
+
+/**
+ * Build reason summary from all responses
+ */
+const buildReasonSummary = (responses, decision) => {
+  const reasons = responses
+    .filter(r => r.decision === decision && r.reason)
+    .map(r => r.reason)
+    .slice(0, 3);
+  
+  if (reasons.length === 0) return `Consensus: ${decision}`;
+  if (reasons.length === 1) return reasons[0];
+  
+  return reasons[0] + (reasons.length > 1 ? ` (+${reasons.length - 1} more)` : '');
+};
+
+/**
+ * Calculate consensus from multiple agent responses
+ * 
+ * @param {Array} agentResponses - Array of { agentId, response, weight }
+ * @param {Object} options - Consensus options
+ * @returns {Object} Consensus result
+ */
+const calculateConsensus = (agentResponses, options = {}) => {
+  const {
+    minAgents = 1,
+    approveThreshold = 0.5,
+    rejectThreshold = 0.6,
+    minConfidence = 30
+  } = options;
+
+  // Filter valid responses
+  const validResponses = agentResponses.filter(ar => 
+    ar && ar.response && ar.response.decision
+  );
+
+  if (validResponses.length === 0) {
+    return { ...DEFAULT_CONSENSUS, reason: 'No valid agent responses' };
+  }
+
+  if (validResponses.length < minAgents) {
+    return { 
+      ...DEFAULT_CONSENSUS, 
+      reason: `Insufficient agents (${validResponses.length}/${minAgents})`,
+      agentCount: agentResponses.length,
+      respondedCount: validResponses.length
+    };
+  }
+
+  // Extract responses and weights
+  const responses = validResponses.map(ar => ar.response);
+  const weights = validResponses.map(ar => ar.weight || 100);
+  const totalWeight = weights.reduce((a, b) => a + b, 0);
+
+  // Calculate weighted votes for each decision
+  const votes = { approve: 0, reject: 0, modify: 0 };
+  for (let i = 0; i < responses.length; i++) {
+    const decision = responses[i].decision;
+    votes[decision] = (votes[decision] || 0) + weights[i];
+  }
+
+  // Normalize votes to percentages
+  const approveRatio = votes.approve / totalWeight;
+  const rejectRatio = votes.reject / totalWeight;
+  const modifyRatio = votes.modify / totalWeight;
+
+  // Determine consensus decision
+  let decision;
+  if (rejectRatio >= rejectThreshold) {
+    decision = 'reject';
+  } else if (approveRatio >= approveThreshold) {
+    decision = modifyRatio > 0 ? 'modify' : 'approve';
+  } else if (modifyRatio > approveRatio) {
+    decision = 'modify';
+  } else {
+    decision = 'approve';
+  }
+
+  // Calculate weighted confidence
+  const confidences = responses.map(r => r.confidence);
+  const avgConfidence = Math.round(weightedAverage(confidences, weights));
+
+  // Apply minimum confidence check
+  if (avgConfidence < minConfidence && decision !== 'reject') {
+    decision = 'reject';
+  }
+
+  // Check unanimity
+  const decisions = responses.map(r => r.decision);
+  const unanimous = new Set(decisions).size === 1;
+
+  // Build consensus result
+  const consensus = {
+    decision,
+    confidence: avgConfidence,
+    optimizations: decision !== 'reject' ? mergeOptimizations(responses, weights) : null,
+    reason: buildReasonSummary(responses, decision),
+    alerts: collectAlerts(responses),
+    
+    // Metadata
+    agentCount: agentResponses.length,
+    respondedCount: validResponses.length,
+    unanimous,
+    
+    // Vote breakdown
+    votes: {
+      approve: Math.round(approveRatio * 100),
+      reject: Math.round(rejectRatio * 100),
+      modify: Math.round(modifyRatio * 100)
+    },
+    
+    // Individual responses for debugging
+    agentDetails: validResponses.map(ar => ({
+      agentId: ar.agentId,
+      decision: ar.response.decision,
+      confidence: ar.response.confidence,
+      weight: ar.weight
+    }))
+  };
+
+  return consensus;
+};
+
+/**
+ * Quick check if consensus approves the signal
+ */
+const isApproved = (consensus) => {
+  return consensus.decision === 'approve' || consensus.decision === 'modify';
+};
+
+/**
+ * Apply consensus optimizations to original signal
+ */
+const applyOptimizations = (signal, consensus) => {
+  if (!isApproved(consensus) || !consensus.optimizations) {
+    return signal;
+  }
+
+  const opts = consensus.optimizations;
+  const optimized = { ...signal };
+
+  if (opts.entry !== null) optimized.entry = opts.entry;
+  if (opts.stopLoss !== null) optimized.stopLoss = opts.stopLoss;
+  if (opts.takeProfit !== null) optimized.takeProfit = opts.takeProfit;
+  
+  // Apply size adjustment
+  if (opts.size !== null && signal.size) {
+    optimized.size = Math.max(1, Math.round(signal.size * (1 + opts.size)));
+  }
+
+  optimized.aiOptimized = true;
+  optimized.aiConfidence = consensus.confidence;
+  optimized.aiTiming = opts.timing;
+
+  return optimized;
+};
+
+module.exports = {
+  calculateConsensus,
+  isApproved,
+  applyOptimizations,
+  weightedAverage,
+  weightedMode,
+  mergeOptimizations,
+  DEFAULT_CONSENSUS
+};