hedgequantx 2.3.16 → 2.3.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedgequantx",
-  "version": "2.3.16",
+  "version": "2.3.18",
   "description": "HedgeQuantX - Prop Futures Trading CLI",
   "main": "src/app.js",
   "bin": {

package/src/pages/algo/one-account.js

@@ -11,6 +11,8 @@ const { AlgoUI, renderSessionSummary } = require('./ui');
 const { prompts } = require('../../utils');
 const { checkMarketHours } = require('../../services/projectx/market');
 
+
+
 /**
  * One Account Menu
  */
@@ -154,28 +156,50 @@ const configureAlgo = async (account, contract) => {
 
 /**
  * Launch algo trading
+ * 100% API data - no simulation, no mock data, no local calculations
  */
 const launchAlgo = async (service, account, contract, config) => {
   const { contracts, dailyTarget, maxRisk, showName } = config;
-  // Use real account ID from API
-  const realAccountId = account.rithmicAccountId || account.accountName || account.accountId;
-  const accountName = showName ? realAccountId : 'HQX *****';
-  // Use RAW API field 'name' for symbol (e.g., "MESH6")
+  
+  // Use RAW API fields
+  const accountName = showName 
+    ? (account.accountName || account.rithmicAccountId || account.accountId) 
+    : 'HQX *****';
   const symbolName = contract.name;
+  const connectionType = account.platform || 'ProjectX';
   
   const ui = new AlgoUI({ subtitle: 'HQX Algo Trading', mode: 'one-account' });
   
   const stats = {
-    accountName, symbol: symbolName, contracts,
-    target: dailyTarget, risk: maxRisk,
+    accountName,
+    symbol: symbolName,
+    qty: contracts,
+    target: dailyTarget,
+    risk: maxRisk,
     propfirm: account.propfirm || 'Unknown',
-    platform: account.platform || 'ProjectX',
-    pnl: 0, trades: 0, wins: 0, losses: 0,
-    latency: 0, connected: false,
-    startTime: Date.now()  // Track start time for duration
+    platform: connectionType,
+    pnl: 0,
+    trades: 0,
+    wins: 0,
+    losses: 0,
+    latency: 0,
+    connected: true,
+    startTime: Date.now()
   };
   
-  // Measure API latency (CLI <-> API)
+  let running = true;
+  let stopReason = null;
+  let startingPnL = null; // P&L at algo start (from API)
+  let lastPositionPnL = 0;
+  
+  // Log startup info from API
+  ui.addLog('info', `Connection: ${connectionType}`);
+  ui.addLog('info', `Account: ${accountName}`);
+  ui.addLog('info', `Symbol: ${symbolName} | Qty: ${contracts}`);
+  ui.addLog('info', `Target: $${dailyTarget} | Max Risk: $${maxRisk}`);
+  ui.addLog('info', 'Monitoring positions from API...');
+  
+  // Measure API latency (real network round-trip)
   const measureLatency = async () => {
     try {
       const start = Date.now();
@@ -186,56 +210,82 @@ const launchAlgo = async (service, account, contract, config) => {
     }
   };
   
-  let running = true;
-  let stopReason = null;
-  
-  // Local algo - no external server needed
-  ui.addLog('info', `Starting algo on ${stats.platform}...`);
-  ui.addLog('info', `Symbol: ${symbolName} | Qty: ${contracts}`);
-  ui.addLog('info', `Target: $${dailyTarget} | Risk: $${maxRisk}`);
-  stats.connected = true;
-  
-  // Poll P&L from API every 2 seconds
-  const pollPnL = async () => {
+  // Poll data from API - 100% real data
+  const pollAPI = async () => {
     try {
-      // Get positions to check P&L
+      // Get account P&L from API
+      const accountResult = await service.getTradingAccounts();
+      if (accountResult.success && accountResult.accounts) {
+        const acc = accountResult.accounts.find(a => a.accountId === account.accountId);
+        if (acc && acc.profitAndLoss !== undefined) {
+          const accountPnL = acc.profitAndLoss;
+          
+          // Set starting P&L on first poll
+          if (startingPnL === null) {
+            startingPnL = accountPnL;
+            ui.addLog('info', `Starting P&L: $${startingPnL.toFixed(2)}`);
+          }
+          
+          // Session P&L = current - starting (both from API)
+          const sessionPnL = accountPnL - startingPnL;
+          stats.pnl = sessionPnL;
+        }
+      }
+      
+      // Get positions from API
       const posResult = await service.getPositions(account.accountId);
+      
       if (posResult.success && posResult.positions) {
-        // Find position for our symbol
-        const pos = posResult.positions.find(p => 
-          (p.contractId || p.symbol || '').includes(contract.name || contract.symbol)
-        );
-        if (pos && pos.profitAndLoss !== undefined) {
-          const prevPnL = stats.pnl;
-          stats.pnl = pos.profitAndLoss;
+        // Find position for selected contract
+        const position = posResult.positions.find(p => {
+          const posSymbol = p.contractId || p.symbol || '';
+          return posSymbol.includes(contract.name) || posSymbol.includes(contract.id);
+        });
+        
+        if (position) {
+          const positionPnL = position.profitAndLoss || 0;
           
-          // Detect trade completion
-          if (Math.abs(stats.pnl - prevPnL) > 0.01 && prevPnL !== 0) {
-            const tradePnL = stats.pnl - prevPnL;
+          // Detect trade completion (position P&L changed significantly)
+          if (lastPositionPnL !== 0 && Math.abs(positionPnL - lastPositionPnL) > 0.01) {
+            const tradePnL = positionPnL - lastPositionPnL;
             stats.trades++;
-            if (tradePnL >= 0) {
+            
+            if (tradePnL > 0) {
               stats.wins++;
-              ui.addLog('trade', `Trade closed: +$${tradePnL.toFixed(2)}`);
+              ui.addLog('trade', `+$${tradePnL.toFixed(2)}`);
             } else {
               stats.losses++;
-              ui.addLog('loss', `Trade closed: -$${Math.abs(tradePnL).toFixed(2)}`);
+              ui.addLog('loss', `-$${Math.abs(tradePnL).toFixed(2)}`);
             }
           }
+          
+          lastPositionPnL = positionPnL;
+          
+          // Log position info from API
+          if (position.quantity && position.quantity !== 0) {
+            const side = position.quantity > 0 ? 'LONG' : 'SHORT';
+            const qty = Math.abs(position.quantity);
+            ui.addLog('info', `${side} ${qty}x @ P&L: $${positionPnL.toFixed(2)}`);
+          }
+        } else {
+          // No position for this symbol
+          lastPositionPnL = 0;
         }
       }
       
-      // Check target/risk limits
+      // Check target/risk limits (using SESSION P&L, not account total)
       if (stats.pnl >= dailyTarget) {
         stopReason = 'target';
         running = false;
-        ui.addLog('success', `TARGET REACHED! +$${stats.pnl.toFixed(2)}`);
+        ui.addLog('success', `SESSION TARGET! +$${stats.pnl.toFixed(2)}`);
       } else if (stats.pnl <= -maxRisk) {
         stopReason = 'risk';
         running = false;
-        ui.addLog('error', `MAX RISK HIT! -$${Math.abs(stats.pnl).toFixed(2)}`);
+        ui.addLog('error', `SESSION MAX RISK! -$${Math.abs(stats.pnl).toFixed(2)}`);
       }
+      
     } catch (e) {
-      // Silent fail - will retry
+      ui.addLog('error', `API: ${e.message}`);
     }
   };
   
@@ -245,9 +295,9 @@ const launchAlgo = async (service, account, contract, config) => {
   measureLatency(); // Initial measurement
   const latencyInterval = setInterval(() => { if (running) measureLatency(); }, 5000);
   
-  // Poll P&L from API every 2 seconds
-  pollPnL(); // Initial poll
-  const pnlInterval = setInterval(() => { if (running) pollPnL(); }, 2000);
+  // Poll data from API every 2 seconds
+  pollAPI(); // Initial poll
+  const apiInterval = setInterval(() => { if (running) pollAPI(); }, 2000);
   
   // Keyboard
   const setupKeyHandler = () => {
@@ -276,7 +326,7 @@ const launchAlgo = async (service, account, contract, config) => {
   
   clearInterval(refreshInterval);
   clearInterval(latencyInterval);
-  clearInterval(pnlInterval);
+  clearInterval(apiInterval);
   if (cleanupKeys) cleanupKeys();
   ui.cleanup();