hedgequantx 2.6.160 → 2.6.162

package/src/pages/algo/copy-trading.js

@@ -1,15 +1,8 @@
 /**
- * @fileoverview Professional Copy Trading System
+ * @fileoverview Professional Copy Trading Menu
  * @module pages/algo/copy-trading
  * 
- * Ultra-low latency copy trading with:
- * - Fast polling (250ms adaptive)
- * - Multi-follower support
- * - Parallel order execution
- * - Automatic retry with exponential backoff
- * - Position reconciliation
- * - Slippage protection
- * - Cross-platform support (ProjectX <-> Rithmic)
+ * Copy trading configuration and session management
  */
 
 const chalk = require('chalk');
@@ -21,6 +14,7 @@ const { AlgoUI, renderSessionSummary } = require('./ui');
 const { logger, prompts } = require('../../utils');
 const { checkMarketHours } = require('../../services/projectx/market');
 const { algoLogger } = require('./logger');
+const { CopyEngine } = require('./copy-engine');
 
 // AI Strategy Supervisor
 const aiService = require('../../services/ai');
@@ -28,531 +22,6 @@ const StrategySupervisor = require('../../services/ai/strategy-supervisor');
 
 const log = logger.scope('CopyTrading');
 
-// ============================================================================
-// COPY ENGINE - Professional Order Execution
-// ============================================================================
-
-/**
- * CopyEngine - Handles all copy trading logic with professional execution
- */
-class CopyEngine {
-  constructor(config) {
-    this.lead = config.lead;
-    this.followers = config.followers; // Array of followers
-    this.symbol = config.symbol;
-    this.dailyTarget = config.dailyTarget;
-    this.maxRisk = config.maxRisk;
-    this.ui = config.ui;
-    this.stats = config.stats;
-    
-    // Engine state
-    this.running = false;
-    this.stopReason = null;
-    
-    // Position tracking
-    this.leadPositions = new Map(); // key: positionKey, value: position
-    this.followerPositions = new Map(); // key: `${followerIdx}:${posKey}`, value: position
-    this.pendingOrders = new Map(); // key: orderId, value: orderInfo
-    
-    // Order queue for sequential execution per follower
-    this.orderQueues = new Map(); // key: followerIdx, value: queue[]
-    this.processingQueue = new Map(); // key: followerIdx, value: boolean
-    
-    // Timing
-    this.pollInterval = 250; // Start at 250ms, adaptive
-    this.lastPollTime = 0;
-    this.pollCount = 0;
-    this.orderCount = 0;
-    this.failedOrders = 0;
-    this.lastLogTime = 0;
-    this.positionEntryTime = null;
-    
-    // Retry configuration
-    this.maxRetries = 3;
-    this.retryDelayBase = 100; // ms
-    
-    // Slippage protection (ticks)
-    this.maxSlippageTicks = 4;
-  }
-
-  /**
-   * Get unique position key (cross-platform compatible)
-   */
-  getPositionKey(position) {
-    return position.contractId || position.symbol || position.id;
-  }
-
-  /**
-   * Resolve symbol for target platform
-   */
-  resolveSymbol(position, targetAccount) {
-    const targetType = targetAccount.type;
-    
-    if (targetType === 'rithmic') {
-      return {
-        symbol: position.symbol || this.symbol.name,
-        exchange: position.exchange || this.symbol.exchange || 'CME',
-        contractId: null
-      };
-    } else {
-      return {
-        contractId: position.contractId || this.symbol.id || this.symbol.contractId,
-        symbol: null,
-        exchange: null
-      };
-    }
-  }
-
-  /**
-   * Build order data for specific platform
-   */
-  buildOrderData(params, platformType) {
-    const { accountId, contractId, symbol, exchange, side, size, type, price } = params;
-    
-    if (platformType === 'rithmic') {
-      return {
-        accountId,
-        symbol,
-        exchange: exchange || 'CME',
-        size,
-        side,
-        type,
-        price: price || 0
-      };
-    } else {
-      return {
-        accountId,
-        contractId,
-        type,
-        side,
-        size
-      };
-    }
-  }
-
-  /**
-   * Execute order with retry logic
-   */
-  async executeOrderWithRetry(follower, orderData, retryCount = 0) {
-    try {
-      const startTime = Date.now();
-      const result = await follower.service.placeOrder(orderData);
-      const latency = Date.now() - startTime;
-      
-      if (result.success) {
-        this.orderCount++;
-        this.stats.latency = Math.round((this.stats.latency + latency) / 2);
-        return { success: true, latency };
-      }
-      
-      // Retry on failure
-      if (retryCount < this.maxRetries) {
-        const delay = this.retryDelayBase * Math.pow(2, retryCount);
-        await this.sleep(delay);
-        return this.executeOrderWithRetry(follower, orderData, retryCount + 1);
-      }
-      
-      this.failedOrders++;
-      return { success: false, error: result.error || 'Max retries exceeded' };
-    } catch (err) {
-      if (retryCount < this.maxRetries) {
-        const delay = this.retryDelayBase * Math.pow(2, retryCount);
-        await this.sleep(delay);
-        return this.executeOrderWithRetry(follower, orderData, retryCount + 1);
-      }
-      
-      this.failedOrders++;
-      return { success: false, error: err.message };
-    }
-  }
-
-  /**
-   * Queue order for a follower (ensures sequential execution per follower)
-   */
-  async queueOrder(followerIdx, orderFn) {
-    if (!this.orderQueues.has(followerIdx)) {
-      this.orderQueues.set(followerIdx, []);
-    }
-    
-    return new Promise((resolve) => {
-      this.orderQueues.get(followerIdx).push({ fn: orderFn, resolve });
-      this.processQueue(followerIdx);
-    });
-  }
-
-  /**
-   * Process order queue for a follower
-   */
-  async processQueue(followerIdx) {
-    if (this.processingQueue.get(followerIdx)) return;
-    
-    const queue = this.orderQueues.get(followerIdx);
-    if (!queue || queue.length === 0) return;
-    
-    this.processingQueue.set(followerIdx, true);
-    
-    while (queue.length > 0 && this.running) {
-      const { fn, resolve } = queue.shift();
-      try {
-        const result = await fn();
-        resolve(result);
-      } catch (err) {
-        resolve({ success: false, error: err.message });
-      }
-    }
-    
-    this.processingQueue.set(followerIdx, false);
-  }
-
-  /**
-   * Copy position open to all followers (parallel execution)
-   */
-  async copyPositionOpen(position) {
-    const side = position.quantity > 0 ? 'LONG' : 'SHORT';
-    const orderSide = position.quantity > 0 ? 0 : 1;
-    const displaySymbol = position.symbol || this.symbol.name;
-    const size = Math.abs(position.quantity);
-    const entry = position.averagePrice || 0;
-    
-    // Track entry time for smart logs
-    this.positionEntryTime = Date.now();
-    
-    algoLogger.positionOpened(this.ui, displaySymbol, side, size, entry);
-    
-    // Feed to AI supervisor
-    if (this.stats.aiSupervision) {
-      StrategySupervisor.feedSignal({
-        direction: side.toLowerCase(),
-        entry,
-        stopLoss: null,
-        takeProfit: null,
-        confidence: 0.5
-      });
-    }
-    
-    // Execute on all followers in parallel
-    const promises = this.followers.map((follower, idx) => {
-      return this.queueOrder(idx, async () => {
-        const resolved = this.resolveSymbol(position, follower);
-        const orderData = this.buildOrderData({
-          accountId: follower.account.accountId,
-          contractId: resolved.contractId,
-          symbol: resolved.symbol,
-          exchange: resolved.exchange,
-          side: orderSide,
-          size: follower.contracts,
-          type: 2 // Market
-        }, follower.type);
-        
-        algoLogger.info(this.ui, 'COPY ORDER', `${side} ${follower.contracts}x -> ${follower.propfirm}`);
-        
-        const result = await this.executeOrderWithRetry(follower, orderData);
-        
-        if (result.success) {
-          algoLogger.orderFilled(this.ui, displaySymbol, side, follower.contracts, entry);
-          
-          // Track follower position
-          const posKey = this.getPositionKey(position);
-          this.followerPositions.set(`${idx}:${posKey}`, {
-            ...position,
-            followerIdx: idx,
-            openTime: Date.now()
-          });
-        } else {
-          algoLogger.orderRejected(this.ui, displaySymbol, result.error);
-        }
-        
-        return result;
-      });
-    });
-    
-    const results = await Promise.all(promises);
-    const successCount = results.filter(r => r.success).length;
-    
-    if (successCount === this.followers.length) {
-      algoLogger.info(this.ui, 'ALL COPIED', `${successCount}/${this.followers.length} followers`);
-    } else if (successCount > 0) {
-      algoLogger.info(this.ui, 'PARTIAL COPY', `${successCount}/${this.followers.length} followers`);
-    }
-    
-    return results;
-  }
-
-  /**
-   * Copy position close to all followers (parallel execution)
-   */
-  async copyPositionClose(position, exitPrice, pnl) {
-    const side = position.quantity > 0 ? 'LONG' : 'SHORT';
-    const closeSide = position.quantity > 0 ? 1 : 0;
-    const displaySymbol = position.symbol || this.symbol.name;
-    const size = Math.abs(position.quantity);
-    
-    // Reset entry time
-    this.positionEntryTime = null;
-    
-    algoLogger.positionClosed(this.ui, displaySymbol, side, size, exitPrice, pnl);
-    
-    // Feed to AI supervisor
-    if (this.stats.aiSupervision) {
-      StrategySupervisor.feedTradeResult({
-        side,
-        qty: size,
-        price: exitPrice,
-        pnl,
-        symbol: displaySymbol,
-        direction: side
-      });
-      
-      const aiStatus = StrategySupervisor.getStatus();
-      if (aiStatus.patternsLearned.winning + aiStatus.patternsLearned.losing > 0) {
-        algoLogger.info(this.ui, 'AI LEARNING', 
-          `${aiStatus.patternsLearned.winning}W/${aiStatus.patternsLearned.losing}L patterns`);
-      }
-    }
-    
-    // Close on all followers in parallel
-    const posKey = this.getPositionKey(position);
-    
-    const promises = this.followers.map((follower, idx) => {
-      return this.queueOrder(idx, async () => {
-        const resolved = this.resolveSymbol(position, follower);
-        const posIdentifier = follower.type === 'rithmic' 
-          ? (position.symbol || this.symbol.name)
-          : (position.contractId || this.symbol.id);
-        
-        algoLogger.info(this.ui, 'CLOSE ORDER', `${displaySymbol} -> ${follower.propfirm}`);
-        
-        // Try closePosition first
-        let result = await follower.service.closePosition(
-          follower.account.accountId,
-          posIdentifier
-        );
-        
-        if (!result.success) {
-          // Fallback: market order
-          const orderData = this.buildOrderData({
-            accountId: follower.account.accountId,
-            contractId: resolved.contractId,
-            symbol: resolved.symbol,
-            exchange: resolved.exchange,
-            side: closeSide,
-            size: follower.contracts,
-            type: 2
-          }, follower.type);
-          
-          result = await this.executeOrderWithRetry(follower, orderData);
-        }
-        
-        if (result.success) {
-          algoLogger.info(this.ui, 'CLOSED', `${displaySymbol} on ${follower.propfirm}`);
-          this.followerPositions.delete(`${idx}:${posKey}`);
-        } else {
-          algoLogger.error(this.ui, 'CLOSE FAILED', `${follower.propfirm}: ${result.error}`);
-        }
-        
-        return result;
-      });
-    });
-    
-    const results = await Promise.all(promises);
-    const successCount = results.filter(r => r.success).length;
-    
-    if (successCount === this.followers.length) {
-      this.stats.trades++;
-      this.stats.sessionPnl += pnl; // Track session P&L
-      if (pnl >= 0) this.stats.wins++;
-      else this.stats.losses++;
-    }
-    
-    return results;
-  }
-
-  /**
-   * Poll lead positions and detect changes
-   */
-  async pollLeadPositions() {
-    if (!this.running) return;
-    
-    const startTime = Date.now();
-    
-    try {
-      const result = await this.lead.service.getPositions(this.lead.account.accountId);
-      if (!result.success) return;
-      
-      const currentPositions = result.positions || [];
-      const currentMap = new Map();
-      
-      // Build current positions map
-      for (const pos of currentPositions) {
-        if (pos.quantity === 0) continue;
-        const key = this.getPositionKey(pos);
-        currentMap.set(key, pos);
-      }
-      
-      // Detect new positions (opened)
-      for (const [key, pos] of currentMap) {
-        if (!this.leadPositions.has(key)) {
-          // New position - copy to followers
-          await this.copyPositionOpen(pos);
-          this.leadPositions.set(key, pos);
-        } else {
-          // Position exists - check for size change (scaling)
-          const oldPos = this.leadPositions.get(key);
-          if (Math.abs(pos.quantity) !== Math.abs(oldPos.quantity)) {
-            // Size changed - update tracked position (scaling in/out)
-            this.leadPositions.set(key, pos);
-          }
-        }
-      }
-      
-      // Detect closed positions
-      for (const [key, oldPos] of this.leadPositions) {
-        if (!currentMap.has(key)) {
-          // Position closed - close on followers
-          const exitPrice = oldPos.averagePrice || 0;
-          const pnl = oldPos.profitAndLoss || 0;
-          await this.copyPositionClose(oldPos, exitPrice, pnl);
-          this.leadPositions.delete(key);
-        }
-      }
-      
-      // Update P&L from current positions
-      const totalPnL = currentPositions.reduce((sum, p) => sum + (p.profitAndLoss || 0), 0);
-      this.stats.pnl = totalPnL;
-      
-      // Check limits
-      if (totalPnL >= this.dailyTarget) {
-        this.stop('target');
-        algoLogger.info(this.ui, 'TARGET REACHED', `+$${totalPnL.toFixed(2)}`);
-      } else if (totalPnL <= -this.maxRisk) {
-        this.stop('risk');
-        algoLogger.error(this.ui, 'MAX RISK HIT', `-$${Math.abs(totalPnL).toFixed(2)}`);
-      }
-      
-      // Adaptive polling - faster when positions are open
-      const pollTime = Date.now() - startTime;
-      this.stats.latency = pollTime;
-      
-      if (this.leadPositions.size > 0) {
-        this.pollInterval = Math.max(100, Math.min(250, pollTime * 2));
-      } else {
-        this.pollInterval = Math.max(250, Math.min(500, pollTime * 3));
-      }
-      
-      this.pollCount++;
-      
-      // Smart logs - only on STATE CHANGES (not every second when in position)
-      const now = Date.now();
-      if (now - this.lastLogTime > 1000) {
-        const smartLogs = require('./smart-logs');
-        
-        if (this.leadPositions.size === 0) {
-          // Not in position - show market analysis (varied messages)
-          // Use scanning log since copy trading doesn't have strategy model values
-          const scanLog = smartLogs.getScanningLog(true);
-          this.ui.addLog('info', `${scanLog.message} poll #${this.pollCount} | ${pollTime}ms`);
-        }
-        // When IN POSITION: Don't spam logs every second
-        // Position updates come from order fills and exit events (copyPositionOpen/copyPositionClose)
-        this.lastLogTime = now;
-      }
-      
-    } catch (err) {
-      log.warn('Poll error', { error: err.message });
-    }
-  }
-
-  /**
-   * Reconcile follower positions with lead
-   */
-  async reconcilePositions() {
-    // Get all follower positions and compare with lead
-    for (let idx = 0; idx < this.followers.length; idx++) {
-      const follower = this.followers[idx];
-      
-      try {
-        const result = await follower.service.getPositions(follower.account.accountId);
-        if (!result.success) continue;
-        
-        const followerPositions = result.positions || [];
-        
-        // Check each lead position has corresponding follower position
-        for (const [key, leadPos] of this.leadPositions) {
-          const hasFollowerPos = followerPositions.some(fp => {
-            const fpKey = this.getPositionKey(fp);
-            return fpKey === key && fp.quantity !== 0;
-          });
-          
-          if (!hasFollowerPos) {
-            // Missing position on follower - need to open
-            algoLogger.info(this.ui, 'RECONCILE', `Missing ${key} on ${follower.propfirm}`);
-            await this.copyPositionOpen(leadPos);
-          }
-        }
-        
-        // Check for orphaned follower positions (position on follower but not on lead)
-        for (const fp of followerPositions) {
-          if (fp.quantity === 0) continue;
-          const fpKey = this.getPositionKey(fp);
-          
-          if (!this.leadPositions.has(fpKey)) {
-            // Orphaned position - close it
-            algoLogger.info(this.ui, 'RECONCILE', `Orphaned ${fpKey} on ${follower.propfirm}`);
-            
-            const posIdentifier = follower.type === 'rithmic' ? fp.symbol : fp.contractId;
-            await follower.service.closePosition(follower.account.accountId, posIdentifier);
-          }
-        }
-        
-      } catch (err) {
-        log.warn('Reconcile error', { follower: follower.propfirm, error: err.message });
-      }
-    }
-  }
-
-  /**
-   * Start the copy engine
-   */
-  async start() {
-    this.running = true;
-    this.stats.connected = true;
-    
-    algoLogger.info(this.ui, 'ENGINE STARTED', `Polling every ${this.pollInterval}ms`);
-    algoLogger.info(this.ui, 'FOLLOWERS', `${this.followers.length} account(s)`);
-    
-    // Initial reconciliation
-    await this.reconcilePositions();
-    
-    // Main polling loop
-    while (this.running) {
-      await this.pollLeadPositions();
-      await this.sleep(this.pollInterval);
-    }
-    
-    return this.stopReason;
-  }
-
-  /**
-   * Stop the copy engine
-   */
-  stop(reason = 'manual') {
-    this.running = false;
-    this.stopReason = reason;
-    this.stats.connected = false;
-  }
-
-  /**
-   * Sleep utility
-   */
-  sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-}
-
-// ============================================================================
-// COPY TRADING MENU
-// ============================================================================
-
 /**
  * Copy Trading Menu
  */
@@ -608,14 +77,14 @@ const copyTradingMenu = async () => {
       followers.length === 0 ? 'FOLLOWER ACCOUNT:' : 'ADD ANOTHER FOLLOWER:',
       allAccounts,
       excludeIndices,
-      followers.length > 0 // Allow skip if at least one follower
+      followers.length > 0
     );
     
     if (followerIdx === null || followerIdx === -1) {
-      if (followers.length === 0) return; // Cancel
+      if (followers.length === 0) return;
       selectingFollowers = false;
     } else if (followerIdx === -2) {
-      selectingFollowers = false; // Done adding
+      selectingFollowers = false;
     } else {
       followers.push(allAccounts[followerIdx]);
       excludeIndices.push(followerIdx);
@@ -725,7 +194,6 @@ const copyTradingMenu = async () => {
 const fetchAllAccounts = async (allConns) => {
   const allAccounts = [];
 
-  // Fetch in parallel
   const promises = allConns.map(async (conn) => {
     try {
       const result = await conn.service.getTradingAccounts();
@@ -813,7 +281,6 @@ const selectSymbol = async (service) => {
       return (a.name || '').localeCompare(b.name || '');
     });
 
-    // Display contracts (uniform format: NAME - DESCRIPTION)
     const options = contracts.slice(0, 30).map(c => {
       const name = c.name || c.symbol || c.baseSymbol;
       const desc = c.description || '';
@@ -868,7 +335,7 @@ const launchCopyTrading = async (config) => {
     target: dailyTarget,
     risk: maxRisk,
     pnl: 0,
-    sessionPnl: 0,         // P&L from THIS session only (HQX trades)
+    sessionPnl: 0,
     trades: 0,
     wins: 0,
     losses: 0,
@@ -878,10 +345,10 @@ const launchCopyTrading = async (config) => {
     startTime: Date.now(),
     aiSupervision: false,
     aiMode: null,
-    agentCount: 0          // Number of AI agents active
+    agentCount: 0
   };
 
-  // Initialize AI Supervisor - only if user enabled it
+  // Initialize AI Supervisor
   if (enableAI) {
     const aiAgents = aiService.getAgents();
     stats.agentCount = aiAgents.length;
@@ -905,6 +372,7 @@ const launchCopyTrading = async (config) => {
   algoLogger.info(ui, 'COPY MODE', `Lead: ${lead.propfirm} -> ${followers.length} follower(s)`);
 
   if (stats.aiSupervision) {
+    const aiAgents = aiService.getAgents();
     algoLogger.info(ui, 'AI SUPERVISION', `${aiAgents.length} agent(s) - LEARNING ACTIVE`);
   }
 
@@ -959,7 +427,7 @@ const launchCopyTrading = async (config) => {
       ? `${minutes}m ${seconds}s`
       : `${seconds}s`;
 
-  // Close log file with session summary
+  // Close log file
   try { ui.closeLog(stats); } catch {}
   
   ui.cleanup();